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 35 struct 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 */ 49 static 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 62 static 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 88 static 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 99 static void ad198x_power_eapd(struct hda_codec *codec) 100 { 101 /* We currently only handle front, HP */ 102 switch (codec->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 127 static 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 134 static 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 */ 142 static 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 160 static 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 173 static 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 187 static 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 217 static 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 */ 234 static 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 */ 248 static 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) */ 261 static 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 272 enum { 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 284 static 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 372 static 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 390 static 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 */ 401 static 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 */ 462 static 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 480 static 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 490 static 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 509 static 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 517 static 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 533 static 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 571 static 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 */ 585 static 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 596 enum { 597 AD1981_FIXUP_AMP_OVERRIDE, 598 AD1981_FIXUP_HP_EAPD, 599 }; 600 601 static 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 614 static 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 623 static 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 742 #ifdef ENABLE_AD_STATIC_QUIRKS 743 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol, 744 struct snd_ctl_elem_info *uinfo) 745 { 746 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 747 struct ad198x_spec *spec = codec->spec; 748 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode, 749 spec->num_channel_mode); 750 } 751 752 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol, 753 struct snd_ctl_elem_value *ucontrol) 754 { 755 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 756 struct ad198x_spec *spec = codec->spec; 757 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode, 758 spec->num_channel_mode, spec->multiout.max_channels); 759 } 760 761 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol, 762 struct snd_ctl_elem_value *ucontrol) 763 { 764 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 765 struct ad198x_spec *spec = codec->spec; 766 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode, 767 spec->num_channel_mode, 768 &spec->multiout.max_channels); 769 if (err >= 0 && spec->need_dac_fix) 770 spec->multiout.num_dacs = spec->multiout.max_channels / 2; 771 return err; 772 } 773 #endif /* ENABLE_AD_STATIC_QUIRKS */ 774 775 static int ad1988_auto_smux_enum_info(struct snd_kcontrol *kcontrol, 776 struct snd_ctl_elem_info *uinfo) 777 { 778 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 779 static const char * const texts[] = { 780 "PCM", "ADC1", "ADC2", "ADC3", 781 }; 782 int num_conns = snd_hda_get_num_conns(codec, 0x0b) + 1; 783 if (num_conns > 4) 784 num_conns = 4; 785 return snd_hda_enum_helper_info(kcontrol, uinfo, num_conns, texts); 786 } 787 788 static int ad1988_auto_smux_enum_get(struct snd_kcontrol *kcontrol, 789 struct snd_ctl_elem_value *ucontrol) 790 { 791 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 792 struct ad198x_spec *spec = codec->spec; 793 794 ucontrol->value.enumerated.item[0] = spec->cur_smux; 795 return 0; 796 } 797 798 static int ad1988_auto_smux_enum_put(struct snd_kcontrol *kcontrol, 799 struct snd_ctl_elem_value *ucontrol) 800 { 801 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 802 struct ad198x_spec *spec = codec->spec; 803 unsigned int val = ucontrol->value.enumerated.item[0]; 804 struct nid_path *path; 805 int num_conns = snd_hda_get_num_conns(codec, 0x0b) + 1; 806 807 if (val >= num_conns) 808 return -EINVAL; 809 if (spec->cur_smux == val) 810 return 0; 811 812 mutex_lock(&codec->control_mutex); 813 codec->cached_write = 1; 814 path = snd_hda_get_path_from_idx(codec, 815 spec->smux_paths[spec->cur_smux]); 816 if (path) 817 snd_hda_activate_path(codec, path, false, true); 818 path = snd_hda_get_path_from_idx(codec, spec->smux_paths[val]); 819 if (path) 820 snd_hda_activate_path(codec, path, true, true); 821 spec->cur_smux = val; 822 codec->cached_write = 0; 823 mutex_unlock(&codec->control_mutex); 824 snd_hda_codec_flush_cache(codec); /* flush the updates */ 825 return 1; 826 } 827 828 static struct snd_kcontrol_new ad1988_auto_smux_mixer = { 829 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 830 .name = "IEC958 Playback Source", 831 .info = ad1988_auto_smux_enum_info, 832 .get = ad1988_auto_smux_enum_get, 833 .put = ad1988_auto_smux_enum_put, 834 }; 835 836 static int ad1988_auto_init(struct hda_codec *codec) 837 { 838 struct ad198x_spec *spec = codec->spec; 839 int i, err; 840 841 err = snd_hda_gen_init(codec); 842 if (err < 0) 843 return err; 844 if (!spec->gen.autocfg.dig_outs) 845 return 0; 846 847 for (i = 0; i < 4; i++) { 848 struct nid_path *path; 849 path = snd_hda_get_path_from_idx(codec, spec->smux_paths[i]); 850 if (path) 851 snd_hda_activate_path(codec, path, path->active, false); 852 } 853 854 return 0; 855 } 856 857 static int ad1988_add_spdif_mux_ctl(struct hda_codec *codec) 858 { 859 struct ad198x_spec *spec = codec->spec; 860 int i, num_conns; 861 /* we create four static faked paths, since AD codecs have odd 862 * widget connections regarding the SPDIF out source 863 */ 864 static struct nid_path fake_paths[4] = { 865 { 866 .depth = 3, 867 .path = { 0x02, 0x1d, 0x1b }, 868 .idx = { 0, 0, 0 }, 869 .multi = { 0, 0, 0 }, 870 }, 871 { 872 .depth = 4, 873 .path = { 0x08, 0x0b, 0x1d, 0x1b }, 874 .idx = { 0, 0, 1, 0 }, 875 .multi = { 0, 1, 0, 0 }, 876 }, 877 { 878 .depth = 4, 879 .path = { 0x09, 0x0b, 0x1d, 0x1b }, 880 .idx = { 0, 1, 1, 0 }, 881 .multi = { 0, 1, 0, 0 }, 882 }, 883 { 884 .depth = 4, 885 .path = { 0x0f, 0x0b, 0x1d, 0x1b }, 886 .idx = { 0, 2, 1, 0 }, 887 .multi = { 0, 1, 0, 0 }, 888 }, 889 }; 890 891 /* SPDIF source mux appears to be present only on AD1988A */ 892 if (!spec->gen.autocfg.dig_outs || 893 get_wcaps_type(get_wcaps(codec, 0x1d)) != AC_WID_AUD_MIX) 894 return 0; 895 896 num_conns = snd_hda_get_num_conns(codec, 0x0b) + 1; 897 if (num_conns != 3 && num_conns != 4) 898 return 0; 899 900 for (i = 0; i < num_conns; i++) { 901 struct nid_path *path = snd_array_new(&spec->gen.paths); 902 if (!path) 903 return -ENOMEM; 904 *path = fake_paths[i]; 905 if (!i) 906 path->active = 1; 907 spec->smux_paths[i] = snd_hda_get_path_idx(codec, path); 908 } 909 910 if (!snd_hda_gen_add_kctl(&spec->gen, NULL, &ad1988_auto_smux_mixer)) 911 return -ENOMEM; 912 913 codec->patch_ops.init = ad1988_auto_init; 914 915 return 0; 916 } 917 918 /* 919 */ 920 921 enum { 922 AD1988_FIXUP_6STACK_DIG, 923 }; 924 925 static const struct hda_fixup ad1988_fixups[] = { 926 [AD1988_FIXUP_6STACK_DIG] = { 927 .type = HDA_FIXUP_PINS, 928 .v.pins = (const struct hda_pintbl[]) { 929 { 0x11, 0x02214130 }, /* front-hp */ 930 { 0x12, 0x01014010 }, /* line-out */ 931 { 0x14, 0x02a19122 }, /* front-mic */ 932 { 0x15, 0x01813021 }, /* line-in */ 933 { 0x16, 0x01011012 }, /* line-out */ 934 { 0x17, 0x01a19020 }, /* mic */ 935 { 0x1b, 0x0145f1f0 }, /* SPDIF */ 936 { 0x24, 0x01016011 }, /* line-out */ 937 { 0x25, 0x01012013 }, /* line-out */ 938 { } 939 } 940 }, 941 }; 942 943 static const struct hda_model_fixup ad1988_fixup_models[] = { 944 { .id = AD1988_FIXUP_6STACK_DIG, .name = "6stack-dig" }, 945 {} 946 }; 947 948 static int patch_ad1988(struct hda_codec *codec) 949 { 950 struct ad198x_spec *spec; 951 int err; 952 953 err = alloc_ad_spec(codec); 954 if (err < 0) 955 return err; 956 spec = codec->spec; 957 958 spec->gen.mixer_nid = 0x20; 959 spec->gen.mixer_merge_nid = 0x21; 960 spec->gen.beep_nid = 0x10; 961 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT); 962 963 snd_hda_pick_fixup(codec, ad1988_fixup_models, NULL, ad1988_fixups); 964 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 965 966 err = ad198x_parse_auto_config(codec, true); 967 if (err < 0) 968 goto error; 969 err = ad1988_add_spdif_mux_ctl(codec); 970 if (err < 0) 971 goto error; 972 973 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 974 975 return 0; 976 977 error: 978 snd_hda_gen_free(codec); 979 return err; 980 } 981 982 983 /* 984 * AD1884 / AD1984 985 * 986 * port-B - front line/mic-in 987 * port-E - aux in/out 988 * port-F - aux in/out 989 * port-C - rear line/mic-in 990 * port-D - rear line/hp-out 991 * port-A - front line/hp-out 992 * 993 * AD1984 = AD1884 + two digital mic-ins 994 * 995 * AD1883 / AD1884A / AD1984A / AD1984B 996 * 997 * port-B (0x14) - front mic-in 998 * port-E (0x1c) - rear mic-in 999 * port-F (0x16) - CD / ext out 1000 * port-C (0x15) - rear line-in 1001 * port-D (0x12) - rear line-out 1002 * port-A (0x11) - front hp-out 1003 * 1004 * AD1984A = AD1884A + digital-mic 1005 * AD1883 = equivalent with AD1984A 1006 * AD1984B = AD1984A + extra SPDIF-out 1007 */ 1008 1009 /* set the upper-limit for mixer amp to 0dB for avoiding the possible 1010 * damage by overloading 1011 */ 1012 static void ad1884_fixup_amp_override(struct hda_codec *codec, 1013 const struct hda_fixup *fix, int action) 1014 { 1015 if (action == HDA_FIXUP_ACT_PRE_PROBE) 1016 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT, 1017 (0x17 << AC_AMPCAP_OFFSET_SHIFT) | 1018 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) | 1019 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) | 1020 (1 << AC_AMPCAP_MUTE_SHIFT)); 1021 } 1022 1023 /* toggle GPIO1 according to the mute state */ 1024 static void ad1884_vmaster_hp_gpio_hook(void *private_data, int enabled) 1025 { 1026 struct hda_codec *codec = private_data; 1027 struct ad198x_spec *spec = codec->spec; 1028 1029 if (spec->eapd_nid) 1030 ad_vmaster_eapd_hook(private_data, enabled); 1031 snd_hda_codec_update_cache(codec, 0x01, 0, 1032 AC_VERB_SET_GPIO_DATA, 1033 enabled ? 0x00 : 0x02); 1034 } 1035 1036 static void ad1884_fixup_hp_eapd(struct hda_codec *codec, 1037 const struct hda_fixup *fix, int action) 1038 { 1039 struct ad198x_spec *spec = codec->spec; 1040 static const struct hda_verb gpio_init_verbs[] = { 1041 {0x01, AC_VERB_SET_GPIO_MASK, 0x02}, 1042 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02}, 1043 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, 1044 {}, 1045 }; 1046 1047 switch (action) { 1048 case HDA_FIXUP_ACT_PRE_PROBE: 1049 spec->gen.vmaster_mute.hook = ad1884_vmaster_hp_gpio_hook; 1050 spec->gen.own_eapd_ctl = 1; 1051 snd_hda_sequence_write_cache(codec, gpio_init_verbs); 1052 break; 1053 case HDA_FIXUP_ACT_PROBE: 1054 if (spec->gen.autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT) 1055 spec->eapd_nid = spec->gen.autocfg.line_out_pins[0]; 1056 else 1057 spec->eapd_nid = spec->gen.autocfg.speaker_pins[0]; 1058 break; 1059 } 1060 } 1061 1062 static void ad1884_fixup_thinkpad(struct hda_codec *codec, 1063 const struct hda_fixup *fix, int action) 1064 { 1065 struct ad198x_spec *spec = codec->spec; 1066 1067 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1068 spec->gen.keep_eapd_on = 1; 1069 spec->gen.vmaster_mute.hook = ad_vmaster_eapd_hook; 1070 spec->eapd_nid = 0x12; 1071 /* Analog PC Beeper - allow firmware/ACPI beeps */ 1072 spec->beep_amp = HDA_COMPOSE_AMP_VAL(0x20, 3, 3, HDA_INPUT); 1073 spec->gen.beep_nid = 0; /* no digital beep */ 1074 } 1075 } 1076 1077 /* set magic COEFs for dmic */ 1078 static const struct hda_verb ad1884_dmic_init_verbs[] = { 1079 {0x01, AC_VERB_SET_COEF_INDEX, 0x13f7}, 1080 {0x01, AC_VERB_SET_PROC_COEF, 0x08}, 1081 {} 1082 }; 1083 1084 enum { 1085 AD1884_FIXUP_AMP_OVERRIDE, 1086 AD1884_FIXUP_HP_EAPD, 1087 AD1884_FIXUP_DMIC_COEF, 1088 AD1884_FIXUP_THINKPAD, 1089 AD1884_FIXUP_HP_TOUCHSMART, 1090 }; 1091 1092 static const struct hda_fixup ad1884_fixups[] = { 1093 [AD1884_FIXUP_AMP_OVERRIDE] = { 1094 .type = HDA_FIXUP_FUNC, 1095 .v.func = ad1884_fixup_amp_override, 1096 }, 1097 [AD1884_FIXUP_HP_EAPD] = { 1098 .type = HDA_FIXUP_FUNC, 1099 .v.func = ad1884_fixup_hp_eapd, 1100 .chained = true, 1101 .chain_id = AD1884_FIXUP_AMP_OVERRIDE, 1102 }, 1103 [AD1884_FIXUP_DMIC_COEF] = { 1104 .type = HDA_FIXUP_VERBS, 1105 .v.verbs = ad1884_dmic_init_verbs, 1106 }, 1107 [AD1884_FIXUP_THINKPAD] = { 1108 .type = HDA_FIXUP_FUNC, 1109 .v.func = ad1884_fixup_thinkpad, 1110 .chained = true, 1111 .chain_id = AD1884_FIXUP_DMIC_COEF, 1112 }, 1113 [AD1884_FIXUP_HP_TOUCHSMART] = { 1114 .type = HDA_FIXUP_VERBS, 1115 .v.verbs = ad1884_dmic_init_verbs, 1116 .chained = true, 1117 .chain_id = AD1884_FIXUP_HP_EAPD, 1118 }, 1119 }; 1120 1121 static const struct snd_pci_quirk ad1884_fixup_tbl[] = { 1122 SND_PCI_QUIRK(0x103c, 0x2a82, "HP Touchsmart", AD1884_FIXUP_HP_TOUCHSMART), 1123 SND_PCI_QUIRK_VENDOR(0x103c, "HP", AD1884_FIXUP_HP_EAPD), 1124 SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo Thinkpad", AD1884_FIXUP_THINKPAD), 1125 {} 1126 }; 1127 1128 1129 static int patch_ad1884(struct hda_codec *codec) 1130 { 1131 struct ad198x_spec *spec; 1132 int err; 1133 1134 err = alloc_ad_spec(codec); 1135 if (err < 0) 1136 return err; 1137 spec = codec->spec; 1138 1139 spec->gen.mixer_nid = 0x20; 1140 spec->gen.mixer_merge_nid = 0x21; 1141 spec->gen.beep_nid = 0x10; 1142 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT); 1143 1144 snd_hda_pick_fixup(codec, NULL, ad1884_fixup_tbl, ad1884_fixups); 1145 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 1146 1147 err = ad198x_parse_auto_config(codec, true); 1148 if (err < 0) 1149 goto error; 1150 err = ad1983_add_spdif_mux_ctl(codec); 1151 if (err < 0) 1152 goto error; 1153 1154 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 1155 1156 return 0; 1157 1158 error: 1159 snd_hda_gen_free(codec); 1160 return err; 1161 } 1162 1163 /* 1164 * AD1882 / AD1882A 1165 * 1166 * port-A - front hp-out 1167 * port-B - front mic-in 1168 * port-C - rear line-in, shared surr-out (3stack) 1169 * port-D - rear line-out 1170 * port-E - rear mic-in, shared clfe-out (3stack) 1171 * port-F - rear surr-out (6stack) 1172 * port-G - rear clfe-out (6stack) 1173 */ 1174 1175 static int patch_ad1882(struct hda_codec *codec) 1176 { 1177 struct ad198x_spec *spec; 1178 int err; 1179 1180 err = alloc_ad_spec(codec); 1181 if (err < 0) 1182 return err; 1183 spec = codec->spec; 1184 1185 spec->gen.mixer_nid = 0x20; 1186 spec->gen.mixer_merge_nid = 0x21; 1187 spec->gen.beep_nid = 0x10; 1188 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT); 1189 err = ad198x_parse_auto_config(codec, true); 1190 if (err < 0) 1191 goto error; 1192 err = ad1988_add_spdif_mux_ctl(codec); 1193 if (err < 0) 1194 goto error; 1195 return 0; 1196 1197 error: 1198 snd_hda_gen_free(codec); 1199 return err; 1200 } 1201 1202 1203 /* 1204 * patch entries 1205 */ 1206 static const struct hda_codec_preset snd_hda_preset_analog[] = { 1207 { .id = 0x11d4184a, .name = "AD1884A", .patch = patch_ad1884 }, 1208 { .id = 0x11d41882, .name = "AD1882", .patch = patch_ad1882 }, 1209 { .id = 0x11d41883, .name = "AD1883", .patch = patch_ad1884 }, 1210 { .id = 0x11d41884, .name = "AD1884", .patch = patch_ad1884 }, 1211 { .id = 0x11d4194a, .name = "AD1984A", .patch = patch_ad1884 }, 1212 { .id = 0x11d4194b, .name = "AD1984B", .patch = patch_ad1884 }, 1213 { .id = 0x11d41981, .name = "AD1981", .patch = patch_ad1981 }, 1214 { .id = 0x11d41983, .name = "AD1983", .patch = patch_ad1983 }, 1215 { .id = 0x11d41984, .name = "AD1984", .patch = patch_ad1884 }, 1216 { .id = 0x11d41986, .name = "AD1986A", .patch = patch_ad1986a }, 1217 { .id = 0x11d41988, .name = "AD1988", .patch = patch_ad1988 }, 1218 { .id = 0x11d4198b, .name = "AD1988B", .patch = patch_ad1988 }, 1219 { .id = 0x11d4882a, .name = "AD1882A", .patch = patch_ad1882 }, 1220 { .id = 0x11d4989a, .name = "AD1989A", .patch = patch_ad1988 }, 1221 { .id = 0x11d4989b, .name = "AD1989B", .patch = patch_ad1988 }, 1222 {} /* terminator */ 1223 }; 1224 1225 MODULE_ALIAS("snd-hda-codec-id:11d4*"); 1226 1227 MODULE_LICENSE("GPL"); 1228 MODULE_DESCRIPTION("Analog Devices HD-audio codec"); 1229 1230 static struct hda_codec_preset_list analog_list = { 1231 .preset = snd_hda_preset_analog, 1232 .owner = THIS_MODULE, 1233 }; 1234 1235 static int __init patch_analog_init(void) 1236 { 1237 return snd_hda_add_codec_preset(&analog_list); 1238 } 1239 1240 static void __exit patch_analog_exit(void) 1241 { 1242 snd_hda_delete_codec_preset(&analog_list); 1243 } 1244 1245 module_init(patch_analog_init) 1246 module_exit(patch_analog_exit) 1247