1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Universal Interface for Intel High Definition Audio Codec 4 * 5 * HD audio interface patch for Realtek ALC codecs 6 * 7 * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw> 8 * PeiSen Hou <pshou@realtek.com.tw> 9 * Takashi Iwai <tiwai@suse.de> 10 * Jonathan Woithe <jwoithe@just42.net> 11 */ 12 13 #include <linux/init.h> 14 #include <linux/delay.h> 15 #include <linux/slab.h> 16 #include <linux/pci.h> 17 #include <linux/dmi.h> 18 #include <linux/module.h> 19 #include <linux/input.h> 20 #include <linux/leds.h> 21 #include <sound/core.h> 22 #include <sound/jack.h> 23 #include <sound/hda_codec.h> 24 #include "hda_local.h" 25 #include "hda_auto_parser.h" 26 #include "hda_jack.h" 27 #include "hda_generic.h" 28 29 /* keep halting ALC5505 DSP, for power saving */ 30 #define HALT_REALTEK_ALC5505 31 32 /* extra amp-initialization sequence types */ 33 enum { 34 ALC_INIT_UNDEFINED, 35 ALC_INIT_NONE, 36 ALC_INIT_DEFAULT, 37 }; 38 39 enum { 40 ALC_HEADSET_MODE_UNKNOWN, 41 ALC_HEADSET_MODE_UNPLUGGED, 42 ALC_HEADSET_MODE_HEADSET, 43 ALC_HEADSET_MODE_MIC, 44 ALC_HEADSET_MODE_HEADPHONE, 45 }; 46 47 enum { 48 ALC_HEADSET_TYPE_UNKNOWN, 49 ALC_HEADSET_TYPE_CTIA, 50 ALC_HEADSET_TYPE_OMTP, 51 }; 52 53 enum { 54 ALC_KEY_MICMUTE_INDEX, 55 }; 56 57 struct alc_customize_define { 58 unsigned int sku_cfg; 59 unsigned char port_connectivity; 60 unsigned char check_sum; 61 unsigned char customization; 62 unsigned char external_amp; 63 unsigned int enable_pcbeep:1; 64 unsigned int platform_type:1; 65 unsigned int swap:1; 66 unsigned int override:1; 67 unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */ 68 }; 69 70 struct alc_coef_led { 71 unsigned int idx; 72 unsigned int mask; 73 unsigned int on; 74 unsigned int off; 75 }; 76 77 struct alc_spec { 78 struct hda_gen_spec gen; /* must be at head */ 79 80 /* codec parameterization */ 81 struct alc_customize_define cdefine; 82 unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */ 83 84 /* GPIO bits */ 85 unsigned int gpio_mask; 86 unsigned int gpio_dir; 87 unsigned int gpio_data; 88 bool gpio_write_delay; /* add a delay before writing gpio_data */ 89 90 /* mute LED for HP laptops, see vref_mute_led_set() */ 91 int mute_led_polarity; 92 int micmute_led_polarity; 93 hda_nid_t mute_led_nid; 94 hda_nid_t cap_mute_led_nid; 95 96 unsigned int gpio_mute_led_mask; 97 unsigned int gpio_mic_led_mask; 98 struct alc_coef_led mute_led_coef; 99 struct alc_coef_led mic_led_coef; 100 101 hda_nid_t headset_mic_pin; 102 hda_nid_t headphone_mic_pin; 103 int current_headset_mode; 104 int current_headset_type; 105 106 /* hooks */ 107 void (*init_hook)(struct hda_codec *codec); 108 #ifdef CONFIG_PM 109 void (*power_hook)(struct hda_codec *codec); 110 #endif 111 void (*shutup)(struct hda_codec *codec); 112 void (*reboot_notify)(struct hda_codec *codec); 113 114 int init_amp; 115 int codec_variant; /* flag for other variants */ 116 unsigned int has_alc5505_dsp:1; 117 unsigned int no_depop_delay:1; 118 unsigned int done_hp_init:1; 119 unsigned int no_shutup_pins:1; 120 unsigned int ultra_low_power:1; 121 unsigned int has_hs_key:1; 122 123 /* for PLL fix */ 124 hda_nid_t pll_nid; 125 unsigned int pll_coef_idx, pll_coef_bit; 126 unsigned int coef0; 127 struct input_dev *kb_dev; 128 u8 alc_mute_keycode_map[1]; 129 }; 130 131 /* 132 * COEF access helper functions 133 */ 134 135 static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid, 136 unsigned int coef_idx) 137 { 138 unsigned int val; 139 140 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx); 141 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0); 142 return val; 143 } 144 145 #define alc_read_coef_idx(codec, coef_idx) \ 146 alc_read_coefex_idx(codec, 0x20, coef_idx) 147 148 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid, 149 unsigned int coef_idx, unsigned int coef_val) 150 { 151 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx); 152 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val); 153 } 154 155 #define alc_write_coef_idx(codec, coef_idx, coef_val) \ 156 alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val) 157 158 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid, 159 unsigned int coef_idx, unsigned int mask, 160 unsigned int bits_set) 161 { 162 unsigned int val = alc_read_coefex_idx(codec, nid, coef_idx); 163 164 if (val != -1) 165 alc_write_coefex_idx(codec, nid, coef_idx, 166 (val & ~mask) | bits_set); 167 } 168 169 #define alc_update_coef_idx(codec, coef_idx, mask, bits_set) \ 170 alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set) 171 172 /* a special bypass for COEF 0; read the cached value at the second time */ 173 static unsigned int alc_get_coef0(struct hda_codec *codec) 174 { 175 struct alc_spec *spec = codec->spec; 176 177 if (!spec->coef0) 178 spec->coef0 = alc_read_coef_idx(codec, 0); 179 return spec->coef0; 180 } 181 182 /* coef writes/updates batch */ 183 struct coef_fw { 184 unsigned char nid; 185 unsigned char idx; 186 unsigned short mask; 187 unsigned short val; 188 }; 189 190 #define UPDATE_COEFEX(_nid, _idx, _mask, _val) \ 191 { .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) } 192 #define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val) 193 #define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val) 194 #define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val) 195 196 static void alc_process_coef_fw(struct hda_codec *codec, 197 const struct coef_fw *fw) 198 { 199 for (; fw->nid; fw++) { 200 if (fw->mask == (unsigned short)-1) 201 alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val); 202 else 203 alc_update_coefex_idx(codec, fw->nid, fw->idx, 204 fw->mask, fw->val); 205 } 206 } 207 208 /* 209 * GPIO setup tables, used in initialization 210 */ 211 212 /* Enable GPIO mask and set output */ 213 static void alc_setup_gpio(struct hda_codec *codec, unsigned int mask) 214 { 215 struct alc_spec *spec = codec->spec; 216 217 spec->gpio_mask |= mask; 218 spec->gpio_dir |= mask; 219 spec->gpio_data |= mask; 220 } 221 222 static void alc_write_gpio_data(struct hda_codec *codec) 223 { 224 struct alc_spec *spec = codec->spec; 225 226 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 227 spec->gpio_data); 228 } 229 230 static void alc_update_gpio_data(struct hda_codec *codec, unsigned int mask, 231 bool on) 232 { 233 struct alc_spec *spec = codec->spec; 234 unsigned int oldval = spec->gpio_data; 235 236 if (on) 237 spec->gpio_data |= mask; 238 else 239 spec->gpio_data &= ~mask; 240 if (oldval != spec->gpio_data) 241 alc_write_gpio_data(codec); 242 } 243 244 static void alc_write_gpio(struct hda_codec *codec) 245 { 246 struct alc_spec *spec = codec->spec; 247 248 if (!spec->gpio_mask) 249 return; 250 251 snd_hda_codec_write(codec, codec->core.afg, 0, 252 AC_VERB_SET_GPIO_MASK, spec->gpio_mask); 253 snd_hda_codec_write(codec, codec->core.afg, 0, 254 AC_VERB_SET_GPIO_DIRECTION, spec->gpio_dir); 255 if (spec->gpio_write_delay) 256 msleep(1); 257 alc_write_gpio_data(codec); 258 } 259 260 static void alc_fixup_gpio(struct hda_codec *codec, int action, 261 unsigned int mask) 262 { 263 if (action == HDA_FIXUP_ACT_PRE_PROBE) 264 alc_setup_gpio(codec, mask); 265 } 266 267 static void alc_fixup_gpio1(struct hda_codec *codec, 268 const struct hda_fixup *fix, int action) 269 { 270 alc_fixup_gpio(codec, action, 0x01); 271 } 272 273 static void alc_fixup_gpio2(struct hda_codec *codec, 274 const struct hda_fixup *fix, int action) 275 { 276 alc_fixup_gpio(codec, action, 0x02); 277 } 278 279 static void alc_fixup_gpio3(struct hda_codec *codec, 280 const struct hda_fixup *fix, int action) 281 { 282 alc_fixup_gpio(codec, action, 0x03); 283 } 284 285 static void alc_fixup_gpio4(struct hda_codec *codec, 286 const struct hda_fixup *fix, int action) 287 { 288 alc_fixup_gpio(codec, action, 0x04); 289 } 290 291 static void alc_fixup_micmute_led(struct hda_codec *codec, 292 const struct hda_fixup *fix, int action) 293 { 294 if (action == HDA_FIXUP_ACT_PROBE) 295 snd_hda_gen_add_micmute_led_cdev(codec, NULL); 296 } 297 298 /* 299 * Fix hardware PLL issue 300 * On some codecs, the analog PLL gating control must be off while 301 * the default value is 1. 302 */ 303 static void alc_fix_pll(struct hda_codec *codec) 304 { 305 struct alc_spec *spec = codec->spec; 306 307 if (spec->pll_nid) 308 alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx, 309 1 << spec->pll_coef_bit, 0); 310 } 311 312 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid, 313 unsigned int coef_idx, unsigned int coef_bit) 314 { 315 struct alc_spec *spec = codec->spec; 316 spec->pll_nid = nid; 317 spec->pll_coef_idx = coef_idx; 318 spec->pll_coef_bit = coef_bit; 319 alc_fix_pll(codec); 320 } 321 322 /* update the master volume per volume-knob's unsol event */ 323 static void alc_update_knob_master(struct hda_codec *codec, 324 struct hda_jack_callback *jack) 325 { 326 unsigned int val; 327 struct snd_kcontrol *kctl; 328 struct snd_ctl_elem_value *uctl; 329 330 kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume"); 331 if (!kctl) 332 return; 333 uctl = kzalloc(sizeof(*uctl), GFP_KERNEL); 334 if (!uctl) 335 return; 336 val = snd_hda_codec_read(codec, jack->nid, 0, 337 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0); 338 val &= HDA_AMP_VOLMASK; 339 uctl->value.integer.value[0] = val; 340 uctl->value.integer.value[1] = val; 341 kctl->put(kctl, uctl); 342 kfree(uctl); 343 } 344 345 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res) 346 { 347 /* For some reason, the res given from ALC880 is broken. 348 Here we adjust it properly. */ 349 snd_hda_jack_unsol_event(codec, res >> 2); 350 } 351 352 /* Change EAPD to verb control */ 353 static void alc_fill_eapd_coef(struct hda_codec *codec) 354 { 355 int coef; 356 357 coef = alc_get_coef0(codec); 358 359 switch (codec->core.vendor_id) { 360 case 0x10ec0262: 361 alc_update_coef_idx(codec, 0x7, 0, 1<<5); 362 break; 363 case 0x10ec0267: 364 case 0x10ec0268: 365 alc_update_coef_idx(codec, 0x7, 0, 1<<13); 366 break; 367 case 0x10ec0269: 368 if ((coef & 0x00f0) == 0x0010) 369 alc_update_coef_idx(codec, 0xd, 0, 1<<14); 370 if ((coef & 0x00f0) == 0x0020) 371 alc_update_coef_idx(codec, 0x4, 1<<15, 0); 372 if ((coef & 0x00f0) == 0x0030) 373 alc_update_coef_idx(codec, 0x10, 1<<9, 0); 374 break; 375 case 0x10ec0280: 376 case 0x10ec0284: 377 case 0x10ec0290: 378 case 0x10ec0292: 379 alc_update_coef_idx(codec, 0x4, 1<<15, 0); 380 break; 381 case 0x10ec0225: 382 case 0x10ec0295: 383 case 0x10ec0299: 384 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000); 385 fallthrough; 386 case 0x10ec0215: 387 case 0x10ec0233: 388 case 0x10ec0235: 389 case 0x10ec0236: 390 case 0x10ec0245: 391 case 0x10ec0255: 392 case 0x10ec0256: 393 case 0x10ec0257: 394 case 0x10ec0282: 395 case 0x10ec0283: 396 case 0x10ec0286: 397 case 0x10ec0287: 398 case 0x10ec0288: 399 case 0x10ec0285: 400 case 0x10ec0298: 401 case 0x10ec0289: 402 case 0x10ec0300: 403 alc_update_coef_idx(codec, 0x10, 1<<9, 0); 404 break; 405 case 0x10ec0275: 406 alc_update_coef_idx(codec, 0xe, 0, 1<<0); 407 break; 408 case 0x10ec0293: 409 alc_update_coef_idx(codec, 0xa, 1<<13, 0); 410 break; 411 case 0x10ec0234: 412 case 0x10ec0274: 413 case 0x10ec0294: 414 case 0x10ec0700: 415 case 0x10ec0701: 416 case 0x10ec0703: 417 case 0x10ec0711: 418 alc_update_coef_idx(codec, 0x10, 1<<15, 0); 419 break; 420 case 0x10ec0662: 421 if ((coef & 0x00f0) == 0x0030) 422 alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */ 423 break; 424 case 0x10ec0272: 425 case 0x10ec0273: 426 case 0x10ec0663: 427 case 0x10ec0665: 428 case 0x10ec0670: 429 case 0x10ec0671: 430 case 0x10ec0672: 431 alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */ 432 break; 433 case 0x10ec0222: 434 case 0x10ec0623: 435 alc_update_coef_idx(codec, 0x19, 1<<13, 0); 436 break; 437 case 0x10ec0668: 438 alc_update_coef_idx(codec, 0x7, 3<<13, 0); 439 break; 440 case 0x10ec0867: 441 alc_update_coef_idx(codec, 0x4, 1<<10, 0); 442 break; 443 case 0x10ec0888: 444 if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030) 445 alc_update_coef_idx(codec, 0x7, 1<<5, 0); 446 break; 447 case 0x10ec0892: 448 alc_update_coef_idx(codec, 0x7, 1<<5, 0); 449 break; 450 case 0x10ec0899: 451 case 0x10ec0900: 452 case 0x10ec0b00: 453 case 0x10ec1168: 454 case 0x10ec1220: 455 alc_update_coef_idx(codec, 0x7, 1<<1, 0); 456 break; 457 } 458 } 459 460 /* additional initialization for ALC888 variants */ 461 static void alc888_coef_init(struct hda_codec *codec) 462 { 463 switch (alc_get_coef0(codec) & 0x00f0) { 464 /* alc888-VA */ 465 case 0x00: 466 /* alc888-VB */ 467 case 0x10: 468 alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */ 469 break; 470 } 471 } 472 473 /* turn on/off EAPD control (only if available) */ 474 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on) 475 { 476 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN) 477 return; 478 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD) 479 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE, 480 on ? 2 : 0); 481 } 482 483 /* turn on/off EAPD controls of the codec */ 484 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on) 485 { 486 /* We currently only handle front, HP */ 487 static const hda_nid_t pins[] = { 488 0x0f, 0x10, 0x14, 0x15, 0x17, 0 489 }; 490 const hda_nid_t *p; 491 for (p = pins; *p; p++) 492 set_eapd(codec, *p, on); 493 } 494 495 static int find_ext_mic_pin(struct hda_codec *codec); 496 497 static void alc_headset_mic_no_shutup(struct hda_codec *codec) 498 { 499 const struct hda_pincfg *pin; 500 int mic_pin = find_ext_mic_pin(codec); 501 int i; 502 503 /* don't shut up pins when unloading the driver; otherwise it breaks 504 * the default pin setup at the next load of the driver 505 */ 506 if (codec->bus->shutdown) 507 return; 508 509 snd_array_for_each(&codec->init_pins, i, pin) { 510 /* use read here for syncing after issuing each verb */ 511 if (pin->nid != mic_pin) 512 snd_hda_codec_read(codec, pin->nid, 0, 513 AC_VERB_SET_PIN_WIDGET_CONTROL, 0); 514 } 515 516 codec->pins_shutup = 1; 517 } 518 519 static void alc_shutup_pins(struct hda_codec *codec) 520 { 521 struct alc_spec *spec = codec->spec; 522 523 switch (codec->core.vendor_id) { 524 case 0x10ec0283: 525 case 0x10ec0286: 526 case 0x10ec0288: 527 case 0x10ec0298: 528 alc_headset_mic_no_shutup(codec); 529 break; 530 default: 531 if (!spec->no_shutup_pins) 532 snd_hda_shutup_pins(codec); 533 break; 534 } 535 } 536 537 /* generic shutup callback; 538 * just turning off EAPD and a little pause for avoiding pop-noise 539 */ 540 static void alc_eapd_shutup(struct hda_codec *codec) 541 { 542 struct alc_spec *spec = codec->spec; 543 544 alc_auto_setup_eapd(codec, false); 545 if (!spec->no_depop_delay) 546 msleep(200); 547 alc_shutup_pins(codec); 548 } 549 550 /* generic EAPD initialization */ 551 static void alc_auto_init_amp(struct hda_codec *codec, int type) 552 { 553 alc_auto_setup_eapd(codec, true); 554 alc_write_gpio(codec); 555 switch (type) { 556 case ALC_INIT_DEFAULT: 557 switch (codec->core.vendor_id) { 558 case 0x10ec0260: 559 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010); 560 break; 561 case 0x10ec0880: 562 case 0x10ec0882: 563 case 0x10ec0883: 564 case 0x10ec0885: 565 alc_update_coef_idx(codec, 7, 0, 0x2030); 566 break; 567 case 0x10ec0888: 568 alc888_coef_init(codec); 569 break; 570 } 571 break; 572 } 573 } 574 575 /* get a primary headphone pin if available */ 576 static hda_nid_t alc_get_hp_pin(struct alc_spec *spec) 577 { 578 if (spec->gen.autocfg.hp_pins[0]) 579 return spec->gen.autocfg.hp_pins[0]; 580 if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT) 581 return spec->gen.autocfg.line_out_pins[0]; 582 return 0; 583 } 584 585 /* 586 * Realtek SSID verification 587 */ 588 589 /* Could be any non-zero and even value. When used as fixup, tells 590 * the driver to ignore any present sku defines. 591 */ 592 #define ALC_FIXUP_SKU_IGNORE (2) 593 594 static void alc_fixup_sku_ignore(struct hda_codec *codec, 595 const struct hda_fixup *fix, int action) 596 { 597 struct alc_spec *spec = codec->spec; 598 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 599 spec->cdefine.fixup = 1; 600 spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE; 601 } 602 } 603 604 static void alc_fixup_no_depop_delay(struct hda_codec *codec, 605 const struct hda_fixup *fix, int action) 606 { 607 struct alc_spec *spec = codec->spec; 608 609 if (action == HDA_FIXUP_ACT_PROBE) { 610 spec->no_depop_delay = 1; 611 codec->depop_delay = 0; 612 } 613 } 614 615 static int alc_auto_parse_customize_define(struct hda_codec *codec) 616 { 617 unsigned int ass, tmp, i; 618 unsigned nid = 0; 619 struct alc_spec *spec = codec->spec; 620 621 spec->cdefine.enable_pcbeep = 1; /* assume always enabled */ 622 623 if (spec->cdefine.fixup) { 624 ass = spec->cdefine.sku_cfg; 625 if (ass == ALC_FIXUP_SKU_IGNORE) 626 return -1; 627 goto do_sku; 628 } 629 630 if (!codec->bus->pci) 631 return -1; 632 ass = codec->core.subsystem_id & 0xffff; 633 if (ass != codec->bus->pci->subsystem_device && (ass & 1)) 634 goto do_sku; 635 636 nid = 0x1d; 637 if (codec->core.vendor_id == 0x10ec0260) 638 nid = 0x17; 639 ass = snd_hda_codec_get_pincfg(codec, nid); 640 641 if (!(ass & 1)) { 642 codec_info(codec, "%s: SKU not ready 0x%08x\n", 643 codec->core.chip_name, ass); 644 return -1; 645 } 646 647 /* check sum */ 648 tmp = 0; 649 for (i = 1; i < 16; i++) { 650 if ((ass >> i) & 1) 651 tmp++; 652 } 653 if (((ass >> 16) & 0xf) != tmp) 654 return -1; 655 656 spec->cdefine.port_connectivity = ass >> 30; 657 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20; 658 spec->cdefine.check_sum = (ass >> 16) & 0xf; 659 spec->cdefine.customization = ass >> 8; 660 do_sku: 661 spec->cdefine.sku_cfg = ass; 662 spec->cdefine.external_amp = (ass & 0x38) >> 3; 663 spec->cdefine.platform_type = (ass & 0x4) >> 2; 664 spec->cdefine.swap = (ass & 0x2) >> 1; 665 spec->cdefine.override = ass & 0x1; 666 667 codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n", 668 nid, spec->cdefine.sku_cfg); 669 codec_dbg(codec, "SKU: port_connectivity=0x%x\n", 670 spec->cdefine.port_connectivity); 671 codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep); 672 codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum); 673 codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization); 674 codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp); 675 codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type); 676 codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap); 677 codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override); 678 679 return 0; 680 } 681 682 /* return the position of NID in the list, or -1 if not found */ 683 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums) 684 { 685 int i; 686 for (i = 0; i < nums; i++) 687 if (list[i] == nid) 688 return i; 689 return -1; 690 } 691 /* return true if the given NID is found in the list */ 692 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums) 693 { 694 return find_idx_in_nid_list(nid, list, nums) >= 0; 695 } 696 697 /* check subsystem ID and set up device-specific initialization; 698 * return 1 if initialized, 0 if invalid SSID 699 */ 700 /* 32-bit subsystem ID for BIOS loading in HD Audio codec. 701 * 31 ~ 16 : Manufacture ID 702 * 15 ~ 8 : SKU ID 703 * 7 ~ 0 : Assembly ID 704 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36 705 */ 706 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports) 707 { 708 unsigned int ass, tmp, i; 709 unsigned nid; 710 struct alc_spec *spec = codec->spec; 711 712 if (spec->cdefine.fixup) { 713 ass = spec->cdefine.sku_cfg; 714 if (ass == ALC_FIXUP_SKU_IGNORE) 715 return 0; 716 goto do_sku; 717 } 718 719 ass = codec->core.subsystem_id & 0xffff; 720 if (codec->bus->pci && 721 ass != codec->bus->pci->subsystem_device && (ass & 1)) 722 goto do_sku; 723 724 /* invalid SSID, check the special NID pin defcfg instead */ 725 /* 726 * 31~30 : port connectivity 727 * 29~21 : reserve 728 * 20 : PCBEEP input 729 * 19~16 : Check sum (15:1) 730 * 15~1 : Custom 731 * 0 : override 732 */ 733 nid = 0x1d; 734 if (codec->core.vendor_id == 0x10ec0260) 735 nid = 0x17; 736 ass = snd_hda_codec_get_pincfg(codec, nid); 737 codec_dbg(codec, 738 "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n", 739 ass, nid); 740 if (!(ass & 1)) 741 return 0; 742 if ((ass >> 30) != 1) /* no physical connection */ 743 return 0; 744 745 /* check sum */ 746 tmp = 0; 747 for (i = 1; i < 16; i++) { 748 if ((ass >> i) & 1) 749 tmp++; 750 } 751 if (((ass >> 16) & 0xf) != tmp) 752 return 0; 753 do_sku: 754 codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n", 755 ass & 0xffff, codec->core.vendor_id); 756 /* 757 * 0 : override 758 * 1 : Swap Jack 759 * 2 : 0 --> Desktop, 1 --> Laptop 760 * 3~5 : External Amplifier control 761 * 7~6 : Reserved 762 */ 763 tmp = (ass & 0x38) >> 3; /* external Amp control */ 764 if (spec->init_amp == ALC_INIT_UNDEFINED) { 765 switch (tmp) { 766 case 1: 767 alc_setup_gpio(codec, 0x01); 768 break; 769 case 3: 770 alc_setup_gpio(codec, 0x02); 771 break; 772 case 7: 773 alc_setup_gpio(codec, 0x03); 774 break; 775 case 5: 776 default: 777 spec->init_amp = ALC_INIT_DEFAULT; 778 break; 779 } 780 } 781 782 /* is laptop or Desktop and enable the function "Mute internal speaker 783 * when the external headphone out jack is plugged" 784 */ 785 if (!(ass & 0x8000)) 786 return 1; 787 /* 788 * 10~8 : Jack location 789 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered 790 * 14~13: Resvered 791 * 15 : 1 --> enable the function "Mute internal speaker 792 * when the external headphone out jack is plugged" 793 */ 794 if (!alc_get_hp_pin(spec)) { 795 hda_nid_t nid; 796 tmp = (ass >> 11) & 0x3; /* HP to chassis */ 797 nid = ports[tmp]; 798 if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins, 799 spec->gen.autocfg.line_outs)) 800 return 1; 801 spec->gen.autocfg.hp_pins[0] = nid; 802 } 803 return 1; 804 } 805 806 /* Check the validity of ALC subsystem-id 807 * ports contains an array of 4 pin NIDs for port-A, E, D and I */ 808 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports) 809 { 810 if (!alc_subsystem_id(codec, ports)) { 811 struct alc_spec *spec = codec->spec; 812 if (spec->init_amp == ALC_INIT_UNDEFINED) { 813 codec_dbg(codec, 814 "realtek: Enable default setup for auto mode as fallback\n"); 815 spec->init_amp = ALC_INIT_DEFAULT; 816 } 817 } 818 } 819 820 /* 821 */ 822 823 static void alc_fixup_inv_dmic(struct hda_codec *codec, 824 const struct hda_fixup *fix, int action) 825 { 826 struct alc_spec *spec = codec->spec; 827 828 spec->gen.inv_dmic_split = 1; 829 } 830 831 832 static int alc_build_controls(struct hda_codec *codec) 833 { 834 int err; 835 836 err = snd_hda_gen_build_controls(codec); 837 if (err < 0) 838 return err; 839 840 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD); 841 return 0; 842 } 843 844 845 /* 846 * Common callbacks 847 */ 848 849 static void alc_pre_init(struct hda_codec *codec) 850 { 851 alc_fill_eapd_coef(codec); 852 } 853 854 #define is_s3_resume(codec) \ 855 ((codec)->core.dev.power.power_state.event == PM_EVENT_RESUME) 856 #define is_s4_resume(codec) \ 857 ((codec)->core.dev.power.power_state.event == PM_EVENT_RESTORE) 858 859 static int alc_init(struct hda_codec *codec) 860 { 861 struct alc_spec *spec = codec->spec; 862 863 /* hibernation resume needs the full chip initialization */ 864 if (is_s4_resume(codec)) 865 alc_pre_init(codec); 866 867 if (spec->init_hook) 868 spec->init_hook(codec); 869 870 spec->gen.skip_verbs = 1; /* applied in below */ 871 snd_hda_gen_init(codec); 872 alc_fix_pll(codec); 873 alc_auto_init_amp(codec, spec->init_amp); 874 snd_hda_apply_verbs(codec); /* apply verbs here after own init */ 875 876 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT); 877 878 return 0; 879 } 880 881 static inline void alc_shutup(struct hda_codec *codec) 882 { 883 struct alc_spec *spec = codec->spec; 884 885 if (!snd_hda_get_bool_hint(codec, "shutup")) 886 return; /* disabled explicitly by hints */ 887 888 if (spec && spec->shutup) 889 spec->shutup(codec); 890 else 891 alc_shutup_pins(codec); 892 } 893 894 static void alc_reboot_notify(struct hda_codec *codec) 895 { 896 struct alc_spec *spec = codec->spec; 897 898 if (spec && spec->reboot_notify) 899 spec->reboot_notify(codec); 900 else 901 alc_shutup(codec); 902 } 903 904 #define alc_free snd_hda_gen_free 905 906 #ifdef CONFIG_PM 907 static void alc_power_eapd(struct hda_codec *codec) 908 { 909 alc_auto_setup_eapd(codec, false); 910 } 911 912 static int alc_suspend(struct hda_codec *codec) 913 { 914 struct alc_spec *spec = codec->spec; 915 alc_shutup(codec); 916 if (spec && spec->power_hook) 917 spec->power_hook(codec); 918 return 0; 919 } 920 #endif 921 922 #ifdef CONFIG_PM 923 static int alc_resume(struct hda_codec *codec) 924 { 925 struct alc_spec *spec = codec->spec; 926 927 if (!spec->no_depop_delay) 928 msleep(150); /* to avoid pop noise */ 929 codec->patch_ops.init(codec); 930 snd_hda_regmap_sync(codec); 931 hda_call_check_power_status(codec, 0x01); 932 return 0; 933 } 934 #endif 935 936 /* 937 */ 938 static const struct hda_codec_ops alc_patch_ops = { 939 .build_controls = alc_build_controls, 940 .build_pcms = snd_hda_gen_build_pcms, 941 .init = alc_init, 942 .free = alc_free, 943 .unsol_event = snd_hda_jack_unsol_event, 944 #ifdef CONFIG_PM 945 .resume = alc_resume, 946 .suspend = alc_suspend, 947 .check_power_status = snd_hda_gen_check_power_status, 948 #endif 949 .reboot_notify = alc_reboot_notify, 950 }; 951 952 953 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name) 954 955 /* 956 * Rename codecs appropriately from COEF value or subvendor id 957 */ 958 struct alc_codec_rename_table { 959 unsigned int vendor_id; 960 unsigned short coef_mask; 961 unsigned short coef_bits; 962 const char *name; 963 }; 964 965 struct alc_codec_rename_pci_table { 966 unsigned int codec_vendor_id; 967 unsigned short pci_subvendor; 968 unsigned short pci_subdevice; 969 const char *name; 970 }; 971 972 static const struct alc_codec_rename_table rename_tbl[] = { 973 { 0x10ec0221, 0xf00f, 0x1003, "ALC231" }, 974 { 0x10ec0269, 0xfff0, 0x3010, "ALC277" }, 975 { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" }, 976 { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" }, 977 { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" }, 978 { 0x10ec0269, 0xffff, 0xa023, "ALC259" }, 979 { 0x10ec0269, 0xffff, 0x6023, "ALC281X" }, 980 { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" }, 981 { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" }, 982 { 0x10ec0662, 0xffff, 0x4020, "ALC656" }, 983 { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" }, 984 { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" }, 985 { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" }, 986 { 0x10ec0899, 0x2000, 0x2000, "ALC899" }, 987 { 0x10ec0892, 0xffff, 0x8020, "ALC661" }, 988 { 0x10ec0892, 0xffff, 0x8011, "ALC661" }, 989 { 0x10ec0892, 0xffff, 0x4011, "ALC656" }, 990 { } /* terminator */ 991 }; 992 993 static const struct alc_codec_rename_pci_table rename_pci_tbl[] = { 994 { 0x10ec0280, 0x1028, 0, "ALC3220" }, 995 { 0x10ec0282, 0x1028, 0, "ALC3221" }, 996 { 0x10ec0283, 0x1028, 0, "ALC3223" }, 997 { 0x10ec0288, 0x1028, 0, "ALC3263" }, 998 { 0x10ec0292, 0x1028, 0, "ALC3226" }, 999 { 0x10ec0293, 0x1028, 0, "ALC3235" }, 1000 { 0x10ec0255, 0x1028, 0, "ALC3234" }, 1001 { 0x10ec0668, 0x1028, 0, "ALC3661" }, 1002 { 0x10ec0275, 0x1028, 0, "ALC3260" }, 1003 { 0x10ec0899, 0x1028, 0, "ALC3861" }, 1004 { 0x10ec0298, 0x1028, 0, "ALC3266" }, 1005 { 0x10ec0236, 0x1028, 0, "ALC3204" }, 1006 { 0x10ec0256, 0x1028, 0, "ALC3246" }, 1007 { 0x10ec0225, 0x1028, 0, "ALC3253" }, 1008 { 0x10ec0295, 0x1028, 0, "ALC3254" }, 1009 { 0x10ec0299, 0x1028, 0, "ALC3271" }, 1010 { 0x10ec0670, 0x1025, 0, "ALC669X" }, 1011 { 0x10ec0676, 0x1025, 0, "ALC679X" }, 1012 { 0x10ec0282, 0x1043, 0, "ALC3229" }, 1013 { 0x10ec0233, 0x1043, 0, "ALC3236" }, 1014 { 0x10ec0280, 0x103c, 0, "ALC3228" }, 1015 { 0x10ec0282, 0x103c, 0, "ALC3227" }, 1016 { 0x10ec0286, 0x103c, 0, "ALC3242" }, 1017 { 0x10ec0290, 0x103c, 0, "ALC3241" }, 1018 { 0x10ec0668, 0x103c, 0, "ALC3662" }, 1019 { 0x10ec0283, 0x17aa, 0, "ALC3239" }, 1020 { 0x10ec0292, 0x17aa, 0, "ALC3232" }, 1021 { } /* terminator */ 1022 }; 1023 1024 static int alc_codec_rename_from_preset(struct hda_codec *codec) 1025 { 1026 const struct alc_codec_rename_table *p; 1027 const struct alc_codec_rename_pci_table *q; 1028 1029 for (p = rename_tbl; p->vendor_id; p++) { 1030 if (p->vendor_id != codec->core.vendor_id) 1031 continue; 1032 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits) 1033 return alc_codec_rename(codec, p->name); 1034 } 1035 1036 if (!codec->bus->pci) 1037 return 0; 1038 for (q = rename_pci_tbl; q->codec_vendor_id; q++) { 1039 if (q->codec_vendor_id != codec->core.vendor_id) 1040 continue; 1041 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor) 1042 continue; 1043 if (!q->pci_subdevice || 1044 q->pci_subdevice == codec->bus->pci->subsystem_device) 1045 return alc_codec_rename(codec, q->name); 1046 } 1047 1048 return 0; 1049 } 1050 1051 1052 /* 1053 * Digital-beep handlers 1054 */ 1055 #ifdef CONFIG_SND_HDA_INPUT_BEEP 1056 1057 /* additional beep mixers; private_value will be overwritten */ 1058 static const struct snd_kcontrol_new alc_beep_mixer[] = { 1059 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT), 1060 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT), 1061 }; 1062 1063 /* set up and create beep controls */ 1064 static int set_beep_amp(struct alc_spec *spec, hda_nid_t nid, 1065 int idx, int dir) 1066 { 1067 struct snd_kcontrol_new *knew; 1068 unsigned int beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir); 1069 int i; 1070 1071 for (i = 0; i < ARRAY_SIZE(alc_beep_mixer); i++) { 1072 knew = snd_hda_gen_add_kctl(&spec->gen, NULL, 1073 &alc_beep_mixer[i]); 1074 if (!knew) 1075 return -ENOMEM; 1076 knew->private_value = beep_amp; 1077 } 1078 return 0; 1079 } 1080 1081 static const struct snd_pci_quirk beep_allow_list[] = { 1082 SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1), 1083 SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1), 1084 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1), 1085 SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1), 1086 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1), 1087 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1), 1088 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1), 1089 SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1), 1090 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1), 1091 /* denylist -- no beep available */ 1092 SND_PCI_QUIRK(0x17aa, 0x309e, "Lenovo ThinkCentre M73", 0), 1093 SND_PCI_QUIRK(0x17aa, 0x30a3, "Lenovo ThinkCentre M93", 0), 1094 {} 1095 }; 1096 1097 static inline int has_cdefine_beep(struct hda_codec *codec) 1098 { 1099 struct alc_spec *spec = codec->spec; 1100 const struct snd_pci_quirk *q; 1101 q = snd_pci_quirk_lookup(codec->bus->pci, beep_allow_list); 1102 if (q) 1103 return q->value; 1104 return spec->cdefine.enable_pcbeep; 1105 } 1106 #else 1107 #define set_beep_amp(spec, nid, idx, dir) 0 1108 #define has_cdefine_beep(codec) 0 1109 #endif 1110 1111 /* parse the BIOS configuration and set up the alc_spec */ 1112 /* return 1 if successful, 0 if the proper config is not found, 1113 * or a negative error code 1114 */ 1115 static int alc_parse_auto_config(struct hda_codec *codec, 1116 const hda_nid_t *ignore_nids, 1117 const hda_nid_t *ssid_nids) 1118 { 1119 struct alc_spec *spec = codec->spec; 1120 struct auto_pin_cfg *cfg = &spec->gen.autocfg; 1121 int err; 1122 1123 err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids, 1124 spec->parse_flags); 1125 if (err < 0) 1126 return err; 1127 1128 if (ssid_nids) 1129 alc_ssid_check(codec, ssid_nids); 1130 1131 err = snd_hda_gen_parse_auto_config(codec, cfg); 1132 if (err < 0) 1133 return err; 1134 1135 return 1; 1136 } 1137 1138 /* common preparation job for alc_spec */ 1139 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid) 1140 { 1141 struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL); 1142 int err; 1143 1144 if (!spec) 1145 return -ENOMEM; 1146 codec->spec = spec; 1147 snd_hda_gen_spec_init(&spec->gen); 1148 spec->gen.mixer_nid = mixer_nid; 1149 spec->gen.own_eapd_ctl = 1; 1150 codec->single_adc_amp = 1; 1151 /* FIXME: do we need this for all Realtek codec models? */ 1152 codec->spdif_status_reset = 1; 1153 codec->forced_resume = 1; 1154 codec->patch_ops = alc_patch_ops; 1155 1156 err = alc_codec_rename_from_preset(codec); 1157 if (err < 0) { 1158 kfree(spec); 1159 return err; 1160 } 1161 return 0; 1162 } 1163 1164 static int alc880_parse_auto_config(struct hda_codec *codec) 1165 { 1166 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 }; 1167 static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 1168 return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids); 1169 } 1170 1171 /* 1172 * ALC880 fix-ups 1173 */ 1174 enum { 1175 ALC880_FIXUP_GPIO1, 1176 ALC880_FIXUP_GPIO2, 1177 ALC880_FIXUP_MEDION_RIM, 1178 ALC880_FIXUP_LG, 1179 ALC880_FIXUP_LG_LW25, 1180 ALC880_FIXUP_W810, 1181 ALC880_FIXUP_EAPD_COEF, 1182 ALC880_FIXUP_TCL_S700, 1183 ALC880_FIXUP_VOL_KNOB, 1184 ALC880_FIXUP_FUJITSU, 1185 ALC880_FIXUP_F1734, 1186 ALC880_FIXUP_UNIWILL, 1187 ALC880_FIXUP_UNIWILL_DIG, 1188 ALC880_FIXUP_Z71V, 1189 ALC880_FIXUP_ASUS_W5A, 1190 ALC880_FIXUP_3ST_BASE, 1191 ALC880_FIXUP_3ST, 1192 ALC880_FIXUP_3ST_DIG, 1193 ALC880_FIXUP_5ST_BASE, 1194 ALC880_FIXUP_5ST, 1195 ALC880_FIXUP_5ST_DIG, 1196 ALC880_FIXUP_6ST_BASE, 1197 ALC880_FIXUP_6ST, 1198 ALC880_FIXUP_6ST_DIG, 1199 ALC880_FIXUP_6ST_AUTOMUTE, 1200 }; 1201 1202 /* enable the volume-knob widget support on NID 0x21 */ 1203 static void alc880_fixup_vol_knob(struct hda_codec *codec, 1204 const struct hda_fixup *fix, int action) 1205 { 1206 if (action == HDA_FIXUP_ACT_PROBE) 1207 snd_hda_jack_detect_enable_callback(codec, 0x21, 1208 alc_update_knob_master); 1209 } 1210 1211 static const struct hda_fixup alc880_fixups[] = { 1212 [ALC880_FIXUP_GPIO1] = { 1213 .type = HDA_FIXUP_FUNC, 1214 .v.func = alc_fixup_gpio1, 1215 }, 1216 [ALC880_FIXUP_GPIO2] = { 1217 .type = HDA_FIXUP_FUNC, 1218 .v.func = alc_fixup_gpio2, 1219 }, 1220 [ALC880_FIXUP_MEDION_RIM] = { 1221 .type = HDA_FIXUP_VERBS, 1222 .v.verbs = (const struct hda_verb[]) { 1223 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 1224 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 }, 1225 { } 1226 }, 1227 .chained = true, 1228 .chain_id = ALC880_FIXUP_GPIO2, 1229 }, 1230 [ALC880_FIXUP_LG] = { 1231 .type = HDA_FIXUP_PINS, 1232 .v.pins = (const struct hda_pintbl[]) { 1233 /* disable bogus unused pins */ 1234 { 0x16, 0x411111f0 }, 1235 { 0x18, 0x411111f0 }, 1236 { 0x1a, 0x411111f0 }, 1237 { } 1238 } 1239 }, 1240 [ALC880_FIXUP_LG_LW25] = { 1241 .type = HDA_FIXUP_PINS, 1242 .v.pins = (const struct hda_pintbl[]) { 1243 { 0x1a, 0x0181344f }, /* line-in */ 1244 { 0x1b, 0x0321403f }, /* headphone */ 1245 { } 1246 } 1247 }, 1248 [ALC880_FIXUP_W810] = { 1249 .type = HDA_FIXUP_PINS, 1250 .v.pins = (const struct hda_pintbl[]) { 1251 /* disable bogus unused pins */ 1252 { 0x17, 0x411111f0 }, 1253 { } 1254 }, 1255 .chained = true, 1256 .chain_id = ALC880_FIXUP_GPIO2, 1257 }, 1258 [ALC880_FIXUP_EAPD_COEF] = { 1259 .type = HDA_FIXUP_VERBS, 1260 .v.verbs = (const struct hda_verb[]) { 1261 /* change to EAPD mode */ 1262 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 1263 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 }, 1264 {} 1265 }, 1266 }, 1267 [ALC880_FIXUP_TCL_S700] = { 1268 .type = HDA_FIXUP_VERBS, 1269 .v.verbs = (const struct hda_verb[]) { 1270 /* change to EAPD mode */ 1271 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 1272 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 }, 1273 {} 1274 }, 1275 .chained = true, 1276 .chain_id = ALC880_FIXUP_GPIO2, 1277 }, 1278 [ALC880_FIXUP_VOL_KNOB] = { 1279 .type = HDA_FIXUP_FUNC, 1280 .v.func = alc880_fixup_vol_knob, 1281 }, 1282 [ALC880_FIXUP_FUJITSU] = { 1283 /* override all pins as BIOS on old Amilo is broken */ 1284 .type = HDA_FIXUP_PINS, 1285 .v.pins = (const struct hda_pintbl[]) { 1286 { 0x14, 0x0121401f }, /* HP */ 1287 { 0x15, 0x99030120 }, /* speaker */ 1288 { 0x16, 0x99030130 }, /* bass speaker */ 1289 { 0x17, 0x411111f0 }, /* N/A */ 1290 { 0x18, 0x411111f0 }, /* N/A */ 1291 { 0x19, 0x01a19950 }, /* mic-in */ 1292 { 0x1a, 0x411111f0 }, /* N/A */ 1293 { 0x1b, 0x411111f0 }, /* N/A */ 1294 { 0x1c, 0x411111f0 }, /* N/A */ 1295 { 0x1d, 0x411111f0 }, /* N/A */ 1296 { 0x1e, 0x01454140 }, /* SPDIF out */ 1297 { } 1298 }, 1299 .chained = true, 1300 .chain_id = ALC880_FIXUP_VOL_KNOB, 1301 }, 1302 [ALC880_FIXUP_F1734] = { 1303 /* almost compatible with FUJITSU, but no bass and SPDIF */ 1304 .type = HDA_FIXUP_PINS, 1305 .v.pins = (const struct hda_pintbl[]) { 1306 { 0x14, 0x0121401f }, /* HP */ 1307 { 0x15, 0x99030120 }, /* speaker */ 1308 { 0x16, 0x411111f0 }, /* N/A */ 1309 { 0x17, 0x411111f0 }, /* N/A */ 1310 { 0x18, 0x411111f0 }, /* N/A */ 1311 { 0x19, 0x01a19950 }, /* mic-in */ 1312 { 0x1a, 0x411111f0 }, /* N/A */ 1313 { 0x1b, 0x411111f0 }, /* N/A */ 1314 { 0x1c, 0x411111f0 }, /* N/A */ 1315 { 0x1d, 0x411111f0 }, /* N/A */ 1316 { 0x1e, 0x411111f0 }, /* N/A */ 1317 { } 1318 }, 1319 .chained = true, 1320 .chain_id = ALC880_FIXUP_VOL_KNOB, 1321 }, 1322 [ALC880_FIXUP_UNIWILL] = { 1323 /* need to fix HP and speaker pins to be parsed correctly */ 1324 .type = HDA_FIXUP_PINS, 1325 .v.pins = (const struct hda_pintbl[]) { 1326 { 0x14, 0x0121411f }, /* HP */ 1327 { 0x15, 0x99030120 }, /* speaker */ 1328 { 0x16, 0x99030130 }, /* bass speaker */ 1329 { } 1330 }, 1331 }, 1332 [ALC880_FIXUP_UNIWILL_DIG] = { 1333 .type = HDA_FIXUP_PINS, 1334 .v.pins = (const struct hda_pintbl[]) { 1335 /* disable bogus unused pins */ 1336 { 0x17, 0x411111f0 }, 1337 { 0x19, 0x411111f0 }, 1338 { 0x1b, 0x411111f0 }, 1339 { 0x1f, 0x411111f0 }, 1340 { } 1341 } 1342 }, 1343 [ALC880_FIXUP_Z71V] = { 1344 .type = HDA_FIXUP_PINS, 1345 .v.pins = (const struct hda_pintbl[]) { 1346 /* set up the whole pins as BIOS is utterly broken */ 1347 { 0x14, 0x99030120 }, /* speaker */ 1348 { 0x15, 0x0121411f }, /* HP */ 1349 { 0x16, 0x411111f0 }, /* N/A */ 1350 { 0x17, 0x411111f0 }, /* N/A */ 1351 { 0x18, 0x01a19950 }, /* mic-in */ 1352 { 0x19, 0x411111f0 }, /* N/A */ 1353 { 0x1a, 0x01813031 }, /* line-in */ 1354 { 0x1b, 0x411111f0 }, /* N/A */ 1355 { 0x1c, 0x411111f0 }, /* N/A */ 1356 { 0x1d, 0x411111f0 }, /* N/A */ 1357 { 0x1e, 0x0144111e }, /* SPDIF */ 1358 { } 1359 } 1360 }, 1361 [ALC880_FIXUP_ASUS_W5A] = { 1362 .type = HDA_FIXUP_PINS, 1363 .v.pins = (const struct hda_pintbl[]) { 1364 /* set up the whole pins as BIOS is utterly broken */ 1365 { 0x14, 0x0121411f }, /* HP */ 1366 { 0x15, 0x411111f0 }, /* N/A */ 1367 { 0x16, 0x411111f0 }, /* N/A */ 1368 { 0x17, 0x411111f0 }, /* N/A */ 1369 { 0x18, 0x90a60160 }, /* mic */ 1370 { 0x19, 0x411111f0 }, /* N/A */ 1371 { 0x1a, 0x411111f0 }, /* N/A */ 1372 { 0x1b, 0x411111f0 }, /* N/A */ 1373 { 0x1c, 0x411111f0 }, /* N/A */ 1374 { 0x1d, 0x411111f0 }, /* N/A */ 1375 { 0x1e, 0xb743111e }, /* SPDIF out */ 1376 { } 1377 }, 1378 .chained = true, 1379 .chain_id = ALC880_FIXUP_GPIO1, 1380 }, 1381 [ALC880_FIXUP_3ST_BASE] = { 1382 .type = HDA_FIXUP_PINS, 1383 .v.pins = (const struct hda_pintbl[]) { 1384 { 0x14, 0x01014010 }, /* line-out */ 1385 { 0x15, 0x411111f0 }, /* N/A */ 1386 { 0x16, 0x411111f0 }, /* N/A */ 1387 { 0x17, 0x411111f0 }, /* N/A */ 1388 { 0x18, 0x01a19c30 }, /* mic-in */ 1389 { 0x19, 0x0121411f }, /* HP */ 1390 { 0x1a, 0x01813031 }, /* line-in */ 1391 { 0x1b, 0x02a19c40 }, /* front-mic */ 1392 { 0x1c, 0x411111f0 }, /* N/A */ 1393 { 0x1d, 0x411111f0 }, /* N/A */ 1394 /* 0x1e is filled in below */ 1395 { 0x1f, 0x411111f0 }, /* N/A */ 1396 { } 1397 } 1398 }, 1399 [ALC880_FIXUP_3ST] = { 1400 .type = HDA_FIXUP_PINS, 1401 .v.pins = (const struct hda_pintbl[]) { 1402 { 0x1e, 0x411111f0 }, /* N/A */ 1403 { } 1404 }, 1405 .chained = true, 1406 .chain_id = ALC880_FIXUP_3ST_BASE, 1407 }, 1408 [ALC880_FIXUP_3ST_DIG] = { 1409 .type = HDA_FIXUP_PINS, 1410 .v.pins = (const struct hda_pintbl[]) { 1411 { 0x1e, 0x0144111e }, /* SPDIF */ 1412 { } 1413 }, 1414 .chained = true, 1415 .chain_id = ALC880_FIXUP_3ST_BASE, 1416 }, 1417 [ALC880_FIXUP_5ST_BASE] = { 1418 .type = HDA_FIXUP_PINS, 1419 .v.pins = (const struct hda_pintbl[]) { 1420 { 0x14, 0x01014010 }, /* front */ 1421 { 0x15, 0x411111f0 }, /* N/A */ 1422 { 0x16, 0x01011411 }, /* CLFE */ 1423 { 0x17, 0x01016412 }, /* surr */ 1424 { 0x18, 0x01a19c30 }, /* mic-in */ 1425 { 0x19, 0x0121411f }, /* HP */ 1426 { 0x1a, 0x01813031 }, /* line-in */ 1427 { 0x1b, 0x02a19c40 }, /* front-mic */ 1428 { 0x1c, 0x411111f0 }, /* N/A */ 1429 { 0x1d, 0x411111f0 }, /* N/A */ 1430 /* 0x1e is filled in below */ 1431 { 0x1f, 0x411111f0 }, /* N/A */ 1432 { } 1433 } 1434 }, 1435 [ALC880_FIXUP_5ST] = { 1436 .type = HDA_FIXUP_PINS, 1437 .v.pins = (const struct hda_pintbl[]) { 1438 { 0x1e, 0x411111f0 }, /* N/A */ 1439 { } 1440 }, 1441 .chained = true, 1442 .chain_id = ALC880_FIXUP_5ST_BASE, 1443 }, 1444 [ALC880_FIXUP_5ST_DIG] = { 1445 .type = HDA_FIXUP_PINS, 1446 .v.pins = (const struct hda_pintbl[]) { 1447 { 0x1e, 0x0144111e }, /* SPDIF */ 1448 { } 1449 }, 1450 .chained = true, 1451 .chain_id = ALC880_FIXUP_5ST_BASE, 1452 }, 1453 [ALC880_FIXUP_6ST_BASE] = { 1454 .type = HDA_FIXUP_PINS, 1455 .v.pins = (const struct hda_pintbl[]) { 1456 { 0x14, 0x01014010 }, /* front */ 1457 { 0x15, 0x01016412 }, /* surr */ 1458 { 0x16, 0x01011411 }, /* CLFE */ 1459 { 0x17, 0x01012414 }, /* side */ 1460 { 0x18, 0x01a19c30 }, /* mic-in */ 1461 { 0x19, 0x02a19c40 }, /* front-mic */ 1462 { 0x1a, 0x01813031 }, /* line-in */ 1463 { 0x1b, 0x0121411f }, /* HP */ 1464 { 0x1c, 0x411111f0 }, /* N/A */ 1465 { 0x1d, 0x411111f0 }, /* N/A */ 1466 /* 0x1e is filled in below */ 1467 { 0x1f, 0x411111f0 }, /* N/A */ 1468 { } 1469 } 1470 }, 1471 [ALC880_FIXUP_6ST] = { 1472 .type = HDA_FIXUP_PINS, 1473 .v.pins = (const struct hda_pintbl[]) { 1474 { 0x1e, 0x411111f0 }, /* N/A */ 1475 { } 1476 }, 1477 .chained = true, 1478 .chain_id = ALC880_FIXUP_6ST_BASE, 1479 }, 1480 [ALC880_FIXUP_6ST_DIG] = { 1481 .type = HDA_FIXUP_PINS, 1482 .v.pins = (const struct hda_pintbl[]) { 1483 { 0x1e, 0x0144111e }, /* SPDIF */ 1484 { } 1485 }, 1486 .chained = true, 1487 .chain_id = ALC880_FIXUP_6ST_BASE, 1488 }, 1489 [ALC880_FIXUP_6ST_AUTOMUTE] = { 1490 .type = HDA_FIXUP_PINS, 1491 .v.pins = (const struct hda_pintbl[]) { 1492 { 0x1b, 0x0121401f }, /* HP with jack detect */ 1493 { } 1494 }, 1495 .chained_before = true, 1496 .chain_id = ALC880_FIXUP_6ST_BASE, 1497 }, 1498 }; 1499 1500 static const struct snd_pci_quirk alc880_fixup_tbl[] = { 1501 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810), 1502 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A), 1503 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V), 1504 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1), 1505 SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE), 1506 SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2), 1507 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF), 1508 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG), 1509 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734), 1510 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL), 1511 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB), 1512 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810), 1513 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM), 1514 SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE), 1515 SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU), 1516 SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU), 1517 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734), 1518 SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU), 1519 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG), 1520 SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG), 1521 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG), 1522 SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25), 1523 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700), 1524 1525 /* Below is the copied entries from alc880_quirks.c. 1526 * It's not quite sure whether BIOS sets the correct pin-config table 1527 * on these machines, thus they are kept to be compatible with 1528 * the old static quirks. Once when it's confirmed to work without 1529 * these overrides, it'd be better to remove. 1530 */ 1531 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG), 1532 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST), 1533 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG), 1534 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG), 1535 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG), 1536 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG), 1537 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG), 1538 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST), 1539 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG), 1540 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST), 1541 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST), 1542 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST), 1543 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST), 1544 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST), 1545 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG), 1546 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG), 1547 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG), 1548 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG), 1549 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG), 1550 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG), 1551 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG), 1552 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */ 1553 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG), 1554 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1555 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1556 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1557 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG), 1558 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1559 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG), 1560 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG), 1561 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1562 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1563 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1564 /* default Intel */ 1565 SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST), 1566 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG), 1567 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG), 1568 {} 1569 }; 1570 1571 static const struct hda_model_fixup alc880_fixup_models[] = { 1572 {.id = ALC880_FIXUP_3ST, .name = "3stack"}, 1573 {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"}, 1574 {.id = ALC880_FIXUP_5ST, .name = "5stack"}, 1575 {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"}, 1576 {.id = ALC880_FIXUP_6ST, .name = "6stack"}, 1577 {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"}, 1578 {.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"}, 1579 {} 1580 }; 1581 1582 1583 /* 1584 * OK, here we have finally the patch for ALC880 1585 */ 1586 static int patch_alc880(struct hda_codec *codec) 1587 { 1588 struct alc_spec *spec; 1589 int err; 1590 1591 err = alc_alloc_spec(codec, 0x0b); 1592 if (err < 0) 1593 return err; 1594 1595 spec = codec->spec; 1596 spec->gen.need_dac_fix = 1; 1597 spec->gen.beep_nid = 0x01; 1598 1599 codec->patch_ops.unsol_event = alc880_unsol_event; 1600 1601 alc_pre_init(codec); 1602 1603 snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl, 1604 alc880_fixups); 1605 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 1606 1607 /* automatic parse from the BIOS config */ 1608 err = alc880_parse_auto_config(codec); 1609 if (err < 0) 1610 goto error; 1611 1612 if (!spec->gen.no_analog) { 1613 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 1614 if (err < 0) 1615 goto error; 1616 } 1617 1618 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 1619 1620 return 0; 1621 1622 error: 1623 alc_free(codec); 1624 return err; 1625 } 1626 1627 1628 /* 1629 * ALC260 support 1630 */ 1631 static int alc260_parse_auto_config(struct hda_codec *codec) 1632 { 1633 static const hda_nid_t alc260_ignore[] = { 0x17, 0 }; 1634 static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 }; 1635 return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids); 1636 } 1637 1638 /* 1639 * Pin config fixes 1640 */ 1641 enum { 1642 ALC260_FIXUP_HP_DC5750, 1643 ALC260_FIXUP_HP_PIN_0F, 1644 ALC260_FIXUP_COEF, 1645 ALC260_FIXUP_GPIO1, 1646 ALC260_FIXUP_GPIO1_TOGGLE, 1647 ALC260_FIXUP_REPLACER, 1648 ALC260_FIXUP_HP_B1900, 1649 ALC260_FIXUP_KN1, 1650 ALC260_FIXUP_FSC_S7020, 1651 ALC260_FIXUP_FSC_S7020_JWSE, 1652 ALC260_FIXUP_VAIO_PINS, 1653 }; 1654 1655 static void alc260_gpio1_automute(struct hda_codec *codec) 1656 { 1657 struct alc_spec *spec = codec->spec; 1658 1659 alc_update_gpio_data(codec, 0x01, spec->gen.hp_jack_present); 1660 } 1661 1662 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec, 1663 const struct hda_fixup *fix, int action) 1664 { 1665 struct alc_spec *spec = codec->spec; 1666 if (action == HDA_FIXUP_ACT_PROBE) { 1667 /* although the machine has only one output pin, we need to 1668 * toggle GPIO1 according to the jack state 1669 */ 1670 spec->gen.automute_hook = alc260_gpio1_automute; 1671 spec->gen.detect_hp = 1; 1672 spec->gen.automute_speaker = 1; 1673 spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */ 1674 snd_hda_jack_detect_enable_callback(codec, 0x0f, 1675 snd_hda_gen_hp_automute); 1676 alc_setup_gpio(codec, 0x01); 1677 } 1678 } 1679 1680 static void alc260_fixup_kn1(struct hda_codec *codec, 1681 const struct hda_fixup *fix, int action) 1682 { 1683 struct alc_spec *spec = codec->spec; 1684 static const struct hda_pintbl pincfgs[] = { 1685 { 0x0f, 0x02214000 }, /* HP/speaker */ 1686 { 0x12, 0x90a60160 }, /* int mic */ 1687 { 0x13, 0x02a19000 }, /* ext mic */ 1688 { 0x18, 0x01446000 }, /* SPDIF out */ 1689 /* disable bogus I/O pins */ 1690 { 0x10, 0x411111f0 }, 1691 { 0x11, 0x411111f0 }, 1692 { 0x14, 0x411111f0 }, 1693 { 0x15, 0x411111f0 }, 1694 { 0x16, 0x411111f0 }, 1695 { 0x17, 0x411111f0 }, 1696 { 0x19, 0x411111f0 }, 1697 { } 1698 }; 1699 1700 switch (action) { 1701 case HDA_FIXUP_ACT_PRE_PROBE: 1702 snd_hda_apply_pincfgs(codec, pincfgs); 1703 spec->init_amp = ALC_INIT_NONE; 1704 break; 1705 } 1706 } 1707 1708 static void alc260_fixup_fsc_s7020(struct hda_codec *codec, 1709 const struct hda_fixup *fix, int action) 1710 { 1711 struct alc_spec *spec = codec->spec; 1712 if (action == HDA_FIXUP_ACT_PRE_PROBE) 1713 spec->init_amp = ALC_INIT_NONE; 1714 } 1715 1716 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec, 1717 const struct hda_fixup *fix, int action) 1718 { 1719 struct alc_spec *spec = codec->spec; 1720 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1721 spec->gen.add_jack_modes = 1; 1722 spec->gen.hp_mic = 1; 1723 } 1724 } 1725 1726 static const struct hda_fixup alc260_fixups[] = { 1727 [ALC260_FIXUP_HP_DC5750] = { 1728 .type = HDA_FIXUP_PINS, 1729 .v.pins = (const struct hda_pintbl[]) { 1730 { 0x11, 0x90130110 }, /* speaker */ 1731 { } 1732 } 1733 }, 1734 [ALC260_FIXUP_HP_PIN_0F] = { 1735 .type = HDA_FIXUP_PINS, 1736 .v.pins = (const struct hda_pintbl[]) { 1737 { 0x0f, 0x01214000 }, /* HP */ 1738 { } 1739 } 1740 }, 1741 [ALC260_FIXUP_COEF] = { 1742 .type = HDA_FIXUP_VERBS, 1743 .v.verbs = (const struct hda_verb[]) { 1744 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 }, 1745 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3040 }, 1746 { } 1747 }, 1748 }, 1749 [ALC260_FIXUP_GPIO1] = { 1750 .type = HDA_FIXUP_FUNC, 1751 .v.func = alc_fixup_gpio1, 1752 }, 1753 [ALC260_FIXUP_GPIO1_TOGGLE] = { 1754 .type = HDA_FIXUP_FUNC, 1755 .v.func = alc260_fixup_gpio1_toggle, 1756 .chained = true, 1757 .chain_id = ALC260_FIXUP_HP_PIN_0F, 1758 }, 1759 [ALC260_FIXUP_REPLACER] = { 1760 .type = HDA_FIXUP_VERBS, 1761 .v.verbs = (const struct hda_verb[]) { 1762 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 }, 1763 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3050 }, 1764 { } 1765 }, 1766 .chained = true, 1767 .chain_id = ALC260_FIXUP_GPIO1_TOGGLE, 1768 }, 1769 [ALC260_FIXUP_HP_B1900] = { 1770 .type = HDA_FIXUP_FUNC, 1771 .v.func = alc260_fixup_gpio1_toggle, 1772 .chained = true, 1773 .chain_id = ALC260_FIXUP_COEF, 1774 }, 1775 [ALC260_FIXUP_KN1] = { 1776 .type = HDA_FIXUP_FUNC, 1777 .v.func = alc260_fixup_kn1, 1778 }, 1779 [ALC260_FIXUP_FSC_S7020] = { 1780 .type = HDA_FIXUP_FUNC, 1781 .v.func = alc260_fixup_fsc_s7020, 1782 }, 1783 [ALC260_FIXUP_FSC_S7020_JWSE] = { 1784 .type = HDA_FIXUP_FUNC, 1785 .v.func = alc260_fixup_fsc_s7020_jwse, 1786 .chained = true, 1787 .chain_id = ALC260_FIXUP_FSC_S7020, 1788 }, 1789 [ALC260_FIXUP_VAIO_PINS] = { 1790 .type = HDA_FIXUP_PINS, 1791 .v.pins = (const struct hda_pintbl[]) { 1792 /* Pin configs are missing completely on some VAIOs */ 1793 { 0x0f, 0x01211020 }, 1794 { 0x10, 0x0001003f }, 1795 { 0x11, 0x411111f0 }, 1796 { 0x12, 0x01a15930 }, 1797 { 0x13, 0x411111f0 }, 1798 { 0x14, 0x411111f0 }, 1799 { 0x15, 0x411111f0 }, 1800 { 0x16, 0x411111f0 }, 1801 { 0x17, 0x411111f0 }, 1802 { 0x18, 0x411111f0 }, 1803 { 0x19, 0x411111f0 }, 1804 { } 1805 } 1806 }, 1807 }; 1808 1809 static const struct snd_pci_quirk alc260_fixup_tbl[] = { 1810 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1), 1811 SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF), 1812 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1), 1813 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750), 1814 SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900), 1815 SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS), 1816 SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F), 1817 SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020), 1818 SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1), 1819 SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1), 1820 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER), 1821 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF), 1822 {} 1823 }; 1824 1825 static const struct hda_model_fixup alc260_fixup_models[] = { 1826 {.id = ALC260_FIXUP_GPIO1, .name = "gpio1"}, 1827 {.id = ALC260_FIXUP_COEF, .name = "coef"}, 1828 {.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"}, 1829 {.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"}, 1830 {} 1831 }; 1832 1833 /* 1834 */ 1835 static int patch_alc260(struct hda_codec *codec) 1836 { 1837 struct alc_spec *spec; 1838 int err; 1839 1840 err = alc_alloc_spec(codec, 0x07); 1841 if (err < 0) 1842 return err; 1843 1844 spec = codec->spec; 1845 /* as quite a few machines require HP amp for speaker outputs, 1846 * it's easier to enable it unconditionally; even if it's unneeded, 1847 * it's almost harmless. 1848 */ 1849 spec->gen.prefer_hp_amp = 1; 1850 spec->gen.beep_nid = 0x01; 1851 1852 spec->shutup = alc_eapd_shutup; 1853 1854 alc_pre_init(codec); 1855 1856 snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl, 1857 alc260_fixups); 1858 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 1859 1860 /* automatic parse from the BIOS config */ 1861 err = alc260_parse_auto_config(codec); 1862 if (err < 0) 1863 goto error; 1864 1865 if (!spec->gen.no_analog) { 1866 err = set_beep_amp(spec, 0x07, 0x05, HDA_INPUT); 1867 if (err < 0) 1868 goto error; 1869 } 1870 1871 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 1872 1873 return 0; 1874 1875 error: 1876 alc_free(codec); 1877 return err; 1878 } 1879 1880 1881 /* 1882 * ALC882/883/885/888/889 support 1883 * 1884 * ALC882 is almost identical with ALC880 but has cleaner and more flexible 1885 * configuration. Each pin widget can choose any input DACs and a mixer. 1886 * Each ADC is connected from a mixer of all inputs. This makes possible 1887 * 6-channel independent captures. 1888 * 1889 * In addition, an independent DAC for the multi-playback (not used in this 1890 * driver yet). 1891 */ 1892 1893 /* 1894 * Pin config fixes 1895 */ 1896 enum { 1897 ALC882_FIXUP_ABIT_AW9D_MAX, 1898 ALC882_FIXUP_LENOVO_Y530, 1899 ALC882_FIXUP_PB_M5210, 1900 ALC882_FIXUP_ACER_ASPIRE_7736, 1901 ALC882_FIXUP_ASUS_W90V, 1902 ALC889_FIXUP_CD, 1903 ALC889_FIXUP_FRONT_HP_NO_PRESENCE, 1904 ALC889_FIXUP_VAIO_TT, 1905 ALC888_FIXUP_EEE1601, 1906 ALC882_FIXUP_EAPD, 1907 ALC883_FIXUP_EAPD, 1908 ALC883_FIXUP_ACER_EAPD, 1909 ALC882_FIXUP_GPIO1, 1910 ALC882_FIXUP_GPIO2, 1911 ALC882_FIXUP_GPIO3, 1912 ALC889_FIXUP_COEF, 1913 ALC882_FIXUP_ASUS_W2JC, 1914 ALC882_FIXUP_ACER_ASPIRE_4930G, 1915 ALC882_FIXUP_ACER_ASPIRE_8930G, 1916 ALC882_FIXUP_ASPIRE_8930G_VERBS, 1917 ALC885_FIXUP_MACPRO_GPIO, 1918 ALC889_FIXUP_DAC_ROUTE, 1919 ALC889_FIXUP_MBP_VREF, 1920 ALC889_FIXUP_IMAC91_VREF, 1921 ALC889_FIXUP_MBA11_VREF, 1922 ALC889_FIXUP_MBA21_VREF, 1923 ALC889_FIXUP_MP11_VREF, 1924 ALC889_FIXUP_MP41_VREF, 1925 ALC882_FIXUP_INV_DMIC, 1926 ALC882_FIXUP_NO_PRIMARY_HP, 1927 ALC887_FIXUP_ASUS_BASS, 1928 ALC887_FIXUP_BASS_CHMAP, 1929 ALC1220_FIXUP_GB_DUAL_CODECS, 1930 ALC1220_FIXUP_CLEVO_P950, 1931 ALC1220_FIXUP_CLEVO_PB51ED, 1932 ALC1220_FIXUP_CLEVO_PB51ED_PINS, 1933 ALC887_FIXUP_ASUS_AUDIO, 1934 ALC887_FIXUP_ASUS_HMIC, 1935 }; 1936 1937 static void alc889_fixup_coef(struct hda_codec *codec, 1938 const struct hda_fixup *fix, int action) 1939 { 1940 if (action != HDA_FIXUP_ACT_INIT) 1941 return; 1942 alc_update_coef_idx(codec, 7, 0, 0x2030); 1943 } 1944 1945 /* set up GPIO at initialization */ 1946 static void alc885_fixup_macpro_gpio(struct hda_codec *codec, 1947 const struct hda_fixup *fix, int action) 1948 { 1949 struct alc_spec *spec = codec->spec; 1950 1951 spec->gpio_write_delay = true; 1952 alc_fixup_gpio3(codec, fix, action); 1953 } 1954 1955 /* Fix the connection of some pins for ALC889: 1956 * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't 1957 * work correctly (bko#42740) 1958 */ 1959 static void alc889_fixup_dac_route(struct hda_codec *codec, 1960 const struct hda_fixup *fix, int action) 1961 { 1962 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1963 /* fake the connections during parsing the tree */ 1964 static const hda_nid_t conn1[] = { 0x0c, 0x0d }; 1965 static const hda_nid_t conn2[] = { 0x0e, 0x0f }; 1966 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1); 1967 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1); 1968 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn2), conn2); 1969 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn2), conn2); 1970 } else if (action == HDA_FIXUP_ACT_PROBE) { 1971 /* restore the connections */ 1972 static const hda_nid_t conn[] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 }; 1973 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn); 1974 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn), conn); 1975 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn), conn); 1976 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn), conn); 1977 } 1978 } 1979 1980 /* Set VREF on HP pin */ 1981 static void alc889_fixup_mbp_vref(struct hda_codec *codec, 1982 const struct hda_fixup *fix, int action) 1983 { 1984 static const hda_nid_t nids[] = { 0x14, 0x15, 0x19 }; 1985 struct alc_spec *spec = codec->spec; 1986 int i; 1987 1988 if (action != HDA_FIXUP_ACT_INIT) 1989 return; 1990 for (i = 0; i < ARRAY_SIZE(nids); i++) { 1991 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]); 1992 if (get_defcfg_device(val) != AC_JACK_HP_OUT) 1993 continue; 1994 val = snd_hda_codec_get_pin_target(codec, nids[i]); 1995 val |= AC_PINCTL_VREF_80; 1996 snd_hda_set_pin_ctl(codec, nids[i], val); 1997 spec->gen.keep_vref_in_automute = 1; 1998 break; 1999 } 2000 } 2001 2002 static void alc889_fixup_mac_pins(struct hda_codec *codec, 2003 const hda_nid_t *nids, int num_nids) 2004 { 2005 struct alc_spec *spec = codec->spec; 2006 int i; 2007 2008 for (i = 0; i < num_nids; i++) { 2009 unsigned int val; 2010 val = snd_hda_codec_get_pin_target(codec, nids[i]); 2011 val |= AC_PINCTL_VREF_50; 2012 snd_hda_set_pin_ctl(codec, nids[i], val); 2013 } 2014 spec->gen.keep_vref_in_automute = 1; 2015 } 2016 2017 /* Set VREF on speaker pins on imac91 */ 2018 static void alc889_fixup_imac91_vref(struct hda_codec *codec, 2019 const struct hda_fixup *fix, int action) 2020 { 2021 static const hda_nid_t nids[] = { 0x18, 0x1a }; 2022 2023 if (action == HDA_FIXUP_ACT_INIT) 2024 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids)); 2025 } 2026 2027 /* Set VREF on speaker pins on mba11 */ 2028 static void alc889_fixup_mba11_vref(struct hda_codec *codec, 2029 const struct hda_fixup *fix, int action) 2030 { 2031 static const hda_nid_t nids[] = { 0x18 }; 2032 2033 if (action == HDA_FIXUP_ACT_INIT) 2034 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids)); 2035 } 2036 2037 /* Set VREF on speaker pins on mba21 */ 2038 static void alc889_fixup_mba21_vref(struct hda_codec *codec, 2039 const struct hda_fixup *fix, int action) 2040 { 2041 static const hda_nid_t nids[] = { 0x18, 0x19 }; 2042 2043 if (action == HDA_FIXUP_ACT_INIT) 2044 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids)); 2045 } 2046 2047 /* Don't take HP output as primary 2048 * Strangely, the speaker output doesn't work on Vaio Z and some Vaio 2049 * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05 2050 */ 2051 static void alc882_fixup_no_primary_hp(struct hda_codec *codec, 2052 const struct hda_fixup *fix, int action) 2053 { 2054 struct alc_spec *spec = codec->spec; 2055 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2056 spec->gen.no_primary_hp = 1; 2057 spec->gen.no_multi_io = 1; 2058 } 2059 } 2060 2061 static void alc_fixup_bass_chmap(struct hda_codec *codec, 2062 const struct hda_fixup *fix, int action); 2063 2064 /* For dual-codec configuration, we need to disable some features to avoid 2065 * conflicts of kctls and PCM streams 2066 */ 2067 static void alc_fixup_dual_codecs(struct hda_codec *codec, 2068 const struct hda_fixup *fix, int action) 2069 { 2070 struct alc_spec *spec = codec->spec; 2071 2072 if (action != HDA_FIXUP_ACT_PRE_PROBE) 2073 return; 2074 /* disable vmaster */ 2075 spec->gen.suppress_vmaster = 1; 2076 /* auto-mute and auto-mic switch don't work with multiple codecs */ 2077 spec->gen.suppress_auto_mute = 1; 2078 spec->gen.suppress_auto_mic = 1; 2079 /* disable aamix as well */ 2080 spec->gen.mixer_nid = 0; 2081 /* add location prefix to avoid conflicts */ 2082 codec->force_pin_prefix = 1; 2083 } 2084 2085 static void rename_ctl(struct hda_codec *codec, const char *oldname, 2086 const char *newname) 2087 { 2088 struct snd_kcontrol *kctl; 2089 2090 kctl = snd_hda_find_mixer_ctl(codec, oldname); 2091 if (kctl) 2092 strcpy(kctl->id.name, newname); 2093 } 2094 2095 static void alc1220_fixup_gb_dual_codecs(struct hda_codec *codec, 2096 const struct hda_fixup *fix, 2097 int action) 2098 { 2099 alc_fixup_dual_codecs(codec, fix, action); 2100 switch (action) { 2101 case HDA_FIXUP_ACT_PRE_PROBE: 2102 /* override card longname to provide a unique UCM profile */ 2103 strcpy(codec->card->longname, "HDAudio-Gigabyte-ALC1220DualCodecs"); 2104 break; 2105 case HDA_FIXUP_ACT_BUILD: 2106 /* rename Capture controls depending on the codec */ 2107 rename_ctl(codec, "Capture Volume", 2108 codec->addr == 0 ? 2109 "Rear-Panel Capture Volume" : 2110 "Front-Panel Capture Volume"); 2111 rename_ctl(codec, "Capture Switch", 2112 codec->addr == 0 ? 2113 "Rear-Panel Capture Switch" : 2114 "Front-Panel Capture Switch"); 2115 break; 2116 } 2117 } 2118 2119 static void alc1220_fixup_clevo_p950(struct hda_codec *codec, 2120 const struct hda_fixup *fix, 2121 int action) 2122 { 2123 static const hda_nid_t conn1[] = { 0x0c }; 2124 2125 if (action != HDA_FIXUP_ACT_PRE_PROBE) 2126 return; 2127 2128 alc_update_coef_idx(codec, 0x7, 0, 0x3c3); 2129 /* We therefore want to make sure 0x14 (front headphone) and 2130 * 0x1b (speakers) use the stereo DAC 0x02 2131 */ 2132 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1); 2133 snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1); 2134 } 2135 2136 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec, 2137 const struct hda_fixup *fix, int action); 2138 2139 static void alc1220_fixup_clevo_pb51ed(struct hda_codec *codec, 2140 const struct hda_fixup *fix, 2141 int action) 2142 { 2143 alc1220_fixup_clevo_p950(codec, fix, action); 2144 alc_fixup_headset_mode_no_hp_mic(codec, fix, action); 2145 } 2146 2147 static void alc887_asus_hp_automute_hook(struct hda_codec *codec, 2148 struct hda_jack_callback *jack) 2149 { 2150 struct alc_spec *spec = codec->spec; 2151 unsigned int vref; 2152 2153 snd_hda_gen_hp_automute(codec, jack); 2154 2155 if (spec->gen.hp_jack_present) 2156 vref = AC_PINCTL_VREF_80; 2157 else 2158 vref = AC_PINCTL_VREF_HIZ; 2159 snd_hda_set_pin_ctl(codec, 0x19, PIN_HP | vref); 2160 } 2161 2162 static void alc887_fixup_asus_jack(struct hda_codec *codec, 2163 const struct hda_fixup *fix, int action) 2164 { 2165 struct alc_spec *spec = codec->spec; 2166 if (action != HDA_FIXUP_ACT_PROBE) 2167 return; 2168 snd_hda_set_pin_ctl_cache(codec, 0x1b, PIN_HP); 2169 spec->gen.hp_automute_hook = alc887_asus_hp_automute_hook; 2170 } 2171 2172 static const struct hda_fixup alc882_fixups[] = { 2173 [ALC882_FIXUP_ABIT_AW9D_MAX] = { 2174 .type = HDA_FIXUP_PINS, 2175 .v.pins = (const struct hda_pintbl[]) { 2176 { 0x15, 0x01080104 }, /* side */ 2177 { 0x16, 0x01011012 }, /* rear */ 2178 { 0x17, 0x01016011 }, /* clfe */ 2179 { } 2180 } 2181 }, 2182 [ALC882_FIXUP_LENOVO_Y530] = { 2183 .type = HDA_FIXUP_PINS, 2184 .v.pins = (const struct hda_pintbl[]) { 2185 { 0x15, 0x99130112 }, /* rear int speakers */ 2186 { 0x16, 0x99130111 }, /* subwoofer */ 2187 { } 2188 } 2189 }, 2190 [ALC882_FIXUP_PB_M5210] = { 2191 .type = HDA_FIXUP_PINCTLS, 2192 .v.pins = (const struct hda_pintbl[]) { 2193 { 0x19, PIN_VREF50 }, 2194 {} 2195 } 2196 }, 2197 [ALC882_FIXUP_ACER_ASPIRE_7736] = { 2198 .type = HDA_FIXUP_FUNC, 2199 .v.func = alc_fixup_sku_ignore, 2200 }, 2201 [ALC882_FIXUP_ASUS_W90V] = { 2202 .type = HDA_FIXUP_PINS, 2203 .v.pins = (const struct hda_pintbl[]) { 2204 { 0x16, 0x99130110 }, /* fix sequence for CLFE */ 2205 { } 2206 } 2207 }, 2208 [ALC889_FIXUP_CD] = { 2209 .type = HDA_FIXUP_PINS, 2210 .v.pins = (const struct hda_pintbl[]) { 2211 { 0x1c, 0x993301f0 }, /* CD */ 2212 { } 2213 } 2214 }, 2215 [ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = { 2216 .type = HDA_FIXUP_PINS, 2217 .v.pins = (const struct hda_pintbl[]) { 2218 { 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */ 2219 { } 2220 }, 2221 .chained = true, 2222 .chain_id = ALC889_FIXUP_CD, 2223 }, 2224 [ALC889_FIXUP_VAIO_TT] = { 2225 .type = HDA_FIXUP_PINS, 2226 .v.pins = (const struct hda_pintbl[]) { 2227 { 0x17, 0x90170111 }, /* hidden surround speaker */ 2228 { } 2229 } 2230 }, 2231 [ALC888_FIXUP_EEE1601] = { 2232 .type = HDA_FIXUP_VERBS, 2233 .v.verbs = (const struct hda_verb[]) { 2234 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b }, 2235 { 0x20, AC_VERB_SET_PROC_COEF, 0x0838 }, 2236 { } 2237 } 2238 }, 2239 [ALC882_FIXUP_EAPD] = { 2240 .type = HDA_FIXUP_VERBS, 2241 .v.verbs = (const struct hda_verb[]) { 2242 /* change to EAPD mode */ 2243 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2244 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 }, 2245 { } 2246 } 2247 }, 2248 [ALC883_FIXUP_EAPD] = { 2249 .type = HDA_FIXUP_VERBS, 2250 .v.verbs = (const struct hda_verb[]) { 2251 /* change to EAPD mode */ 2252 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2253 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 }, 2254 { } 2255 } 2256 }, 2257 [ALC883_FIXUP_ACER_EAPD] = { 2258 .type = HDA_FIXUP_VERBS, 2259 .v.verbs = (const struct hda_verb[]) { 2260 /* eanable EAPD on Acer laptops */ 2261 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2262 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 }, 2263 { } 2264 } 2265 }, 2266 [ALC882_FIXUP_GPIO1] = { 2267 .type = HDA_FIXUP_FUNC, 2268 .v.func = alc_fixup_gpio1, 2269 }, 2270 [ALC882_FIXUP_GPIO2] = { 2271 .type = HDA_FIXUP_FUNC, 2272 .v.func = alc_fixup_gpio2, 2273 }, 2274 [ALC882_FIXUP_GPIO3] = { 2275 .type = HDA_FIXUP_FUNC, 2276 .v.func = alc_fixup_gpio3, 2277 }, 2278 [ALC882_FIXUP_ASUS_W2JC] = { 2279 .type = HDA_FIXUP_FUNC, 2280 .v.func = alc_fixup_gpio1, 2281 .chained = true, 2282 .chain_id = ALC882_FIXUP_EAPD, 2283 }, 2284 [ALC889_FIXUP_COEF] = { 2285 .type = HDA_FIXUP_FUNC, 2286 .v.func = alc889_fixup_coef, 2287 }, 2288 [ALC882_FIXUP_ACER_ASPIRE_4930G] = { 2289 .type = HDA_FIXUP_PINS, 2290 .v.pins = (const struct hda_pintbl[]) { 2291 { 0x16, 0x99130111 }, /* CLFE speaker */ 2292 { 0x17, 0x99130112 }, /* surround speaker */ 2293 { } 2294 }, 2295 .chained = true, 2296 .chain_id = ALC882_FIXUP_GPIO1, 2297 }, 2298 [ALC882_FIXUP_ACER_ASPIRE_8930G] = { 2299 .type = HDA_FIXUP_PINS, 2300 .v.pins = (const struct hda_pintbl[]) { 2301 { 0x16, 0x99130111 }, /* CLFE speaker */ 2302 { 0x1b, 0x99130112 }, /* surround speaker */ 2303 { } 2304 }, 2305 .chained = true, 2306 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS, 2307 }, 2308 [ALC882_FIXUP_ASPIRE_8930G_VERBS] = { 2309 /* additional init verbs for Acer Aspire 8930G */ 2310 .type = HDA_FIXUP_VERBS, 2311 .v.verbs = (const struct hda_verb[]) { 2312 /* Enable all DACs */ 2313 /* DAC DISABLE/MUTE 1? */ 2314 /* setting bits 1-5 disables DAC nids 0x02-0x06 2315 * apparently. Init=0x38 */ 2316 { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 }, 2317 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 }, 2318 /* DAC DISABLE/MUTE 2? */ 2319 /* some bit here disables the other DACs. 2320 * Init=0x4900 */ 2321 { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 }, 2322 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 }, 2323 /* DMIC fix 2324 * This laptop has a stereo digital microphone. 2325 * The mics are only 1cm apart which makes the stereo 2326 * useless. However, either the mic or the ALC889 2327 * makes the signal become a difference/sum signal 2328 * instead of standard stereo, which is annoying. 2329 * So instead we flip this bit which makes the 2330 * codec replicate the sum signal to both channels, 2331 * turning it into a normal mono mic. 2332 */ 2333 /* DMIC_CONTROL? Init value = 0x0001 */ 2334 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b }, 2335 { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 }, 2336 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2337 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 }, 2338 { } 2339 }, 2340 .chained = true, 2341 .chain_id = ALC882_FIXUP_GPIO1, 2342 }, 2343 [ALC885_FIXUP_MACPRO_GPIO] = { 2344 .type = HDA_FIXUP_FUNC, 2345 .v.func = alc885_fixup_macpro_gpio, 2346 }, 2347 [ALC889_FIXUP_DAC_ROUTE] = { 2348 .type = HDA_FIXUP_FUNC, 2349 .v.func = alc889_fixup_dac_route, 2350 }, 2351 [ALC889_FIXUP_MBP_VREF] = { 2352 .type = HDA_FIXUP_FUNC, 2353 .v.func = alc889_fixup_mbp_vref, 2354 .chained = true, 2355 .chain_id = ALC882_FIXUP_GPIO1, 2356 }, 2357 [ALC889_FIXUP_IMAC91_VREF] = { 2358 .type = HDA_FIXUP_FUNC, 2359 .v.func = alc889_fixup_imac91_vref, 2360 .chained = true, 2361 .chain_id = ALC882_FIXUP_GPIO1, 2362 }, 2363 [ALC889_FIXUP_MBA11_VREF] = { 2364 .type = HDA_FIXUP_FUNC, 2365 .v.func = alc889_fixup_mba11_vref, 2366 .chained = true, 2367 .chain_id = ALC889_FIXUP_MBP_VREF, 2368 }, 2369 [ALC889_FIXUP_MBA21_VREF] = { 2370 .type = HDA_FIXUP_FUNC, 2371 .v.func = alc889_fixup_mba21_vref, 2372 .chained = true, 2373 .chain_id = ALC889_FIXUP_MBP_VREF, 2374 }, 2375 [ALC889_FIXUP_MP11_VREF] = { 2376 .type = HDA_FIXUP_FUNC, 2377 .v.func = alc889_fixup_mba11_vref, 2378 .chained = true, 2379 .chain_id = ALC885_FIXUP_MACPRO_GPIO, 2380 }, 2381 [ALC889_FIXUP_MP41_VREF] = { 2382 .type = HDA_FIXUP_FUNC, 2383 .v.func = alc889_fixup_mbp_vref, 2384 .chained = true, 2385 .chain_id = ALC885_FIXUP_MACPRO_GPIO, 2386 }, 2387 [ALC882_FIXUP_INV_DMIC] = { 2388 .type = HDA_FIXUP_FUNC, 2389 .v.func = alc_fixup_inv_dmic, 2390 }, 2391 [ALC882_FIXUP_NO_PRIMARY_HP] = { 2392 .type = HDA_FIXUP_FUNC, 2393 .v.func = alc882_fixup_no_primary_hp, 2394 }, 2395 [ALC887_FIXUP_ASUS_BASS] = { 2396 .type = HDA_FIXUP_PINS, 2397 .v.pins = (const struct hda_pintbl[]) { 2398 {0x16, 0x99130130}, /* bass speaker */ 2399 {} 2400 }, 2401 .chained = true, 2402 .chain_id = ALC887_FIXUP_BASS_CHMAP, 2403 }, 2404 [ALC887_FIXUP_BASS_CHMAP] = { 2405 .type = HDA_FIXUP_FUNC, 2406 .v.func = alc_fixup_bass_chmap, 2407 }, 2408 [ALC1220_FIXUP_GB_DUAL_CODECS] = { 2409 .type = HDA_FIXUP_FUNC, 2410 .v.func = alc1220_fixup_gb_dual_codecs, 2411 }, 2412 [ALC1220_FIXUP_CLEVO_P950] = { 2413 .type = HDA_FIXUP_FUNC, 2414 .v.func = alc1220_fixup_clevo_p950, 2415 }, 2416 [ALC1220_FIXUP_CLEVO_PB51ED] = { 2417 .type = HDA_FIXUP_FUNC, 2418 .v.func = alc1220_fixup_clevo_pb51ed, 2419 }, 2420 [ALC1220_FIXUP_CLEVO_PB51ED_PINS] = { 2421 .type = HDA_FIXUP_PINS, 2422 .v.pins = (const struct hda_pintbl[]) { 2423 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 2424 {} 2425 }, 2426 .chained = true, 2427 .chain_id = ALC1220_FIXUP_CLEVO_PB51ED, 2428 }, 2429 [ALC887_FIXUP_ASUS_AUDIO] = { 2430 .type = HDA_FIXUP_PINS, 2431 .v.pins = (const struct hda_pintbl[]) { 2432 { 0x15, 0x02a14150 }, /* use as headset mic, without its own jack detect */ 2433 { 0x19, 0x22219420 }, 2434 {} 2435 }, 2436 }, 2437 [ALC887_FIXUP_ASUS_HMIC] = { 2438 .type = HDA_FIXUP_FUNC, 2439 .v.func = alc887_fixup_asus_jack, 2440 .chained = true, 2441 .chain_id = ALC887_FIXUP_ASUS_AUDIO, 2442 }, 2443 }; 2444 2445 static const struct snd_pci_quirk alc882_fixup_tbl[] = { 2446 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD), 2447 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD), 2448 SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD), 2449 SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD), 2450 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD), 2451 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD), 2452 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD), 2453 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G", 2454 ALC882_FIXUP_ACER_ASPIRE_4930G), 2455 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G", 2456 ALC882_FIXUP_ACER_ASPIRE_4930G), 2457 SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G", 2458 ALC882_FIXUP_ACER_ASPIRE_8930G), 2459 SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G", 2460 ALC882_FIXUP_ACER_ASPIRE_8930G), 2461 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G", 2462 ALC882_FIXUP_ACER_ASPIRE_4930G), 2463 SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G", 2464 ALC882_FIXUP_ACER_ASPIRE_4930G), 2465 SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G", 2466 ALC882_FIXUP_ACER_ASPIRE_4930G), 2467 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210), 2468 SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G", 2469 ALC882_FIXUP_ACER_ASPIRE_4930G), 2470 SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE), 2471 SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G), 2472 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736), 2473 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD), 2474 SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V), 2475 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC), 2476 SND_PCI_QUIRK(0x1043, 0x2390, "Asus D700SA", ALC887_FIXUP_ASUS_HMIC), 2477 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601), 2478 SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS), 2479 SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3), 2480 SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT), 2481 SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP), 2482 SND_PCI_QUIRK(0x104d, 0x9060, "Sony Vaio VPCL14M1R", ALC882_FIXUP_NO_PRIMARY_HP), 2483 SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP), 2484 SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP), 2485 2486 /* All Apple entries are in codec SSIDs */ 2487 SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF), 2488 SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF), 2489 SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF), 2490 SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF), 2491 SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO), 2492 SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO), 2493 SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF), 2494 SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF), 2495 SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD), 2496 SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF), 2497 SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF), 2498 SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF), 2499 SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF), 2500 SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO), 2501 SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF), 2502 SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF), 2503 SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF), 2504 SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF), 2505 SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF), 2506 SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF), 2507 SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF), 2508 SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF), 2509 2510 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD), 2511 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE), 2512 SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS), 2513 SND_PCI_QUIRK(0x1458, 0xa0cd, "Gigabyte X570 Aorus Master", ALC1220_FIXUP_CLEVO_P950), 2514 SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_CLEVO_P950), 2515 SND_PCI_QUIRK(0x1462, 0x11f7, "MSI-GE63", ALC1220_FIXUP_CLEVO_P950), 2516 SND_PCI_QUIRK(0x1462, 0x1228, "MSI-GP63", ALC1220_FIXUP_CLEVO_P950), 2517 SND_PCI_QUIRK(0x1462, 0x1275, "MSI-GL63", ALC1220_FIXUP_CLEVO_P950), 2518 SND_PCI_QUIRK(0x1462, 0x1276, "MSI-GL73", ALC1220_FIXUP_CLEVO_P950), 2519 SND_PCI_QUIRK(0x1462, 0x1293, "MSI-GP65", ALC1220_FIXUP_CLEVO_P950), 2520 SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD), 2521 SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS), 2522 SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3), 2523 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX), 2524 SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950), 2525 SND_PCI_QUIRK(0x1558, 0x95e1, "Clevo P95xER", ALC1220_FIXUP_CLEVO_P950), 2526 SND_PCI_QUIRK(0x1558, 0x95e2, "Clevo P950ER", ALC1220_FIXUP_CLEVO_P950), 2527 SND_PCI_QUIRK(0x1558, 0x96e1, "Clevo P960[ER][CDFN]-K", ALC1220_FIXUP_CLEVO_P950), 2528 SND_PCI_QUIRK(0x1558, 0x97e1, "Clevo P970[ER][CDFN]", ALC1220_FIXUP_CLEVO_P950), 2529 SND_PCI_QUIRK(0x1558, 0x65d1, "Clevo PB51[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2530 SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2531 SND_PCI_QUIRK(0x1558, 0x50d3, "Clevo PC50[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2532 SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2533 SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2534 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD), 2535 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD), 2536 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530), 2537 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF), 2538 {} 2539 }; 2540 2541 static const struct hda_model_fixup alc882_fixup_models[] = { 2542 {.id = ALC882_FIXUP_ABIT_AW9D_MAX, .name = "abit-aw9d"}, 2543 {.id = ALC882_FIXUP_LENOVO_Y530, .name = "lenovo-y530"}, 2544 {.id = ALC882_FIXUP_ACER_ASPIRE_7736, .name = "acer-aspire-7736"}, 2545 {.id = ALC882_FIXUP_ASUS_W90V, .name = "asus-w90v"}, 2546 {.id = ALC889_FIXUP_CD, .name = "cd"}, 2547 {.id = ALC889_FIXUP_FRONT_HP_NO_PRESENCE, .name = "no-front-hp"}, 2548 {.id = ALC889_FIXUP_VAIO_TT, .name = "vaio-tt"}, 2549 {.id = ALC888_FIXUP_EEE1601, .name = "eee1601"}, 2550 {.id = ALC882_FIXUP_EAPD, .name = "alc882-eapd"}, 2551 {.id = ALC883_FIXUP_EAPD, .name = "alc883-eapd"}, 2552 {.id = ALC882_FIXUP_GPIO1, .name = "gpio1"}, 2553 {.id = ALC882_FIXUP_GPIO2, .name = "gpio2"}, 2554 {.id = ALC882_FIXUP_GPIO3, .name = "gpio3"}, 2555 {.id = ALC889_FIXUP_COEF, .name = "alc889-coef"}, 2556 {.id = ALC882_FIXUP_ASUS_W2JC, .name = "asus-w2jc"}, 2557 {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"}, 2558 {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"}, 2559 {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"}, 2560 {.id = ALC885_FIXUP_MACPRO_GPIO, .name = "macpro-gpio"}, 2561 {.id = ALC889_FIXUP_DAC_ROUTE, .name = "dac-route"}, 2562 {.id = ALC889_FIXUP_MBP_VREF, .name = "mbp-vref"}, 2563 {.id = ALC889_FIXUP_IMAC91_VREF, .name = "imac91-vref"}, 2564 {.id = ALC889_FIXUP_MBA11_VREF, .name = "mba11-vref"}, 2565 {.id = ALC889_FIXUP_MBA21_VREF, .name = "mba21-vref"}, 2566 {.id = ALC889_FIXUP_MP11_VREF, .name = "mp11-vref"}, 2567 {.id = ALC889_FIXUP_MP41_VREF, .name = "mp41-vref"}, 2568 {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"}, 2569 {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"}, 2570 {.id = ALC887_FIXUP_ASUS_BASS, .name = "asus-bass"}, 2571 {.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"}, 2572 {.id = ALC1220_FIXUP_CLEVO_P950, .name = "clevo-p950"}, 2573 {} 2574 }; 2575 2576 /* 2577 * BIOS auto configuration 2578 */ 2579 /* almost identical with ALC880 parser... */ 2580 static int alc882_parse_auto_config(struct hda_codec *codec) 2581 { 2582 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 }; 2583 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 2584 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids); 2585 } 2586 2587 /* 2588 */ 2589 static int patch_alc882(struct hda_codec *codec) 2590 { 2591 struct alc_spec *spec; 2592 int err; 2593 2594 err = alc_alloc_spec(codec, 0x0b); 2595 if (err < 0) 2596 return err; 2597 2598 spec = codec->spec; 2599 2600 switch (codec->core.vendor_id) { 2601 case 0x10ec0882: 2602 case 0x10ec0885: 2603 case 0x10ec0900: 2604 case 0x10ec0b00: 2605 case 0x10ec1220: 2606 break; 2607 default: 2608 /* ALC883 and variants */ 2609 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 2610 break; 2611 } 2612 2613 alc_pre_init(codec); 2614 2615 snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl, 2616 alc882_fixups); 2617 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 2618 2619 alc_auto_parse_customize_define(codec); 2620 2621 if (has_cdefine_beep(codec)) 2622 spec->gen.beep_nid = 0x01; 2623 2624 /* automatic parse from the BIOS config */ 2625 err = alc882_parse_auto_config(codec); 2626 if (err < 0) 2627 goto error; 2628 2629 if (!spec->gen.no_analog && spec->gen.beep_nid) { 2630 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 2631 if (err < 0) 2632 goto error; 2633 } 2634 2635 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 2636 2637 return 0; 2638 2639 error: 2640 alc_free(codec); 2641 return err; 2642 } 2643 2644 2645 /* 2646 * ALC262 support 2647 */ 2648 static int alc262_parse_auto_config(struct hda_codec *codec) 2649 { 2650 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 }; 2651 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 2652 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids); 2653 } 2654 2655 /* 2656 * Pin config fixes 2657 */ 2658 enum { 2659 ALC262_FIXUP_FSC_H270, 2660 ALC262_FIXUP_FSC_S7110, 2661 ALC262_FIXUP_HP_Z200, 2662 ALC262_FIXUP_TYAN, 2663 ALC262_FIXUP_LENOVO_3000, 2664 ALC262_FIXUP_BENQ, 2665 ALC262_FIXUP_BENQ_T31, 2666 ALC262_FIXUP_INV_DMIC, 2667 ALC262_FIXUP_INTEL_BAYLEYBAY, 2668 }; 2669 2670 static const struct hda_fixup alc262_fixups[] = { 2671 [ALC262_FIXUP_FSC_H270] = { 2672 .type = HDA_FIXUP_PINS, 2673 .v.pins = (const struct hda_pintbl[]) { 2674 { 0x14, 0x99130110 }, /* speaker */ 2675 { 0x15, 0x0221142f }, /* front HP */ 2676 { 0x1b, 0x0121141f }, /* rear HP */ 2677 { } 2678 } 2679 }, 2680 [ALC262_FIXUP_FSC_S7110] = { 2681 .type = HDA_FIXUP_PINS, 2682 .v.pins = (const struct hda_pintbl[]) { 2683 { 0x15, 0x90170110 }, /* speaker */ 2684 { } 2685 }, 2686 .chained = true, 2687 .chain_id = ALC262_FIXUP_BENQ, 2688 }, 2689 [ALC262_FIXUP_HP_Z200] = { 2690 .type = HDA_FIXUP_PINS, 2691 .v.pins = (const struct hda_pintbl[]) { 2692 { 0x16, 0x99130120 }, /* internal speaker */ 2693 { } 2694 } 2695 }, 2696 [ALC262_FIXUP_TYAN] = { 2697 .type = HDA_FIXUP_PINS, 2698 .v.pins = (const struct hda_pintbl[]) { 2699 { 0x14, 0x1993e1f0 }, /* int AUX */ 2700 { } 2701 } 2702 }, 2703 [ALC262_FIXUP_LENOVO_3000] = { 2704 .type = HDA_FIXUP_PINCTLS, 2705 .v.pins = (const struct hda_pintbl[]) { 2706 { 0x19, PIN_VREF50 }, 2707 {} 2708 }, 2709 .chained = true, 2710 .chain_id = ALC262_FIXUP_BENQ, 2711 }, 2712 [ALC262_FIXUP_BENQ] = { 2713 .type = HDA_FIXUP_VERBS, 2714 .v.verbs = (const struct hda_verb[]) { 2715 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2716 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 }, 2717 {} 2718 } 2719 }, 2720 [ALC262_FIXUP_BENQ_T31] = { 2721 .type = HDA_FIXUP_VERBS, 2722 .v.verbs = (const struct hda_verb[]) { 2723 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2724 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 }, 2725 {} 2726 } 2727 }, 2728 [ALC262_FIXUP_INV_DMIC] = { 2729 .type = HDA_FIXUP_FUNC, 2730 .v.func = alc_fixup_inv_dmic, 2731 }, 2732 [ALC262_FIXUP_INTEL_BAYLEYBAY] = { 2733 .type = HDA_FIXUP_FUNC, 2734 .v.func = alc_fixup_no_depop_delay, 2735 }, 2736 }; 2737 2738 static const struct snd_pci_quirk alc262_fixup_tbl[] = { 2739 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200), 2740 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110), 2741 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ), 2742 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN), 2743 SND_PCI_QUIRK(0x1734, 0x1141, "FSC ESPRIMO U9210", ALC262_FIXUP_FSC_H270), 2744 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270), 2745 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000), 2746 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ), 2747 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31), 2748 SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY), 2749 {} 2750 }; 2751 2752 static const struct hda_model_fixup alc262_fixup_models[] = { 2753 {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"}, 2754 {.id = ALC262_FIXUP_FSC_H270, .name = "fsc-h270"}, 2755 {.id = ALC262_FIXUP_FSC_S7110, .name = "fsc-s7110"}, 2756 {.id = ALC262_FIXUP_HP_Z200, .name = "hp-z200"}, 2757 {.id = ALC262_FIXUP_TYAN, .name = "tyan"}, 2758 {.id = ALC262_FIXUP_LENOVO_3000, .name = "lenovo-3000"}, 2759 {.id = ALC262_FIXUP_BENQ, .name = "benq"}, 2760 {.id = ALC262_FIXUP_BENQ_T31, .name = "benq-t31"}, 2761 {.id = ALC262_FIXUP_INTEL_BAYLEYBAY, .name = "bayleybay"}, 2762 {} 2763 }; 2764 2765 /* 2766 */ 2767 static int patch_alc262(struct hda_codec *codec) 2768 { 2769 struct alc_spec *spec; 2770 int err; 2771 2772 err = alc_alloc_spec(codec, 0x0b); 2773 if (err < 0) 2774 return err; 2775 2776 spec = codec->spec; 2777 spec->gen.shared_mic_vref_pin = 0x18; 2778 2779 spec->shutup = alc_eapd_shutup; 2780 2781 #if 0 2782 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is 2783 * under-run 2784 */ 2785 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80); 2786 #endif 2787 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 2788 2789 alc_pre_init(codec); 2790 2791 snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl, 2792 alc262_fixups); 2793 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 2794 2795 alc_auto_parse_customize_define(codec); 2796 2797 if (has_cdefine_beep(codec)) 2798 spec->gen.beep_nid = 0x01; 2799 2800 /* automatic parse from the BIOS config */ 2801 err = alc262_parse_auto_config(codec); 2802 if (err < 0) 2803 goto error; 2804 2805 if (!spec->gen.no_analog && spec->gen.beep_nid) { 2806 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 2807 if (err < 0) 2808 goto error; 2809 } 2810 2811 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 2812 2813 return 0; 2814 2815 error: 2816 alc_free(codec); 2817 return err; 2818 } 2819 2820 /* 2821 * ALC268 2822 */ 2823 /* bind Beep switches of both NID 0x0f and 0x10 */ 2824 static int alc268_beep_switch_put(struct snd_kcontrol *kcontrol, 2825 struct snd_ctl_elem_value *ucontrol) 2826 { 2827 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2828 unsigned long pval; 2829 int err; 2830 2831 mutex_lock(&codec->control_mutex); 2832 pval = kcontrol->private_value; 2833 kcontrol->private_value = (pval & ~0xff) | 0x0f; 2834 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); 2835 if (err >= 0) { 2836 kcontrol->private_value = (pval & ~0xff) | 0x10; 2837 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); 2838 } 2839 kcontrol->private_value = pval; 2840 mutex_unlock(&codec->control_mutex); 2841 return err; 2842 } 2843 2844 static const struct snd_kcontrol_new alc268_beep_mixer[] = { 2845 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT), 2846 { 2847 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2848 .name = "Beep Playback Switch", 2849 .subdevice = HDA_SUBDEV_AMP_FLAG, 2850 .info = snd_hda_mixer_amp_switch_info, 2851 .get = snd_hda_mixer_amp_switch_get, 2852 .put = alc268_beep_switch_put, 2853 .private_value = HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT) 2854 }, 2855 }; 2856 2857 /* set PCBEEP vol = 0, mute connections */ 2858 static const struct hda_verb alc268_beep_init_verbs[] = { 2859 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2860 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2861 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2862 { } 2863 }; 2864 2865 enum { 2866 ALC268_FIXUP_INV_DMIC, 2867 ALC268_FIXUP_HP_EAPD, 2868 ALC268_FIXUP_SPDIF, 2869 }; 2870 2871 static const struct hda_fixup alc268_fixups[] = { 2872 [ALC268_FIXUP_INV_DMIC] = { 2873 .type = HDA_FIXUP_FUNC, 2874 .v.func = alc_fixup_inv_dmic, 2875 }, 2876 [ALC268_FIXUP_HP_EAPD] = { 2877 .type = HDA_FIXUP_VERBS, 2878 .v.verbs = (const struct hda_verb[]) { 2879 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0}, 2880 {} 2881 } 2882 }, 2883 [ALC268_FIXUP_SPDIF] = { 2884 .type = HDA_FIXUP_PINS, 2885 .v.pins = (const struct hda_pintbl[]) { 2886 { 0x1e, 0x014b1180 }, /* enable SPDIF out */ 2887 {} 2888 } 2889 }, 2890 }; 2891 2892 static const struct hda_model_fixup alc268_fixup_models[] = { 2893 {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"}, 2894 {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"}, 2895 {.id = ALC268_FIXUP_SPDIF, .name = "spdif"}, 2896 {} 2897 }; 2898 2899 static const struct snd_pci_quirk alc268_fixup_tbl[] = { 2900 SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF), 2901 SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC), 2902 /* below is codec SSID since multiple Toshiba laptops have the 2903 * same PCI SSID 1179:ff00 2904 */ 2905 SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD), 2906 {} 2907 }; 2908 2909 /* 2910 * BIOS auto configuration 2911 */ 2912 static int alc268_parse_auto_config(struct hda_codec *codec) 2913 { 2914 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 2915 return alc_parse_auto_config(codec, NULL, alc268_ssids); 2916 } 2917 2918 /* 2919 */ 2920 static int patch_alc268(struct hda_codec *codec) 2921 { 2922 struct alc_spec *spec; 2923 int i, err; 2924 2925 /* ALC268 has no aa-loopback mixer */ 2926 err = alc_alloc_spec(codec, 0); 2927 if (err < 0) 2928 return err; 2929 2930 spec = codec->spec; 2931 if (has_cdefine_beep(codec)) 2932 spec->gen.beep_nid = 0x01; 2933 2934 spec->shutup = alc_eapd_shutup; 2935 2936 alc_pre_init(codec); 2937 2938 snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups); 2939 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 2940 2941 /* automatic parse from the BIOS config */ 2942 err = alc268_parse_auto_config(codec); 2943 if (err < 0) 2944 goto error; 2945 2946 if (err > 0 && !spec->gen.no_analog && 2947 spec->gen.autocfg.speaker_pins[0] != 0x1d) { 2948 for (i = 0; i < ARRAY_SIZE(alc268_beep_mixer); i++) { 2949 if (!snd_hda_gen_add_kctl(&spec->gen, NULL, 2950 &alc268_beep_mixer[i])) { 2951 err = -ENOMEM; 2952 goto error; 2953 } 2954 } 2955 snd_hda_add_verbs(codec, alc268_beep_init_verbs); 2956 if (!query_amp_caps(codec, 0x1d, HDA_INPUT)) 2957 /* override the amp caps for beep generator */ 2958 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT, 2959 (0x0c << AC_AMPCAP_OFFSET_SHIFT) | 2960 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) | 2961 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) | 2962 (0 << AC_AMPCAP_MUTE_SHIFT)); 2963 } 2964 2965 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 2966 2967 return 0; 2968 2969 error: 2970 alc_free(codec); 2971 return err; 2972 } 2973 2974 /* 2975 * ALC269 2976 */ 2977 2978 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = { 2979 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */ 2980 }; 2981 2982 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = { 2983 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */ 2984 }; 2985 2986 /* different alc269-variants */ 2987 enum { 2988 ALC269_TYPE_ALC269VA, 2989 ALC269_TYPE_ALC269VB, 2990 ALC269_TYPE_ALC269VC, 2991 ALC269_TYPE_ALC269VD, 2992 ALC269_TYPE_ALC280, 2993 ALC269_TYPE_ALC282, 2994 ALC269_TYPE_ALC283, 2995 ALC269_TYPE_ALC284, 2996 ALC269_TYPE_ALC293, 2997 ALC269_TYPE_ALC286, 2998 ALC269_TYPE_ALC298, 2999 ALC269_TYPE_ALC255, 3000 ALC269_TYPE_ALC256, 3001 ALC269_TYPE_ALC257, 3002 ALC269_TYPE_ALC215, 3003 ALC269_TYPE_ALC225, 3004 ALC269_TYPE_ALC294, 3005 ALC269_TYPE_ALC300, 3006 ALC269_TYPE_ALC623, 3007 ALC269_TYPE_ALC700, 3008 }; 3009 3010 /* 3011 * BIOS auto configuration 3012 */ 3013 static int alc269_parse_auto_config(struct hda_codec *codec) 3014 { 3015 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 }; 3016 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 }; 3017 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 3018 struct alc_spec *spec = codec->spec; 3019 const hda_nid_t *ssids; 3020 3021 switch (spec->codec_variant) { 3022 case ALC269_TYPE_ALC269VA: 3023 case ALC269_TYPE_ALC269VC: 3024 case ALC269_TYPE_ALC280: 3025 case ALC269_TYPE_ALC284: 3026 case ALC269_TYPE_ALC293: 3027 ssids = alc269va_ssids; 3028 break; 3029 case ALC269_TYPE_ALC269VB: 3030 case ALC269_TYPE_ALC269VD: 3031 case ALC269_TYPE_ALC282: 3032 case ALC269_TYPE_ALC283: 3033 case ALC269_TYPE_ALC286: 3034 case ALC269_TYPE_ALC298: 3035 case ALC269_TYPE_ALC255: 3036 case ALC269_TYPE_ALC256: 3037 case ALC269_TYPE_ALC257: 3038 case ALC269_TYPE_ALC215: 3039 case ALC269_TYPE_ALC225: 3040 case ALC269_TYPE_ALC294: 3041 case ALC269_TYPE_ALC300: 3042 case ALC269_TYPE_ALC623: 3043 case ALC269_TYPE_ALC700: 3044 ssids = alc269_ssids; 3045 break; 3046 default: 3047 ssids = alc269_ssids; 3048 break; 3049 } 3050 3051 return alc_parse_auto_config(codec, alc269_ignore, ssids); 3052 } 3053 3054 static const struct hda_jack_keymap alc_headset_btn_keymap[] = { 3055 { SND_JACK_BTN_0, KEY_PLAYPAUSE }, 3056 { SND_JACK_BTN_1, KEY_VOICECOMMAND }, 3057 { SND_JACK_BTN_2, KEY_VOLUMEUP }, 3058 { SND_JACK_BTN_3, KEY_VOLUMEDOWN }, 3059 {} 3060 }; 3061 3062 static void alc_headset_btn_callback(struct hda_codec *codec, 3063 struct hda_jack_callback *jack) 3064 { 3065 int report = 0; 3066 3067 if (jack->unsol_res & (7 << 13)) 3068 report |= SND_JACK_BTN_0; 3069 3070 if (jack->unsol_res & (1 << 16 | 3 << 8)) 3071 report |= SND_JACK_BTN_1; 3072 3073 /* Volume up key */ 3074 if (jack->unsol_res & (7 << 23)) 3075 report |= SND_JACK_BTN_2; 3076 3077 /* Volume down key */ 3078 if (jack->unsol_res & (7 << 10)) 3079 report |= SND_JACK_BTN_3; 3080 3081 jack->jack->button_state = report; 3082 } 3083 3084 static void alc_disable_headset_jack_key(struct hda_codec *codec) 3085 { 3086 struct alc_spec *spec = codec->spec; 3087 3088 if (!spec->has_hs_key) 3089 return; 3090 3091 switch (codec->core.vendor_id) { 3092 case 0x10ec0215: 3093 case 0x10ec0225: 3094 case 0x10ec0285: 3095 case 0x10ec0295: 3096 case 0x10ec0289: 3097 case 0x10ec0299: 3098 alc_write_coef_idx(codec, 0x48, 0x0); 3099 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0); 3100 alc_update_coef_idx(codec, 0x44, 0x0045 << 8, 0x0); 3101 break; 3102 case 0x10ec0236: 3103 case 0x10ec0256: 3104 alc_write_coef_idx(codec, 0x48, 0x0); 3105 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0); 3106 break; 3107 } 3108 } 3109 3110 static void alc_enable_headset_jack_key(struct hda_codec *codec) 3111 { 3112 struct alc_spec *spec = codec->spec; 3113 3114 if (!spec->has_hs_key) 3115 return; 3116 3117 switch (codec->core.vendor_id) { 3118 case 0x10ec0215: 3119 case 0x10ec0225: 3120 case 0x10ec0285: 3121 case 0x10ec0295: 3122 case 0x10ec0289: 3123 case 0x10ec0299: 3124 alc_write_coef_idx(codec, 0x48, 0xd011); 3125 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045); 3126 alc_update_coef_idx(codec, 0x44, 0x007f << 8, 0x0045 << 8); 3127 break; 3128 case 0x10ec0236: 3129 case 0x10ec0256: 3130 alc_write_coef_idx(codec, 0x48, 0xd011); 3131 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045); 3132 break; 3133 } 3134 } 3135 3136 static void alc_fixup_headset_jack(struct hda_codec *codec, 3137 const struct hda_fixup *fix, int action) 3138 { 3139 struct alc_spec *spec = codec->spec; 3140 3141 switch (action) { 3142 case HDA_FIXUP_ACT_PRE_PROBE: 3143 spec->has_hs_key = 1; 3144 snd_hda_jack_detect_enable_callback(codec, 0x55, 3145 alc_headset_btn_callback); 3146 snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack", false, 3147 SND_JACK_HEADSET, alc_headset_btn_keymap); 3148 break; 3149 case HDA_FIXUP_ACT_INIT: 3150 alc_enable_headset_jack_key(codec); 3151 break; 3152 } 3153 } 3154 3155 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up) 3156 { 3157 alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0); 3158 } 3159 3160 static void alc269_shutup(struct hda_codec *codec) 3161 { 3162 struct alc_spec *spec = codec->spec; 3163 3164 if (spec->codec_variant == ALC269_TYPE_ALC269VB) 3165 alc269vb_toggle_power_output(codec, 0); 3166 if (spec->codec_variant == ALC269_TYPE_ALC269VB && 3167 (alc_get_coef0(codec) & 0x00ff) == 0x018) { 3168 msleep(150); 3169 } 3170 alc_shutup_pins(codec); 3171 } 3172 3173 static const struct coef_fw alc282_coefs[] = { 3174 WRITE_COEF(0x03, 0x0002), /* Power Down Control */ 3175 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */ 3176 WRITE_COEF(0x07, 0x0200), /* DMIC control */ 3177 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */ 3178 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */ 3179 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */ 3180 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */ 3181 WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */ 3182 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */ 3183 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */ 3184 WRITE_COEF(0x6f, 0x0), /* Class D test 4 */ 3185 UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */ 3186 WRITE_COEF(0x34, 0xa0c0), /* ANC */ 3187 UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */ 3188 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */ 3189 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */ 3190 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */ 3191 WRITE_COEF(0x63, 0x2902), /* PLL */ 3192 WRITE_COEF(0x68, 0xa080), /* capless control 2 */ 3193 WRITE_COEF(0x69, 0x3400), /* capless control 3 */ 3194 WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */ 3195 WRITE_COEF(0x6b, 0x0), /* capless control 5 */ 3196 UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */ 3197 WRITE_COEF(0x6e, 0x110a), /* class D test 3 */ 3198 UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */ 3199 WRITE_COEF(0x71, 0x0014), /* class D test 6 */ 3200 WRITE_COEF(0x72, 0xc2ba), /* classD OCP */ 3201 UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */ 3202 WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */ 3203 {} 3204 }; 3205 3206 static void alc282_restore_default_value(struct hda_codec *codec) 3207 { 3208 alc_process_coef_fw(codec, alc282_coefs); 3209 } 3210 3211 static void alc282_init(struct hda_codec *codec) 3212 { 3213 struct alc_spec *spec = codec->spec; 3214 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3215 bool hp_pin_sense; 3216 int coef78; 3217 3218 alc282_restore_default_value(codec); 3219 3220 if (!hp_pin) 3221 return; 3222 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3223 coef78 = alc_read_coef_idx(codec, 0x78); 3224 3225 /* Index 0x78 Direct Drive HP AMP LPM Control 1 */ 3226 /* Headphone capless set to high power mode */ 3227 alc_write_coef_idx(codec, 0x78, 0x9004); 3228 3229 if (hp_pin_sense) 3230 msleep(2); 3231 3232 snd_hda_codec_write(codec, hp_pin, 0, 3233 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3234 3235 if (hp_pin_sense) 3236 msleep(85); 3237 3238 snd_hda_codec_write(codec, hp_pin, 0, 3239 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3240 3241 if (hp_pin_sense) 3242 msleep(100); 3243 3244 /* Headphone capless set to normal mode */ 3245 alc_write_coef_idx(codec, 0x78, coef78); 3246 } 3247 3248 static void alc282_shutup(struct hda_codec *codec) 3249 { 3250 struct alc_spec *spec = codec->spec; 3251 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3252 bool hp_pin_sense; 3253 int coef78; 3254 3255 if (!hp_pin) { 3256 alc269_shutup(codec); 3257 return; 3258 } 3259 3260 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3261 coef78 = alc_read_coef_idx(codec, 0x78); 3262 alc_write_coef_idx(codec, 0x78, 0x9004); 3263 3264 if (hp_pin_sense) 3265 msleep(2); 3266 3267 snd_hda_codec_write(codec, hp_pin, 0, 3268 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3269 3270 if (hp_pin_sense) 3271 msleep(85); 3272 3273 if (!spec->no_shutup_pins) 3274 snd_hda_codec_write(codec, hp_pin, 0, 3275 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3276 3277 if (hp_pin_sense) 3278 msleep(100); 3279 3280 alc_auto_setup_eapd(codec, false); 3281 alc_shutup_pins(codec); 3282 alc_write_coef_idx(codec, 0x78, coef78); 3283 } 3284 3285 static const struct coef_fw alc283_coefs[] = { 3286 WRITE_COEF(0x03, 0x0002), /* Power Down Control */ 3287 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */ 3288 WRITE_COEF(0x07, 0x0200), /* DMIC control */ 3289 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */ 3290 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */ 3291 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */ 3292 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */ 3293 WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */ 3294 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */ 3295 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */ 3296 WRITE_COEF(0x3a, 0x0), /* Class D test 4 */ 3297 UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */ 3298 WRITE_COEF(0x22, 0xa0c0), /* ANC */ 3299 UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */ 3300 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */ 3301 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */ 3302 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */ 3303 WRITE_COEF(0x2e, 0x2902), /* PLL */ 3304 WRITE_COEF(0x33, 0xa080), /* capless control 2 */ 3305 WRITE_COEF(0x34, 0x3400), /* capless control 3 */ 3306 WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */ 3307 WRITE_COEF(0x36, 0x0), /* capless control 5 */ 3308 UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */ 3309 WRITE_COEF(0x39, 0x110a), /* class D test 3 */ 3310 UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */ 3311 WRITE_COEF(0x3c, 0x0014), /* class D test 6 */ 3312 WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */ 3313 UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */ 3314 WRITE_COEF(0x49, 0x0), /* test mode */ 3315 UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */ 3316 UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */ 3317 WRITE_COEF(0x37, 0xfc06), /* Class D amp control */ 3318 UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */ 3319 {} 3320 }; 3321 3322 static void alc283_restore_default_value(struct hda_codec *codec) 3323 { 3324 alc_process_coef_fw(codec, alc283_coefs); 3325 } 3326 3327 static void alc283_init(struct hda_codec *codec) 3328 { 3329 struct alc_spec *spec = codec->spec; 3330 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3331 bool hp_pin_sense; 3332 3333 alc283_restore_default_value(codec); 3334 3335 if (!hp_pin) 3336 return; 3337 3338 msleep(30); 3339 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3340 3341 /* Index 0x43 Direct Drive HP AMP LPM Control 1 */ 3342 /* Headphone capless set to high power mode */ 3343 alc_write_coef_idx(codec, 0x43, 0x9004); 3344 3345 snd_hda_codec_write(codec, hp_pin, 0, 3346 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3347 3348 if (hp_pin_sense) 3349 msleep(85); 3350 3351 snd_hda_codec_write(codec, hp_pin, 0, 3352 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3353 3354 if (hp_pin_sense) 3355 msleep(85); 3356 /* Index 0x46 Combo jack auto switch control 2 */ 3357 /* 3k pull low control for Headset jack. */ 3358 alc_update_coef_idx(codec, 0x46, 3 << 12, 0); 3359 /* Headphone capless set to normal mode */ 3360 alc_write_coef_idx(codec, 0x43, 0x9614); 3361 } 3362 3363 static void alc283_shutup(struct hda_codec *codec) 3364 { 3365 struct alc_spec *spec = codec->spec; 3366 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3367 bool hp_pin_sense; 3368 3369 if (!hp_pin) { 3370 alc269_shutup(codec); 3371 return; 3372 } 3373 3374 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3375 3376 alc_write_coef_idx(codec, 0x43, 0x9004); 3377 3378 /*depop hp during suspend*/ 3379 alc_write_coef_idx(codec, 0x06, 0x2100); 3380 3381 snd_hda_codec_write(codec, hp_pin, 0, 3382 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3383 3384 if (hp_pin_sense) 3385 msleep(100); 3386 3387 if (!spec->no_shutup_pins) 3388 snd_hda_codec_write(codec, hp_pin, 0, 3389 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3390 3391 alc_update_coef_idx(codec, 0x46, 0, 3 << 12); 3392 3393 if (hp_pin_sense) 3394 msleep(100); 3395 alc_auto_setup_eapd(codec, false); 3396 alc_shutup_pins(codec); 3397 alc_write_coef_idx(codec, 0x43, 0x9614); 3398 } 3399 3400 static void alc256_init(struct hda_codec *codec) 3401 { 3402 struct alc_spec *spec = codec->spec; 3403 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3404 bool hp_pin_sense; 3405 3406 if (!hp_pin) 3407 hp_pin = 0x21; 3408 3409 msleep(30); 3410 3411 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3412 3413 if (hp_pin_sense) 3414 msleep(2); 3415 3416 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */ 3417 if (spec->ultra_low_power) { 3418 alc_update_coef_idx(codec, 0x03, 1<<1, 1<<1); 3419 alc_update_coef_idx(codec, 0x08, 3<<2, 3<<2); 3420 alc_update_coef_idx(codec, 0x08, 7<<4, 0); 3421 alc_update_coef_idx(codec, 0x3b, 1<<15, 0); 3422 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6); 3423 msleep(30); 3424 } 3425 3426 snd_hda_codec_write(codec, hp_pin, 0, 3427 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3428 3429 if (hp_pin_sense || spec->ultra_low_power) 3430 msleep(85); 3431 3432 snd_hda_codec_write(codec, hp_pin, 0, 3433 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3434 3435 if (hp_pin_sense || spec->ultra_low_power) 3436 msleep(100); 3437 3438 alc_update_coef_idx(codec, 0x46, 3 << 12, 0); 3439 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */ 3440 alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15); /* Clear bit */ 3441 alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15); 3442 /* 3443 * Expose headphone mic (or possibly Line In on some machines) instead 3444 * of PC Beep on 1Ah, and disable 1Ah loopback for all outputs. See 3445 * Documentation/sound/hd-audio/realtek-pc-beep.rst for details of 3446 * this register. 3447 */ 3448 alc_write_coef_idx(codec, 0x36, 0x5757); 3449 } 3450 3451 static void alc256_shutup(struct hda_codec *codec) 3452 { 3453 struct alc_spec *spec = codec->spec; 3454 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3455 bool hp_pin_sense; 3456 3457 if (!hp_pin) 3458 hp_pin = 0x21; 3459 3460 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3461 3462 if (hp_pin_sense) 3463 msleep(2); 3464 3465 snd_hda_codec_write(codec, hp_pin, 0, 3466 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3467 3468 if (hp_pin_sense || spec->ultra_low_power) 3469 msleep(85); 3470 3471 /* 3k pull low control for Headset jack. */ 3472 /* NOTE: call this before clearing the pin, otherwise codec stalls */ 3473 /* If disable 3k pulldown control for alc257, the Mic detection will not work correctly 3474 * when booting with headset plugged. So skip setting it for the codec alc257 3475 */ 3476 if (codec->core.vendor_id != 0x10ec0257) 3477 alc_update_coef_idx(codec, 0x46, 0, 3 << 12); 3478 3479 if (!spec->no_shutup_pins) 3480 snd_hda_codec_write(codec, hp_pin, 0, 3481 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3482 3483 if (hp_pin_sense || spec->ultra_low_power) 3484 msleep(100); 3485 3486 alc_auto_setup_eapd(codec, false); 3487 alc_shutup_pins(codec); 3488 if (spec->ultra_low_power) { 3489 msleep(50); 3490 alc_update_coef_idx(codec, 0x03, 1<<1, 0); 3491 alc_update_coef_idx(codec, 0x08, 7<<4, 7<<4); 3492 alc_update_coef_idx(codec, 0x08, 3<<2, 0); 3493 alc_update_coef_idx(codec, 0x3b, 1<<15, 1<<15); 3494 alc_update_coef_idx(codec, 0x0e, 7<<6, 0); 3495 msleep(30); 3496 } 3497 } 3498 3499 static void alc225_init(struct hda_codec *codec) 3500 { 3501 struct alc_spec *spec = codec->spec; 3502 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3503 bool hp1_pin_sense, hp2_pin_sense; 3504 3505 if (!hp_pin) 3506 hp_pin = 0x21; 3507 msleep(30); 3508 3509 hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3510 hp2_pin_sense = snd_hda_jack_detect(codec, 0x16); 3511 3512 if (hp1_pin_sense || hp2_pin_sense) 3513 msleep(2); 3514 3515 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */ 3516 if (spec->ultra_low_power) { 3517 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 3<<2); 3518 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6); 3519 alc_update_coef_idx(codec, 0x33, 1<<11, 0); 3520 msleep(30); 3521 } 3522 3523 if (hp1_pin_sense || spec->ultra_low_power) 3524 snd_hda_codec_write(codec, hp_pin, 0, 3525 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3526 if (hp2_pin_sense) 3527 snd_hda_codec_write(codec, 0x16, 0, 3528 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3529 3530 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power) 3531 msleep(85); 3532 3533 if (hp1_pin_sense || spec->ultra_low_power) 3534 snd_hda_codec_write(codec, hp_pin, 0, 3535 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3536 if (hp2_pin_sense) 3537 snd_hda_codec_write(codec, 0x16, 0, 3538 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3539 3540 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power) 3541 msleep(100); 3542 3543 alc_update_coef_idx(codec, 0x4a, 3 << 10, 0); 3544 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */ 3545 } 3546 3547 static void alc225_shutup(struct hda_codec *codec) 3548 { 3549 struct alc_spec *spec = codec->spec; 3550 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3551 bool hp1_pin_sense, hp2_pin_sense; 3552 3553 if (!hp_pin) 3554 hp_pin = 0x21; 3555 3556 alc_disable_headset_jack_key(codec); 3557 /* 3k pull low control for Headset jack. */ 3558 alc_update_coef_idx(codec, 0x4a, 0, 3 << 10); 3559 3560 hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3561 hp2_pin_sense = snd_hda_jack_detect(codec, 0x16); 3562 3563 if (hp1_pin_sense || hp2_pin_sense) 3564 msleep(2); 3565 3566 if (hp1_pin_sense || spec->ultra_low_power) 3567 snd_hda_codec_write(codec, hp_pin, 0, 3568 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3569 if (hp2_pin_sense) 3570 snd_hda_codec_write(codec, 0x16, 0, 3571 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3572 3573 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power) 3574 msleep(85); 3575 3576 if (hp1_pin_sense || spec->ultra_low_power) 3577 snd_hda_codec_write(codec, hp_pin, 0, 3578 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3579 if (hp2_pin_sense) 3580 snd_hda_codec_write(codec, 0x16, 0, 3581 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3582 3583 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power) 3584 msleep(100); 3585 3586 alc_auto_setup_eapd(codec, false); 3587 alc_shutup_pins(codec); 3588 if (spec->ultra_low_power) { 3589 msleep(50); 3590 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 0x0c << 2); 3591 alc_update_coef_idx(codec, 0x0e, 7<<6, 0); 3592 alc_update_coef_idx(codec, 0x33, 1<<11, 1<<11); 3593 alc_update_coef_idx(codec, 0x4a, 3<<4, 2<<4); 3594 msleep(30); 3595 } 3596 3597 alc_update_coef_idx(codec, 0x4a, 3 << 10, 0); 3598 alc_enable_headset_jack_key(codec); 3599 } 3600 3601 static void alc_default_init(struct hda_codec *codec) 3602 { 3603 struct alc_spec *spec = codec->spec; 3604 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3605 bool hp_pin_sense; 3606 3607 if (!hp_pin) 3608 return; 3609 3610 msleep(30); 3611 3612 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3613 3614 if (hp_pin_sense) 3615 msleep(2); 3616 3617 snd_hda_codec_write(codec, hp_pin, 0, 3618 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3619 3620 if (hp_pin_sense) 3621 msleep(85); 3622 3623 snd_hda_codec_write(codec, hp_pin, 0, 3624 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3625 3626 if (hp_pin_sense) 3627 msleep(100); 3628 } 3629 3630 static void alc_default_shutup(struct hda_codec *codec) 3631 { 3632 struct alc_spec *spec = codec->spec; 3633 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3634 bool hp_pin_sense; 3635 3636 if (!hp_pin) { 3637 alc269_shutup(codec); 3638 return; 3639 } 3640 3641 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3642 3643 if (hp_pin_sense) 3644 msleep(2); 3645 3646 snd_hda_codec_write(codec, hp_pin, 0, 3647 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3648 3649 if (hp_pin_sense) 3650 msleep(85); 3651 3652 if (!spec->no_shutup_pins) 3653 snd_hda_codec_write(codec, hp_pin, 0, 3654 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3655 3656 if (hp_pin_sense) 3657 msleep(100); 3658 3659 alc_auto_setup_eapd(codec, false); 3660 alc_shutup_pins(codec); 3661 } 3662 3663 static void alc294_hp_init(struct hda_codec *codec) 3664 { 3665 struct alc_spec *spec = codec->spec; 3666 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3667 int i, val; 3668 3669 if (!hp_pin) 3670 return; 3671 3672 snd_hda_codec_write(codec, hp_pin, 0, 3673 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3674 3675 msleep(100); 3676 3677 if (!spec->no_shutup_pins) 3678 snd_hda_codec_write(codec, hp_pin, 0, 3679 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3680 3681 alc_update_coef_idx(codec, 0x6f, 0x000f, 0);/* Set HP depop to manual mode */ 3682 alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000); /* HP depop procedure start */ 3683 3684 /* Wait for depop procedure finish */ 3685 val = alc_read_coefex_idx(codec, 0x58, 0x01); 3686 for (i = 0; i < 20 && val & 0x0080; i++) { 3687 msleep(50); 3688 val = alc_read_coefex_idx(codec, 0x58, 0x01); 3689 } 3690 /* Set HP depop to auto mode */ 3691 alc_update_coef_idx(codec, 0x6f, 0x000f, 0x000b); 3692 msleep(50); 3693 } 3694 3695 static void alc294_init(struct hda_codec *codec) 3696 { 3697 struct alc_spec *spec = codec->spec; 3698 3699 /* required only at boot or S4 resume time */ 3700 if (!spec->done_hp_init || 3701 codec->core.dev.power.power_state.event == PM_EVENT_RESTORE) { 3702 alc294_hp_init(codec); 3703 spec->done_hp_init = true; 3704 } 3705 alc_default_init(codec); 3706 } 3707 3708 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg, 3709 unsigned int val) 3710 { 3711 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1); 3712 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */ 3713 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */ 3714 } 3715 3716 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg) 3717 { 3718 unsigned int val; 3719 3720 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1); 3721 val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0) 3722 & 0xffff; 3723 val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0) 3724 << 16; 3725 return val; 3726 } 3727 3728 static void alc5505_dsp_halt(struct hda_codec *codec) 3729 { 3730 unsigned int val; 3731 3732 alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */ 3733 alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */ 3734 alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */ 3735 alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */ 3736 alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */ 3737 alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */ 3738 alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */ 3739 val = alc5505_coef_get(codec, 0x6220); 3740 alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */ 3741 } 3742 3743 static void alc5505_dsp_back_from_halt(struct hda_codec *codec) 3744 { 3745 alc5505_coef_set(codec, 0x61b8, 0x04133302); 3746 alc5505_coef_set(codec, 0x61b0, 0x00005b16); 3747 alc5505_coef_set(codec, 0x61b4, 0x040a2b02); 3748 alc5505_coef_set(codec, 0x6230, 0xf80d4011); 3749 alc5505_coef_set(codec, 0x6220, 0x2002010f); 3750 alc5505_coef_set(codec, 0x880c, 0x00000004); 3751 } 3752 3753 static void alc5505_dsp_init(struct hda_codec *codec) 3754 { 3755 unsigned int val; 3756 3757 alc5505_dsp_halt(codec); 3758 alc5505_dsp_back_from_halt(codec); 3759 alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */ 3760 alc5505_coef_set(codec, 0x61b0, 0x5b16); 3761 alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */ 3762 alc5505_coef_set(codec, 0x61b4, 0x04132b02); 3763 alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/ 3764 alc5505_coef_set(codec, 0x61b8, 0x041f3302); 3765 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */ 3766 alc5505_coef_set(codec, 0x61b8, 0x041b3302); 3767 alc5505_coef_set(codec, 0x61b8, 0x04173302); 3768 alc5505_coef_set(codec, 0x61b8, 0x04163302); 3769 alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */ 3770 alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */ 3771 alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */ 3772 3773 val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */ 3774 if (val <= 3) 3775 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */ 3776 else 3777 alc5505_coef_set(codec, 0x6220, 0x6002018f); 3778 3779 alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/ 3780 alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */ 3781 alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */ 3782 alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */ 3783 alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */ 3784 alc5505_coef_set(codec, 0x880c, 0x00000003); 3785 alc5505_coef_set(codec, 0x880c, 0x00000010); 3786 3787 #ifdef HALT_REALTEK_ALC5505 3788 alc5505_dsp_halt(codec); 3789 #endif 3790 } 3791 3792 #ifdef HALT_REALTEK_ALC5505 3793 #define alc5505_dsp_suspend(codec) do { } while (0) /* NOP */ 3794 #define alc5505_dsp_resume(codec) do { } while (0) /* NOP */ 3795 #else 3796 #define alc5505_dsp_suspend(codec) alc5505_dsp_halt(codec) 3797 #define alc5505_dsp_resume(codec) alc5505_dsp_back_from_halt(codec) 3798 #endif 3799 3800 #ifdef CONFIG_PM 3801 static int alc269_suspend(struct hda_codec *codec) 3802 { 3803 struct alc_spec *spec = codec->spec; 3804 3805 if (spec->has_alc5505_dsp) 3806 alc5505_dsp_suspend(codec); 3807 return alc_suspend(codec); 3808 } 3809 3810 static int alc269_resume(struct hda_codec *codec) 3811 { 3812 struct alc_spec *spec = codec->spec; 3813 3814 if (spec->codec_variant == ALC269_TYPE_ALC269VB) 3815 alc269vb_toggle_power_output(codec, 0); 3816 if (spec->codec_variant == ALC269_TYPE_ALC269VB && 3817 (alc_get_coef0(codec) & 0x00ff) == 0x018) { 3818 msleep(150); 3819 } 3820 3821 codec->patch_ops.init(codec); 3822 3823 if (spec->codec_variant == ALC269_TYPE_ALC269VB) 3824 alc269vb_toggle_power_output(codec, 1); 3825 if (spec->codec_variant == ALC269_TYPE_ALC269VB && 3826 (alc_get_coef0(codec) & 0x00ff) == 0x017) { 3827 msleep(200); 3828 } 3829 3830 snd_hda_regmap_sync(codec); 3831 hda_call_check_power_status(codec, 0x01); 3832 3833 /* on some machine, the BIOS will clear the codec gpio data when enter 3834 * suspend, and won't restore the data after resume, so we restore it 3835 * in the driver. 3836 */ 3837 if (spec->gpio_data) 3838 alc_write_gpio_data(codec); 3839 3840 if (spec->has_alc5505_dsp) 3841 alc5505_dsp_resume(codec); 3842 3843 return 0; 3844 } 3845 #endif /* CONFIG_PM */ 3846 3847 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec, 3848 const struct hda_fixup *fix, int action) 3849 { 3850 struct alc_spec *spec = codec->spec; 3851 3852 if (action == HDA_FIXUP_ACT_PRE_PROBE) 3853 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 3854 } 3855 3856 static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec, 3857 const struct hda_fixup *fix, 3858 int action) 3859 { 3860 unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21); 3861 unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19); 3862 3863 if (cfg_headphone && cfg_headset_mic == 0x411111f0) 3864 snd_hda_codec_set_pincfg(codec, 0x19, 3865 (cfg_headphone & ~AC_DEFCFG_DEVICE) | 3866 (AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT)); 3867 } 3868 3869 static void alc269_fixup_hweq(struct hda_codec *codec, 3870 const struct hda_fixup *fix, int action) 3871 { 3872 if (action == HDA_FIXUP_ACT_INIT) 3873 alc_update_coef_idx(codec, 0x1e, 0, 0x80); 3874 } 3875 3876 static void alc269_fixup_headset_mic(struct hda_codec *codec, 3877 const struct hda_fixup *fix, int action) 3878 { 3879 struct alc_spec *spec = codec->spec; 3880 3881 if (action == HDA_FIXUP_ACT_PRE_PROBE) 3882 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 3883 } 3884 3885 static void alc271_fixup_dmic(struct hda_codec *codec, 3886 const struct hda_fixup *fix, int action) 3887 { 3888 static const struct hda_verb verbs[] = { 3889 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d}, 3890 {0x20, AC_VERB_SET_PROC_COEF, 0x4000}, 3891 {} 3892 }; 3893 unsigned int cfg; 3894 3895 if (strcmp(codec->core.chip_name, "ALC271X") && 3896 strcmp(codec->core.chip_name, "ALC269VB")) 3897 return; 3898 cfg = snd_hda_codec_get_pincfg(codec, 0x12); 3899 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED) 3900 snd_hda_sequence_write(codec, verbs); 3901 } 3902 3903 static void alc269_fixup_pcm_44k(struct hda_codec *codec, 3904 const struct hda_fixup *fix, int action) 3905 { 3906 struct alc_spec *spec = codec->spec; 3907 3908 if (action != HDA_FIXUP_ACT_PROBE) 3909 return; 3910 3911 /* Due to a hardware problem on Lenovo Ideadpad, we need to 3912 * fix the sample rate of analog I/O to 44.1kHz 3913 */ 3914 spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback; 3915 spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture; 3916 } 3917 3918 static void alc269_fixup_stereo_dmic(struct hda_codec *codec, 3919 const struct hda_fixup *fix, int action) 3920 { 3921 /* The digital-mic unit sends PDM (differential signal) instead of 3922 * the standard PCM, thus you can't record a valid mono stream as is. 3923 * Below is a workaround specific to ALC269 to control the dmic 3924 * signal source as mono. 3925 */ 3926 if (action == HDA_FIXUP_ACT_INIT) 3927 alc_update_coef_idx(codec, 0x07, 0, 0x80); 3928 } 3929 3930 static void alc269_quanta_automute(struct hda_codec *codec) 3931 { 3932 snd_hda_gen_update_outputs(codec); 3933 3934 alc_write_coef_idx(codec, 0x0c, 0x680); 3935 alc_write_coef_idx(codec, 0x0c, 0x480); 3936 } 3937 3938 static void alc269_fixup_quanta_mute(struct hda_codec *codec, 3939 const struct hda_fixup *fix, int action) 3940 { 3941 struct alc_spec *spec = codec->spec; 3942 if (action != HDA_FIXUP_ACT_PROBE) 3943 return; 3944 spec->gen.automute_hook = alc269_quanta_automute; 3945 } 3946 3947 static void alc269_x101_hp_automute_hook(struct hda_codec *codec, 3948 struct hda_jack_callback *jack) 3949 { 3950 struct alc_spec *spec = codec->spec; 3951 int vref; 3952 msleep(200); 3953 snd_hda_gen_hp_automute(codec, jack); 3954 3955 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0; 3956 msleep(100); 3957 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 3958 vref); 3959 msleep(500); 3960 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 3961 vref); 3962 } 3963 3964 /* 3965 * Magic sequence to make Huawei Matebook X right speaker working (bko#197801) 3966 */ 3967 struct hda_alc298_mbxinit { 3968 unsigned char value_0x23; 3969 unsigned char value_0x25; 3970 }; 3971 3972 static void alc298_huawei_mbx_stereo_seq(struct hda_codec *codec, 3973 const struct hda_alc298_mbxinit *initval, 3974 bool first) 3975 { 3976 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x0); 3977 alc_write_coef_idx(codec, 0x26, 0xb000); 3978 3979 if (first) 3980 snd_hda_codec_write(codec, 0x21, 0, AC_VERB_GET_PIN_SENSE, 0x0); 3981 3982 snd_hda_codec_write(codec, 0x6, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80); 3983 alc_write_coef_idx(codec, 0x26, 0xf000); 3984 alc_write_coef_idx(codec, 0x23, initval->value_0x23); 3985 3986 if (initval->value_0x23 != 0x1e) 3987 alc_write_coef_idx(codec, 0x25, initval->value_0x25); 3988 3989 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26); 3990 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010); 3991 } 3992 3993 static void alc298_fixup_huawei_mbx_stereo(struct hda_codec *codec, 3994 const struct hda_fixup *fix, 3995 int action) 3996 { 3997 /* Initialization magic */ 3998 static const struct hda_alc298_mbxinit dac_init[] = { 3999 {0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00}, 4000 {0x10, 0x00}, {0x1a, 0x40}, {0x1b, 0x82}, {0x1c, 0x00}, 4001 {0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00}, 4002 {0x20, 0xc2}, {0x21, 0xc8}, {0x22, 0x26}, {0x23, 0x24}, 4003 {0x27, 0xff}, {0x28, 0xff}, {0x29, 0xff}, {0x2a, 0x8f}, 4004 {0x2b, 0x02}, {0x2c, 0x48}, {0x2d, 0x34}, {0x2e, 0x00}, 4005 {0x2f, 0x00}, 4006 {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00}, 4007 {0x34, 0x00}, {0x35, 0x01}, {0x36, 0x93}, {0x37, 0x0c}, 4008 {0x38, 0x00}, {0x39, 0x00}, {0x3a, 0xf8}, {0x38, 0x80}, 4009 {} 4010 }; 4011 const struct hda_alc298_mbxinit *seq; 4012 4013 if (action != HDA_FIXUP_ACT_INIT) 4014 return; 4015 4016 /* Start */ 4017 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x00); 4018 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80); 4019 alc_write_coef_idx(codec, 0x26, 0xf000); 4020 alc_write_coef_idx(codec, 0x22, 0x31); 4021 alc_write_coef_idx(codec, 0x23, 0x0b); 4022 alc_write_coef_idx(codec, 0x25, 0x00); 4023 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26); 4024 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010); 4025 4026 for (seq = dac_init; seq->value_0x23; seq++) 4027 alc298_huawei_mbx_stereo_seq(codec, seq, seq == dac_init); 4028 } 4029 4030 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec, 4031 const struct hda_fixup *fix, int action) 4032 { 4033 struct alc_spec *spec = codec->spec; 4034 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4035 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 4036 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook; 4037 } 4038 } 4039 4040 static void alc_update_vref_led(struct hda_codec *codec, hda_nid_t pin, 4041 bool polarity, bool on) 4042 { 4043 unsigned int pinval; 4044 4045 if (!pin) 4046 return; 4047 if (polarity) 4048 on = !on; 4049 pinval = snd_hda_codec_get_pin_target(codec, pin); 4050 pinval &= ~AC_PINCTL_VREFEN; 4051 pinval |= on ? AC_PINCTL_VREF_80 : AC_PINCTL_VREF_HIZ; 4052 /* temporarily power up/down for setting VREF */ 4053 snd_hda_power_up_pm(codec); 4054 snd_hda_set_pin_ctl_cache(codec, pin, pinval); 4055 snd_hda_power_down_pm(codec); 4056 } 4057 4058 /* update mute-LED according to the speaker mute state via mic VREF pin */ 4059 static int vref_mute_led_set(struct led_classdev *led_cdev, 4060 enum led_brightness brightness) 4061 { 4062 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4063 struct alc_spec *spec = codec->spec; 4064 4065 alc_update_vref_led(codec, spec->mute_led_nid, 4066 spec->mute_led_polarity, brightness); 4067 return 0; 4068 } 4069 4070 /* Make sure the led works even in runtime suspend */ 4071 static unsigned int led_power_filter(struct hda_codec *codec, 4072 hda_nid_t nid, 4073 unsigned int power_state) 4074 { 4075 struct alc_spec *spec = codec->spec; 4076 4077 if (power_state != AC_PWRST_D3 || nid == 0 || 4078 (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid)) 4079 return power_state; 4080 4081 /* Set pin ctl again, it might have just been set to 0 */ 4082 snd_hda_set_pin_ctl(codec, nid, 4083 snd_hda_codec_get_pin_target(codec, nid)); 4084 4085 return snd_hda_gen_path_power_filter(codec, nid, power_state); 4086 } 4087 4088 static void alc269_fixup_hp_mute_led(struct hda_codec *codec, 4089 const struct hda_fixup *fix, int action) 4090 { 4091 struct alc_spec *spec = codec->spec; 4092 const struct dmi_device *dev = NULL; 4093 4094 if (action != HDA_FIXUP_ACT_PRE_PROBE) 4095 return; 4096 4097 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) { 4098 int pol, pin; 4099 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2) 4100 continue; 4101 if (pin < 0x0a || pin >= 0x10) 4102 break; 4103 spec->mute_led_polarity = pol; 4104 spec->mute_led_nid = pin - 0x0a + 0x18; 4105 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set); 4106 codec->power_filter = led_power_filter; 4107 codec_dbg(codec, 4108 "Detected mute LED for %x:%d\n", spec->mute_led_nid, 4109 spec->mute_led_polarity); 4110 break; 4111 } 4112 } 4113 4114 static void alc269_fixup_hp_mute_led_micx(struct hda_codec *codec, 4115 const struct hda_fixup *fix, 4116 int action, hda_nid_t pin) 4117 { 4118 struct alc_spec *spec = codec->spec; 4119 4120 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4121 spec->mute_led_polarity = 0; 4122 spec->mute_led_nid = pin; 4123 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set); 4124 codec->power_filter = led_power_filter; 4125 } 4126 } 4127 4128 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec, 4129 const struct hda_fixup *fix, int action) 4130 { 4131 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x18); 4132 } 4133 4134 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec, 4135 const struct hda_fixup *fix, int action) 4136 { 4137 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x19); 4138 } 4139 4140 static void alc269_fixup_hp_mute_led_mic3(struct hda_codec *codec, 4141 const struct hda_fixup *fix, int action) 4142 { 4143 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1b); 4144 } 4145 4146 /* update LED status via GPIO */ 4147 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask, 4148 int polarity, bool enabled) 4149 { 4150 if (polarity) 4151 enabled = !enabled; 4152 alc_update_gpio_data(codec, mask, !enabled); /* muted -> LED on */ 4153 } 4154 4155 /* turn on/off mute LED via GPIO per vmaster hook */ 4156 static int gpio_mute_led_set(struct led_classdev *led_cdev, 4157 enum led_brightness brightness) 4158 { 4159 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4160 struct alc_spec *spec = codec->spec; 4161 4162 alc_update_gpio_led(codec, spec->gpio_mute_led_mask, 4163 spec->mute_led_polarity, !brightness); 4164 return 0; 4165 } 4166 4167 /* turn on/off mic-mute LED via GPIO per capture hook */ 4168 static int micmute_led_set(struct led_classdev *led_cdev, 4169 enum led_brightness brightness) 4170 { 4171 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4172 struct alc_spec *spec = codec->spec; 4173 4174 alc_update_gpio_led(codec, spec->gpio_mic_led_mask, 4175 spec->micmute_led_polarity, !brightness); 4176 return 0; 4177 } 4178 4179 /* setup mute and mic-mute GPIO bits, add hooks appropriately */ 4180 static void alc_fixup_hp_gpio_led(struct hda_codec *codec, 4181 int action, 4182 unsigned int mute_mask, 4183 unsigned int micmute_mask) 4184 { 4185 struct alc_spec *spec = codec->spec; 4186 4187 alc_fixup_gpio(codec, action, mute_mask | micmute_mask); 4188 4189 if (action != HDA_FIXUP_ACT_PRE_PROBE) 4190 return; 4191 if (mute_mask) { 4192 spec->gpio_mute_led_mask = mute_mask; 4193 snd_hda_gen_add_mute_led_cdev(codec, gpio_mute_led_set); 4194 } 4195 if (micmute_mask) { 4196 spec->gpio_mic_led_mask = micmute_mask; 4197 snd_hda_gen_add_micmute_led_cdev(codec, micmute_led_set); 4198 } 4199 } 4200 4201 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec, 4202 const struct hda_fixup *fix, int action) 4203 { 4204 alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10); 4205 } 4206 4207 static void alc285_fixup_hp_gpio_led(struct hda_codec *codec, 4208 const struct hda_fixup *fix, int action) 4209 { 4210 alc_fixup_hp_gpio_led(codec, action, 0x04, 0x01); 4211 } 4212 4213 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec, 4214 const struct hda_fixup *fix, int action) 4215 { 4216 alc_fixup_hp_gpio_led(codec, action, 0x02, 0x20); 4217 } 4218 4219 /* turn on/off mic-mute LED per capture hook via VREF change */ 4220 static int vref_micmute_led_set(struct led_classdev *led_cdev, 4221 enum led_brightness brightness) 4222 { 4223 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4224 struct alc_spec *spec = codec->spec; 4225 4226 alc_update_vref_led(codec, spec->cap_mute_led_nid, 4227 spec->micmute_led_polarity, brightness); 4228 return 0; 4229 } 4230 4231 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec, 4232 const struct hda_fixup *fix, int action) 4233 { 4234 struct alc_spec *spec = codec->spec; 4235 4236 alc_fixup_hp_gpio_led(codec, action, 0x08, 0); 4237 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4238 /* Like hp_gpio_mic1_led, but also needs GPIO4 low to 4239 * enable headphone amp 4240 */ 4241 spec->gpio_mask |= 0x10; 4242 spec->gpio_dir |= 0x10; 4243 spec->cap_mute_led_nid = 0x18; 4244 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set); 4245 codec->power_filter = led_power_filter; 4246 } 4247 } 4248 4249 static void alc280_fixup_hp_gpio4(struct hda_codec *codec, 4250 const struct hda_fixup *fix, int action) 4251 { 4252 struct alc_spec *spec = codec->spec; 4253 4254 alc_fixup_hp_gpio_led(codec, action, 0x08, 0); 4255 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4256 spec->cap_mute_led_nid = 0x18; 4257 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set); 4258 codec->power_filter = led_power_filter; 4259 } 4260 } 4261 4262 static void alc_update_coef_led(struct hda_codec *codec, 4263 struct alc_coef_led *led, 4264 bool polarity, bool on) 4265 { 4266 if (polarity) 4267 on = !on; 4268 /* temporarily power up/down for setting COEF bit */ 4269 alc_update_coef_idx(codec, led->idx, led->mask, 4270 on ? led->on : led->off); 4271 } 4272 4273 /* update mute-LED according to the speaker mute state via COEF bit */ 4274 static int coef_mute_led_set(struct led_classdev *led_cdev, 4275 enum led_brightness brightness) 4276 { 4277 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4278 struct alc_spec *spec = codec->spec; 4279 4280 alc_update_coef_led(codec, &spec->mute_led_coef, 4281 spec->mute_led_polarity, brightness); 4282 return 0; 4283 } 4284 4285 static void alc285_fixup_hp_mute_led_coefbit(struct hda_codec *codec, 4286 const struct hda_fixup *fix, 4287 int action) 4288 { 4289 struct alc_spec *spec = codec->spec; 4290 4291 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4292 spec->mute_led_polarity = 0; 4293 spec->mute_led_coef.idx = 0x0b; 4294 spec->mute_led_coef.mask = 1 << 3; 4295 spec->mute_led_coef.on = 1 << 3; 4296 spec->mute_led_coef.off = 0; 4297 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set); 4298 } 4299 } 4300 4301 static void alc236_fixup_hp_mute_led_coefbit(struct hda_codec *codec, 4302 const struct hda_fixup *fix, 4303 int action) 4304 { 4305 struct alc_spec *spec = codec->spec; 4306 4307 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4308 spec->mute_led_polarity = 0; 4309 spec->mute_led_coef.idx = 0x34; 4310 spec->mute_led_coef.mask = 1 << 5; 4311 spec->mute_led_coef.on = 0; 4312 spec->mute_led_coef.off = 1 << 5; 4313 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set); 4314 } 4315 } 4316 4317 /* turn on/off mic-mute LED per capture hook by coef bit */ 4318 static int coef_micmute_led_set(struct led_classdev *led_cdev, 4319 enum led_brightness brightness) 4320 { 4321 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4322 struct alc_spec *spec = codec->spec; 4323 4324 alc_update_coef_led(codec, &spec->mic_led_coef, 4325 spec->micmute_led_polarity, brightness); 4326 return 0; 4327 } 4328 4329 static void alc285_fixup_hp_coef_micmute_led(struct hda_codec *codec, 4330 const struct hda_fixup *fix, int action) 4331 { 4332 struct alc_spec *spec = codec->spec; 4333 4334 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4335 spec->mic_led_coef.idx = 0x19; 4336 spec->mic_led_coef.mask = 1 << 13; 4337 spec->mic_led_coef.on = 1 << 13; 4338 spec->mic_led_coef.off = 0; 4339 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set); 4340 } 4341 } 4342 4343 static void alc236_fixup_hp_coef_micmute_led(struct hda_codec *codec, 4344 const struct hda_fixup *fix, int action) 4345 { 4346 struct alc_spec *spec = codec->spec; 4347 4348 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4349 spec->mic_led_coef.idx = 0x35; 4350 spec->mic_led_coef.mask = 3 << 2; 4351 spec->mic_led_coef.on = 2 << 2; 4352 spec->mic_led_coef.off = 1 << 2; 4353 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set); 4354 } 4355 } 4356 4357 static void alc285_fixup_hp_mute_led(struct hda_codec *codec, 4358 const struct hda_fixup *fix, int action) 4359 { 4360 alc285_fixup_hp_mute_led_coefbit(codec, fix, action); 4361 alc285_fixup_hp_coef_micmute_led(codec, fix, action); 4362 } 4363 4364 static void alc236_fixup_hp_mute_led(struct hda_codec *codec, 4365 const struct hda_fixup *fix, int action) 4366 { 4367 alc236_fixup_hp_mute_led_coefbit(codec, fix, action); 4368 alc236_fixup_hp_coef_micmute_led(codec, fix, action); 4369 } 4370 4371 #if IS_REACHABLE(CONFIG_INPUT) 4372 static void gpio2_mic_hotkey_event(struct hda_codec *codec, 4373 struct hda_jack_callback *event) 4374 { 4375 struct alc_spec *spec = codec->spec; 4376 4377 /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore 4378 send both key on and key off event for every interrupt. */ 4379 input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1); 4380 input_sync(spec->kb_dev); 4381 input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0); 4382 input_sync(spec->kb_dev); 4383 } 4384 4385 static int alc_register_micmute_input_device(struct hda_codec *codec) 4386 { 4387 struct alc_spec *spec = codec->spec; 4388 int i; 4389 4390 spec->kb_dev = input_allocate_device(); 4391 if (!spec->kb_dev) { 4392 codec_err(codec, "Out of memory (input_allocate_device)\n"); 4393 return -ENOMEM; 4394 } 4395 4396 spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE; 4397 4398 spec->kb_dev->name = "Microphone Mute Button"; 4399 spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY); 4400 spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]); 4401 spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map); 4402 spec->kb_dev->keycode = spec->alc_mute_keycode_map; 4403 for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++) 4404 set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit); 4405 4406 if (input_register_device(spec->kb_dev)) { 4407 codec_err(codec, "input_register_device failed\n"); 4408 input_free_device(spec->kb_dev); 4409 spec->kb_dev = NULL; 4410 return -ENOMEM; 4411 } 4412 4413 return 0; 4414 } 4415 4416 /* GPIO1 = set according to SKU external amp 4417 * GPIO2 = mic mute hotkey 4418 * GPIO3 = mute LED 4419 * GPIO4 = mic mute LED 4420 */ 4421 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec, 4422 const struct hda_fixup *fix, int action) 4423 { 4424 struct alc_spec *spec = codec->spec; 4425 4426 alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10); 4427 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4428 spec->init_amp = ALC_INIT_DEFAULT; 4429 if (alc_register_micmute_input_device(codec) != 0) 4430 return; 4431 4432 spec->gpio_mask |= 0x06; 4433 spec->gpio_dir |= 0x02; 4434 spec->gpio_data |= 0x02; 4435 snd_hda_codec_write_cache(codec, codec->core.afg, 0, 4436 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04); 4437 snd_hda_jack_detect_enable_callback(codec, codec->core.afg, 4438 gpio2_mic_hotkey_event); 4439 return; 4440 } 4441 4442 if (!spec->kb_dev) 4443 return; 4444 4445 switch (action) { 4446 case HDA_FIXUP_ACT_FREE: 4447 input_unregister_device(spec->kb_dev); 4448 spec->kb_dev = NULL; 4449 } 4450 } 4451 4452 /* Line2 = mic mute hotkey 4453 * GPIO2 = mic mute LED 4454 */ 4455 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec, 4456 const struct hda_fixup *fix, int action) 4457 { 4458 struct alc_spec *spec = codec->spec; 4459 4460 alc_fixup_hp_gpio_led(codec, action, 0, 0x04); 4461 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4462 spec->init_amp = ALC_INIT_DEFAULT; 4463 if (alc_register_micmute_input_device(codec) != 0) 4464 return; 4465 4466 snd_hda_jack_detect_enable_callback(codec, 0x1b, 4467 gpio2_mic_hotkey_event); 4468 return; 4469 } 4470 4471 if (!spec->kb_dev) 4472 return; 4473 4474 switch (action) { 4475 case HDA_FIXUP_ACT_FREE: 4476 input_unregister_device(spec->kb_dev); 4477 spec->kb_dev = NULL; 4478 } 4479 } 4480 #else /* INPUT */ 4481 #define alc280_fixup_hp_gpio2_mic_hotkey NULL 4482 #define alc233_fixup_lenovo_line2_mic_hotkey NULL 4483 #endif /* INPUT */ 4484 4485 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec, 4486 const struct hda_fixup *fix, int action) 4487 { 4488 struct alc_spec *spec = codec->spec; 4489 4490 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1a); 4491 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4492 spec->cap_mute_led_nid = 0x18; 4493 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set); 4494 } 4495 } 4496 4497 static const struct coef_fw alc225_pre_hsmode[] = { 4498 UPDATE_COEF(0x4a, 1<<8, 0), 4499 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), 4500 UPDATE_COEF(0x63, 3<<14, 3<<14), 4501 UPDATE_COEF(0x4a, 3<<4, 2<<4), 4502 UPDATE_COEF(0x4a, 3<<10, 3<<10), 4503 UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10), 4504 UPDATE_COEF(0x4a, 3<<10, 0), 4505 {} 4506 }; 4507 4508 static void alc_headset_mode_unplugged(struct hda_codec *codec) 4509 { 4510 static const struct coef_fw coef0255[] = { 4511 WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */ 4512 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */ 4513 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/ 4514 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */ 4515 WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */ 4516 {} 4517 }; 4518 static const struct coef_fw coef0256[] = { 4519 WRITE_COEF(0x1b, 0x0c4b), /* LDO and MISC control */ 4520 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */ 4521 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */ 4522 WRITE_COEFEX(0x57, 0x03, 0x09a3), /* Direct Drive HP Amp control */ 4523 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/ 4524 {} 4525 }; 4526 static const struct coef_fw coef0233[] = { 4527 WRITE_COEF(0x1b, 0x0c0b), 4528 WRITE_COEF(0x45, 0xc429), 4529 UPDATE_COEF(0x35, 0x4000, 0), 4530 WRITE_COEF(0x06, 0x2104), 4531 WRITE_COEF(0x1a, 0x0001), 4532 WRITE_COEF(0x26, 0x0004), 4533 WRITE_COEF(0x32, 0x42a3), 4534 {} 4535 }; 4536 static const struct coef_fw coef0288[] = { 4537 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), 4538 UPDATE_COEF(0x50, 0x2000, 0x2000), 4539 UPDATE_COEF(0x56, 0x0006, 0x0006), 4540 UPDATE_COEF(0x66, 0x0008, 0), 4541 UPDATE_COEF(0x67, 0x2000, 0), 4542 {} 4543 }; 4544 static const struct coef_fw coef0298[] = { 4545 UPDATE_COEF(0x19, 0x1300, 0x0300), 4546 {} 4547 }; 4548 static const struct coef_fw coef0292[] = { 4549 WRITE_COEF(0x76, 0x000e), 4550 WRITE_COEF(0x6c, 0x2400), 4551 WRITE_COEF(0x18, 0x7308), 4552 WRITE_COEF(0x6b, 0xc429), 4553 {} 4554 }; 4555 static const struct coef_fw coef0293[] = { 4556 UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */ 4557 UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */ 4558 UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */ 4559 UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */ 4560 WRITE_COEF(0x45, 0xc429), /* Set to TRS type */ 4561 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */ 4562 {} 4563 }; 4564 static const struct coef_fw coef0668[] = { 4565 WRITE_COEF(0x15, 0x0d40), 4566 WRITE_COEF(0xb7, 0x802b), 4567 {} 4568 }; 4569 static const struct coef_fw coef0225[] = { 4570 UPDATE_COEF(0x63, 3<<14, 0), 4571 {} 4572 }; 4573 static const struct coef_fw coef0274[] = { 4574 UPDATE_COEF(0x4a, 0x0100, 0), 4575 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0), 4576 UPDATE_COEF(0x6b, 0xf000, 0x5000), 4577 UPDATE_COEF(0x4a, 0x0010, 0), 4578 UPDATE_COEF(0x4a, 0x0c00, 0x0c00), 4579 WRITE_COEF(0x45, 0x5289), 4580 UPDATE_COEF(0x4a, 0x0c00, 0), 4581 {} 4582 }; 4583 4584 switch (codec->core.vendor_id) { 4585 case 0x10ec0255: 4586 alc_process_coef_fw(codec, coef0255); 4587 break; 4588 case 0x10ec0236: 4589 case 0x10ec0256: 4590 alc_process_coef_fw(codec, coef0256); 4591 break; 4592 case 0x10ec0234: 4593 case 0x10ec0274: 4594 case 0x10ec0294: 4595 alc_process_coef_fw(codec, coef0274); 4596 break; 4597 case 0x10ec0233: 4598 case 0x10ec0283: 4599 alc_process_coef_fw(codec, coef0233); 4600 break; 4601 case 0x10ec0286: 4602 case 0x10ec0288: 4603 alc_process_coef_fw(codec, coef0288); 4604 break; 4605 case 0x10ec0298: 4606 alc_process_coef_fw(codec, coef0298); 4607 alc_process_coef_fw(codec, coef0288); 4608 break; 4609 case 0x10ec0292: 4610 alc_process_coef_fw(codec, coef0292); 4611 break; 4612 case 0x10ec0293: 4613 alc_process_coef_fw(codec, coef0293); 4614 break; 4615 case 0x10ec0668: 4616 alc_process_coef_fw(codec, coef0668); 4617 break; 4618 case 0x10ec0215: 4619 case 0x10ec0225: 4620 case 0x10ec0285: 4621 case 0x10ec0295: 4622 case 0x10ec0289: 4623 case 0x10ec0299: 4624 alc_process_coef_fw(codec, alc225_pre_hsmode); 4625 alc_process_coef_fw(codec, coef0225); 4626 break; 4627 case 0x10ec0867: 4628 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0); 4629 break; 4630 } 4631 codec_dbg(codec, "Headset jack set to unplugged mode.\n"); 4632 } 4633 4634 4635 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin, 4636 hda_nid_t mic_pin) 4637 { 4638 static const struct coef_fw coef0255[] = { 4639 WRITE_COEFEX(0x57, 0x03, 0x8aa6), 4640 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */ 4641 {} 4642 }; 4643 static const struct coef_fw coef0256[] = { 4644 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), /* Direct Drive HP Amp control(Set to verb control)*/ 4645 WRITE_COEFEX(0x57, 0x03, 0x09a3), 4646 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */ 4647 {} 4648 }; 4649 static const struct coef_fw coef0233[] = { 4650 UPDATE_COEF(0x35, 0, 1<<14), 4651 WRITE_COEF(0x06, 0x2100), 4652 WRITE_COEF(0x1a, 0x0021), 4653 WRITE_COEF(0x26, 0x008c), 4654 {} 4655 }; 4656 static const struct coef_fw coef0288[] = { 4657 UPDATE_COEF(0x4f, 0x00c0, 0), 4658 UPDATE_COEF(0x50, 0x2000, 0), 4659 UPDATE_COEF(0x56, 0x0006, 0), 4660 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), 4661 UPDATE_COEF(0x66, 0x0008, 0x0008), 4662 UPDATE_COEF(0x67, 0x2000, 0x2000), 4663 {} 4664 }; 4665 static const struct coef_fw coef0292[] = { 4666 WRITE_COEF(0x19, 0xa208), 4667 WRITE_COEF(0x2e, 0xacf0), 4668 {} 4669 }; 4670 static const struct coef_fw coef0293[] = { 4671 UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */ 4672 UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */ 4673 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */ 4674 {} 4675 }; 4676 static const struct coef_fw coef0688[] = { 4677 WRITE_COEF(0xb7, 0x802b), 4678 WRITE_COEF(0xb5, 0x1040), 4679 UPDATE_COEF(0xc3, 0, 1<<12), 4680 {} 4681 }; 4682 static const struct coef_fw coef0225[] = { 4683 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), 4684 UPDATE_COEF(0x4a, 3<<4, 2<<4), 4685 UPDATE_COEF(0x63, 3<<14, 0), 4686 {} 4687 }; 4688 static const struct coef_fw coef0274[] = { 4689 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0x4000), 4690 UPDATE_COEF(0x4a, 0x0010, 0), 4691 UPDATE_COEF(0x6b, 0xf000, 0), 4692 {} 4693 }; 4694 4695 switch (codec->core.vendor_id) { 4696 case 0x10ec0255: 4697 alc_write_coef_idx(codec, 0x45, 0xc489); 4698 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 4699 alc_process_coef_fw(codec, coef0255); 4700 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 4701 break; 4702 case 0x10ec0236: 4703 case 0x10ec0256: 4704 alc_write_coef_idx(codec, 0x45, 0xc489); 4705 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 4706 alc_process_coef_fw(codec, coef0256); 4707 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 4708 break; 4709 case 0x10ec0234: 4710 case 0x10ec0274: 4711 case 0x10ec0294: 4712 alc_write_coef_idx(codec, 0x45, 0x4689); 4713 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 4714 alc_process_coef_fw(codec, coef0274); 4715 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 4716 break; 4717 case 0x10ec0233: 4718 case 0x10ec0283: 4719 alc_write_coef_idx(codec, 0x45, 0xc429); 4720 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 4721 alc_process_coef_fw(codec, coef0233); 4722 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 4723 break; 4724 case 0x10ec0286: 4725 case 0x10ec0288: 4726 case 0x10ec0298: 4727 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 4728 alc_process_coef_fw(codec, coef0288); 4729 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 4730 break; 4731 case 0x10ec0292: 4732 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 4733 alc_process_coef_fw(codec, coef0292); 4734 break; 4735 case 0x10ec0293: 4736 /* Set to TRS mode */ 4737 alc_write_coef_idx(codec, 0x45, 0xc429); 4738 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 4739 alc_process_coef_fw(codec, coef0293); 4740 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 4741 break; 4742 case 0x10ec0867: 4743 alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14); 4744 fallthrough; 4745 case 0x10ec0221: 4746 case 0x10ec0662: 4747 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 4748 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 4749 break; 4750 case 0x10ec0668: 4751 alc_write_coef_idx(codec, 0x11, 0x0001); 4752 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 4753 alc_process_coef_fw(codec, coef0688); 4754 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 4755 break; 4756 case 0x10ec0215: 4757 case 0x10ec0225: 4758 case 0x10ec0285: 4759 case 0x10ec0295: 4760 case 0x10ec0289: 4761 case 0x10ec0299: 4762 alc_process_coef_fw(codec, alc225_pre_hsmode); 4763 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10); 4764 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 4765 alc_process_coef_fw(codec, coef0225); 4766 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 4767 break; 4768 } 4769 codec_dbg(codec, "Headset jack set to mic-in mode.\n"); 4770 } 4771 4772 static void alc_headset_mode_default(struct hda_codec *codec) 4773 { 4774 static const struct coef_fw coef0225[] = { 4775 UPDATE_COEF(0x45, 0x3f<<10, 0x30<<10), 4776 UPDATE_COEF(0x45, 0x3f<<10, 0x31<<10), 4777 UPDATE_COEF(0x49, 3<<8, 0<<8), 4778 UPDATE_COEF(0x4a, 3<<4, 3<<4), 4779 UPDATE_COEF(0x63, 3<<14, 0), 4780 UPDATE_COEF(0x67, 0xf000, 0x3000), 4781 {} 4782 }; 4783 static const struct coef_fw coef0255[] = { 4784 WRITE_COEF(0x45, 0xc089), 4785 WRITE_COEF(0x45, 0xc489), 4786 WRITE_COEFEX(0x57, 0x03, 0x8ea6), 4787 WRITE_COEF(0x49, 0x0049), 4788 {} 4789 }; 4790 static const struct coef_fw coef0256[] = { 4791 WRITE_COEF(0x45, 0xc489), 4792 WRITE_COEFEX(0x57, 0x03, 0x0da3), 4793 WRITE_COEF(0x49, 0x0049), 4794 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/ 4795 WRITE_COEF(0x06, 0x6100), 4796 {} 4797 }; 4798 static const struct coef_fw coef0233[] = { 4799 WRITE_COEF(0x06, 0x2100), 4800 WRITE_COEF(0x32, 0x4ea3), 4801 {} 4802 }; 4803 static const struct coef_fw coef0288[] = { 4804 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */ 4805 UPDATE_COEF(0x50, 0x2000, 0x2000), 4806 UPDATE_COEF(0x56, 0x0006, 0x0006), 4807 UPDATE_COEF(0x66, 0x0008, 0), 4808 UPDATE_COEF(0x67, 0x2000, 0), 4809 {} 4810 }; 4811 static const struct coef_fw coef0292[] = { 4812 WRITE_COEF(0x76, 0x000e), 4813 WRITE_COEF(0x6c, 0x2400), 4814 WRITE_COEF(0x6b, 0xc429), 4815 WRITE_COEF(0x18, 0x7308), 4816 {} 4817 }; 4818 static const struct coef_fw coef0293[] = { 4819 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */ 4820 WRITE_COEF(0x45, 0xC429), /* Set to TRS type */ 4821 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */ 4822 {} 4823 }; 4824 static const struct coef_fw coef0688[] = { 4825 WRITE_COEF(0x11, 0x0041), 4826 WRITE_COEF(0x15, 0x0d40), 4827 WRITE_COEF(0xb7, 0x802b), 4828 {} 4829 }; 4830 static const struct coef_fw coef0274[] = { 4831 WRITE_COEF(0x45, 0x4289), 4832 UPDATE_COEF(0x4a, 0x0010, 0x0010), 4833 UPDATE_COEF(0x6b, 0x0f00, 0), 4834 UPDATE_COEF(0x49, 0x0300, 0x0300), 4835 {} 4836 }; 4837 4838 switch (codec->core.vendor_id) { 4839 case 0x10ec0215: 4840 case 0x10ec0225: 4841 case 0x10ec0285: 4842 case 0x10ec0295: 4843 case 0x10ec0289: 4844 case 0x10ec0299: 4845 alc_process_coef_fw(codec, alc225_pre_hsmode); 4846 alc_process_coef_fw(codec, coef0225); 4847 break; 4848 case 0x10ec0255: 4849 alc_process_coef_fw(codec, coef0255); 4850 break; 4851 case 0x10ec0236: 4852 case 0x10ec0256: 4853 alc_write_coef_idx(codec, 0x1b, 0x0e4b); 4854 alc_write_coef_idx(codec, 0x45, 0xc089); 4855 msleep(50); 4856 alc_process_coef_fw(codec, coef0256); 4857 break; 4858 case 0x10ec0234: 4859 case 0x10ec0274: 4860 case 0x10ec0294: 4861 alc_process_coef_fw(codec, coef0274); 4862 break; 4863 case 0x10ec0233: 4864 case 0x10ec0283: 4865 alc_process_coef_fw(codec, coef0233); 4866 break; 4867 case 0x10ec0286: 4868 case 0x10ec0288: 4869 case 0x10ec0298: 4870 alc_process_coef_fw(codec, coef0288); 4871 break; 4872 case 0x10ec0292: 4873 alc_process_coef_fw(codec, coef0292); 4874 break; 4875 case 0x10ec0293: 4876 alc_process_coef_fw(codec, coef0293); 4877 break; 4878 case 0x10ec0668: 4879 alc_process_coef_fw(codec, coef0688); 4880 break; 4881 case 0x10ec0867: 4882 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0); 4883 break; 4884 } 4885 codec_dbg(codec, "Headset jack set to headphone (default) mode.\n"); 4886 } 4887 4888 /* Iphone type */ 4889 static void alc_headset_mode_ctia(struct hda_codec *codec) 4890 { 4891 int val; 4892 4893 static const struct coef_fw coef0255[] = { 4894 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */ 4895 WRITE_COEF(0x1b, 0x0c2b), 4896 WRITE_COEFEX(0x57, 0x03, 0x8ea6), 4897 {} 4898 }; 4899 static const struct coef_fw coef0256[] = { 4900 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */ 4901 WRITE_COEF(0x1b, 0x0e6b), 4902 {} 4903 }; 4904 static const struct coef_fw coef0233[] = { 4905 WRITE_COEF(0x45, 0xd429), 4906 WRITE_COEF(0x1b, 0x0c2b), 4907 WRITE_COEF(0x32, 0x4ea3), 4908 {} 4909 }; 4910 static const struct coef_fw coef0288[] = { 4911 UPDATE_COEF(0x50, 0x2000, 0x2000), 4912 UPDATE_COEF(0x56, 0x0006, 0x0006), 4913 UPDATE_COEF(0x66, 0x0008, 0), 4914 UPDATE_COEF(0x67, 0x2000, 0), 4915 {} 4916 }; 4917 static const struct coef_fw coef0292[] = { 4918 WRITE_COEF(0x6b, 0xd429), 4919 WRITE_COEF(0x76, 0x0008), 4920 WRITE_COEF(0x18, 0x7388), 4921 {} 4922 }; 4923 static const struct coef_fw coef0293[] = { 4924 WRITE_COEF(0x45, 0xd429), /* Set to ctia type */ 4925 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */ 4926 {} 4927 }; 4928 static const struct coef_fw coef0688[] = { 4929 WRITE_COEF(0x11, 0x0001), 4930 WRITE_COEF(0x15, 0x0d60), 4931 WRITE_COEF(0xc3, 0x0000), 4932 {} 4933 }; 4934 static const struct coef_fw coef0225_1[] = { 4935 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10), 4936 UPDATE_COEF(0x63, 3<<14, 2<<14), 4937 {} 4938 }; 4939 static const struct coef_fw coef0225_2[] = { 4940 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10), 4941 UPDATE_COEF(0x63, 3<<14, 1<<14), 4942 {} 4943 }; 4944 4945 switch (codec->core.vendor_id) { 4946 case 0x10ec0255: 4947 alc_process_coef_fw(codec, coef0255); 4948 break; 4949 case 0x10ec0236: 4950 case 0x10ec0256: 4951 alc_process_coef_fw(codec, coef0256); 4952 break; 4953 case 0x10ec0234: 4954 case 0x10ec0274: 4955 case 0x10ec0294: 4956 alc_write_coef_idx(codec, 0x45, 0xd689); 4957 break; 4958 case 0x10ec0233: 4959 case 0x10ec0283: 4960 alc_process_coef_fw(codec, coef0233); 4961 break; 4962 case 0x10ec0298: 4963 val = alc_read_coef_idx(codec, 0x50); 4964 if (val & (1 << 12)) { 4965 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020); 4966 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400); 4967 msleep(300); 4968 } else { 4969 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010); 4970 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400); 4971 msleep(300); 4972 } 4973 break; 4974 case 0x10ec0286: 4975 case 0x10ec0288: 4976 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400); 4977 msleep(300); 4978 alc_process_coef_fw(codec, coef0288); 4979 break; 4980 case 0x10ec0292: 4981 alc_process_coef_fw(codec, coef0292); 4982 break; 4983 case 0x10ec0293: 4984 alc_process_coef_fw(codec, coef0293); 4985 break; 4986 case 0x10ec0668: 4987 alc_process_coef_fw(codec, coef0688); 4988 break; 4989 case 0x10ec0215: 4990 case 0x10ec0225: 4991 case 0x10ec0285: 4992 case 0x10ec0295: 4993 case 0x10ec0289: 4994 case 0x10ec0299: 4995 val = alc_read_coef_idx(codec, 0x45); 4996 if (val & (1 << 9)) 4997 alc_process_coef_fw(codec, coef0225_2); 4998 else 4999 alc_process_coef_fw(codec, coef0225_1); 5000 break; 5001 case 0x10ec0867: 5002 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0); 5003 break; 5004 } 5005 codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n"); 5006 } 5007 5008 /* Nokia type */ 5009 static void alc_headset_mode_omtp(struct hda_codec *codec) 5010 { 5011 static const struct coef_fw coef0255[] = { 5012 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */ 5013 WRITE_COEF(0x1b, 0x0c2b), 5014 WRITE_COEFEX(0x57, 0x03, 0x8ea6), 5015 {} 5016 }; 5017 static const struct coef_fw coef0256[] = { 5018 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */ 5019 WRITE_COEF(0x1b, 0x0e6b), 5020 {} 5021 }; 5022 static const struct coef_fw coef0233[] = { 5023 WRITE_COEF(0x45, 0xe429), 5024 WRITE_COEF(0x1b, 0x0c2b), 5025 WRITE_COEF(0x32, 0x4ea3), 5026 {} 5027 }; 5028 static const struct coef_fw coef0288[] = { 5029 UPDATE_COEF(0x50, 0x2000, 0x2000), 5030 UPDATE_COEF(0x56, 0x0006, 0x0006), 5031 UPDATE_COEF(0x66, 0x0008, 0), 5032 UPDATE_COEF(0x67, 0x2000, 0), 5033 {} 5034 }; 5035 static const struct coef_fw coef0292[] = { 5036 WRITE_COEF(0x6b, 0xe429), 5037 WRITE_COEF(0x76, 0x0008), 5038 WRITE_COEF(0x18, 0x7388), 5039 {} 5040 }; 5041 static const struct coef_fw coef0293[] = { 5042 WRITE_COEF(0x45, 0xe429), /* Set to omtp type */ 5043 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */ 5044 {} 5045 }; 5046 static const struct coef_fw coef0688[] = { 5047 WRITE_COEF(0x11, 0x0001), 5048 WRITE_COEF(0x15, 0x0d50), 5049 WRITE_COEF(0xc3, 0x0000), 5050 {} 5051 }; 5052 static const struct coef_fw coef0225[] = { 5053 UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10), 5054 UPDATE_COEF(0x63, 3<<14, 2<<14), 5055 {} 5056 }; 5057 5058 switch (codec->core.vendor_id) { 5059 case 0x10ec0255: 5060 alc_process_coef_fw(codec, coef0255); 5061 break; 5062 case 0x10ec0236: 5063 case 0x10ec0256: 5064 alc_process_coef_fw(codec, coef0256); 5065 break; 5066 case 0x10ec0234: 5067 case 0x10ec0274: 5068 case 0x10ec0294: 5069 alc_write_coef_idx(codec, 0x45, 0xe689); 5070 break; 5071 case 0x10ec0233: 5072 case 0x10ec0283: 5073 alc_process_coef_fw(codec, coef0233); 5074 break; 5075 case 0x10ec0298: 5076 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */ 5077 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400); 5078 msleep(300); 5079 break; 5080 case 0x10ec0286: 5081 case 0x10ec0288: 5082 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400); 5083 msleep(300); 5084 alc_process_coef_fw(codec, coef0288); 5085 break; 5086 case 0x10ec0292: 5087 alc_process_coef_fw(codec, coef0292); 5088 break; 5089 case 0x10ec0293: 5090 alc_process_coef_fw(codec, coef0293); 5091 break; 5092 case 0x10ec0668: 5093 alc_process_coef_fw(codec, coef0688); 5094 break; 5095 case 0x10ec0215: 5096 case 0x10ec0225: 5097 case 0x10ec0285: 5098 case 0x10ec0295: 5099 case 0x10ec0289: 5100 case 0x10ec0299: 5101 alc_process_coef_fw(codec, coef0225); 5102 break; 5103 } 5104 codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n"); 5105 } 5106 5107 static void alc_determine_headset_type(struct hda_codec *codec) 5108 { 5109 int val; 5110 bool is_ctia = false; 5111 struct alc_spec *spec = codec->spec; 5112 static const struct coef_fw coef0255[] = { 5113 WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/ 5114 WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref 5115 conteol) */ 5116 {} 5117 }; 5118 static const struct coef_fw coef0288[] = { 5119 UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */ 5120 {} 5121 }; 5122 static const struct coef_fw coef0298[] = { 5123 UPDATE_COEF(0x50, 0x2000, 0x2000), 5124 UPDATE_COEF(0x56, 0x0006, 0x0006), 5125 UPDATE_COEF(0x66, 0x0008, 0), 5126 UPDATE_COEF(0x67, 0x2000, 0), 5127 UPDATE_COEF(0x19, 0x1300, 0x1300), 5128 {} 5129 }; 5130 static const struct coef_fw coef0293[] = { 5131 UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */ 5132 WRITE_COEF(0x45, 0xD429), /* Set to ctia type */ 5133 {} 5134 }; 5135 static const struct coef_fw coef0688[] = { 5136 WRITE_COEF(0x11, 0x0001), 5137 WRITE_COEF(0xb7, 0x802b), 5138 WRITE_COEF(0x15, 0x0d60), 5139 WRITE_COEF(0xc3, 0x0c00), 5140 {} 5141 }; 5142 static const struct coef_fw coef0274[] = { 5143 UPDATE_COEF(0x4a, 0x0010, 0), 5144 UPDATE_COEF(0x4a, 0x8000, 0), 5145 WRITE_COEF(0x45, 0xd289), 5146 UPDATE_COEF(0x49, 0x0300, 0x0300), 5147 {} 5148 }; 5149 5150 switch (codec->core.vendor_id) { 5151 case 0x10ec0255: 5152 alc_process_coef_fw(codec, coef0255); 5153 msleep(300); 5154 val = alc_read_coef_idx(codec, 0x46); 5155 is_ctia = (val & 0x0070) == 0x0070; 5156 break; 5157 case 0x10ec0236: 5158 case 0x10ec0256: 5159 alc_write_coef_idx(codec, 0x1b, 0x0e4b); 5160 alc_write_coef_idx(codec, 0x06, 0x6104); 5161 alc_write_coefex_idx(codec, 0x57, 0x3, 0x09a3); 5162 5163 snd_hda_codec_write(codec, 0x21, 0, 5164 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 5165 msleep(80); 5166 snd_hda_codec_write(codec, 0x21, 0, 5167 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 5168 5169 alc_process_coef_fw(codec, coef0255); 5170 msleep(300); 5171 val = alc_read_coef_idx(codec, 0x46); 5172 is_ctia = (val & 0x0070) == 0x0070; 5173 5174 alc_write_coefex_idx(codec, 0x57, 0x3, 0x0da3); 5175 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0); 5176 5177 snd_hda_codec_write(codec, 0x21, 0, 5178 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 5179 msleep(80); 5180 snd_hda_codec_write(codec, 0x21, 0, 5181 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 5182 break; 5183 case 0x10ec0234: 5184 case 0x10ec0274: 5185 case 0x10ec0294: 5186 alc_process_coef_fw(codec, coef0274); 5187 msleep(80); 5188 val = alc_read_coef_idx(codec, 0x46); 5189 is_ctia = (val & 0x00f0) == 0x00f0; 5190 break; 5191 case 0x10ec0233: 5192 case 0x10ec0283: 5193 alc_write_coef_idx(codec, 0x45, 0xd029); 5194 msleep(300); 5195 val = alc_read_coef_idx(codec, 0x46); 5196 is_ctia = (val & 0x0070) == 0x0070; 5197 break; 5198 case 0x10ec0298: 5199 snd_hda_codec_write(codec, 0x21, 0, 5200 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 5201 msleep(100); 5202 snd_hda_codec_write(codec, 0x21, 0, 5203 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 5204 msleep(200); 5205 5206 val = alc_read_coef_idx(codec, 0x50); 5207 if (val & (1 << 12)) { 5208 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020); 5209 alc_process_coef_fw(codec, coef0288); 5210 msleep(350); 5211 val = alc_read_coef_idx(codec, 0x50); 5212 is_ctia = (val & 0x0070) == 0x0070; 5213 } else { 5214 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010); 5215 alc_process_coef_fw(codec, coef0288); 5216 msleep(350); 5217 val = alc_read_coef_idx(codec, 0x50); 5218 is_ctia = (val & 0x0070) == 0x0070; 5219 } 5220 alc_process_coef_fw(codec, coef0298); 5221 snd_hda_codec_write(codec, 0x21, 0, 5222 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP); 5223 msleep(75); 5224 snd_hda_codec_write(codec, 0x21, 0, 5225 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 5226 break; 5227 case 0x10ec0286: 5228 case 0x10ec0288: 5229 alc_process_coef_fw(codec, coef0288); 5230 msleep(350); 5231 val = alc_read_coef_idx(codec, 0x50); 5232 is_ctia = (val & 0x0070) == 0x0070; 5233 break; 5234 case 0x10ec0292: 5235 alc_write_coef_idx(codec, 0x6b, 0xd429); 5236 msleep(300); 5237 val = alc_read_coef_idx(codec, 0x6c); 5238 is_ctia = (val & 0x001c) == 0x001c; 5239 break; 5240 case 0x10ec0293: 5241 alc_process_coef_fw(codec, coef0293); 5242 msleep(300); 5243 val = alc_read_coef_idx(codec, 0x46); 5244 is_ctia = (val & 0x0070) == 0x0070; 5245 break; 5246 case 0x10ec0668: 5247 alc_process_coef_fw(codec, coef0688); 5248 msleep(300); 5249 val = alc_read_coef_idx(codec, 0xbe); 5250 is_ctia = (val & 0x1c02) == 0x1c02; 5251 break; 5252 case 0x10ec0215: 5253 case 0x10ec0225: 5254 case 0x10ec0285: 5255 case 0x10ec0295: 5256 case 0x10ec0289: 5257 case 0x10ec0299: 5258 snd_hda_codec_write(codec, 0x21, 0, 5259 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 5260 msleep(80); 5261 snd_hda_codec_write(codec, 0x21, 0, 5262 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 5263 5264 alc_process_coef_fw(codec, alc225_pre_hsmode); 5265 alc_update_coef_idx(codec, 0x67, 0xf000, 0x1000); 5266 val = alc_read_coef_idx(codec, 0x45); 5267 if (val & (1 << 9)) { 5268 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10); 5269 alc_update_coef_idx(codec, 0x49, 3<<8, 2<<8); 5270 msleep(800); 5271 val = alc_read_coef_idx(codec, 0x46); 5272 is_ctia = (val & 0x00f0) == 0x00f0; 5273 } else { 5274 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10); 5275 alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8); 5276 msleep(800); 5277 val = alc_read_coef_idx(codec, 0x46); 5278 is_ctia = (val & 0x00f0) == 0x00f0; 5279 } 5280 alc_update_coef_idx(codec, 0x4a, 7<<6, 7<<6); 5281 alc_update_coef_idx(codec, 0x4a, 3<<4, 3<<4); 5282 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000); 5283 5284 snd_hda_codec_write(codec, 0x21, 0, 5285 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 5286 msleep(80); 5287 snd_hda_codec_write(codec, 0x21, 0, 5288 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 5289 break; 5290 case 0x10ec0867: 5291 is_ctia = true; 5292 break; 5293 } 5294 5295 codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n", 5296 is_ctia ? "yes" : "no"); 5297 spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP; 5298 } 5299 5300 static void alc_update_headset_mode(struct hda_codec *codec) 5301 { 5302 struct alc_spec *spec = codec->spec; 5303 5304 hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]]; 5305 hda_nid_t hp_pin = alc_get_hp_pin(spec); 5306 5307 int new_headset_mode; 5308 5309 if (!snd_hda_jack_detect(codec, hp_pin)) 5310 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED; 5311 else if (mux_pin == spec->headset_mic_pin) 5312 new_headset_mode = ALC_HEADSET_MODE_HEADSET; 5313 else if (mux_pin == spec->headphone_mic_pin) 5314 new_headset_mode = ALC_HEADSET_MODE_MIC; 5315 else 5316 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE; 5317 5318 if (new_headset_mode == spec->current_headset_mode) { 5319 snd_hda_gen_update_outputs(codec); 5320 return; 5321 } 5322 5323 switch (new_headset_mode) { 5324 case ALC_HEADSET_MODE_UNPLUGGED: 5325 alc_headset_mode_unplugged(codec); 5326 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN; 5327 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN; 5328 spec->gen.hp_jack_present = false; 5329 break; 5330 case ALC_HEADSET_MODE_HEADSET: 5331 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN) 5332 alc_determine_headset_type(codec); 5333 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA) 5334 alc_headset_mode_ctia(codec); 5335 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP) 5336 alc_headset_mode_omtp(codec); 5337 spec->gen.hp_jack_present = true; 5338 break; 5339 case ALC_HEADSET_MODE_MIC: 5340 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin); 5341 spec->gen.hp_jack_present = false; 5342 break; 5343 case ALC_HEADSET_MODE_HEADPHONE: 5344 alc_headset_mode_default(codec); 5345 spec->gen.hp_jack_present = true; 5346 break; 5347 } 5348 if (new_headset_mode != ALC_HEADSET_MODE_MIC) { 5349 snd_hda_set_pin_ctl_cache(codec, hp_pin, 5350 AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN); 5351 if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin) 5352 snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin, 5353 PIN_VREFHIZ); 5354 } 5355 spec->current_headset_mode = new_headset_mode; 5356 5357 snd_hda_gen_update_outputs(codec); 5358 } 5359 5360 static void alc_update_headset_mode_hook(struct hda_codec *codec, 5361 struct snd_kcontrol *kcontrol, 5362 struct snd_ctl_elem_value *ucontrol) 5363 { 5364 alc_update_headset_mode(codec); 5365 } 5366 5367 static void alc_update_headset_jack_cb(struct hda_codec *codec, 5368 struct hda_jack_callback *jack) 5369 { 5370 snd_hda_gen_hp_automute(codec, jack); 5371 } 5372 5373 static void alc_probe_headset_mode(struct hda_codec *codec) 5374 { 5375 int i; 5376 struct alc_spec *spec = codec->spec; 5377 struct auto_pin_cfg *cfg = &spec->gen.autocfg; 5378 5379 /* Find mic pins */ 5380 for (i = 0; i < cfg->num_inputs; i++) { 5381 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin) 5382 spec->headset_mic_pin = cfg->inputs[i].pin; 5383 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin) 5384 spec->headphone_mic_pin = cfg->inputs[i].pin; 5385 } 5386 5387 WARN_ON(spec->gen.cap_sync_hook); 5388 spec->gen.cap_sync_hook = alc_update_headset_mode_hook; 5389 spec->gen.automute_hook = alc_update_headset_mode; 5390 spec->gen.hp_automute_hook = alc_update_headset_jack_cb; 5391 } 5392 5393 static void alc_fixup_headset_mode(struct hda_codec *codec, 5394 const struct hda_fixup *fix, int action) 5395 { 5396 struct alc_spec *spec = codec->spec; 5397 5398 switch (action) { 5399 case HDA_FIXUP_ACT_PRE_PROBE: 5400 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC; 5401 break; 5402 case HDA_FIXUP_ACT_PROBE: 5403 alc_probe_headset_mode(codec); 5404 break; 5405 case HDA_FIXUP_ACT_INIT: 5406 if (is_s3_resume(codec) || is_s4_resume(codec)) { 5407 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN; 5408 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN; 5409 } 5410 alc_update_headset_mode(codec); 5411 break; 5412 } 5413 } 5414 5415 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec, 5416 const struct hda_fixup *fix, int action) 5417 { 5418 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5419 struct alc_spec *spec = codec->spec; 5420 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 5421 } 5422 else 5423 alc_fixup_headset_mode(codec, fix, action); 5424 } 5425 5426 static void alc255_set_default_jack_type(struct hda_codec *codec) 5427 { 5428 /* Set to iphone type */ 5429 static const struct coef_fw alc255fw[] = { 5430 WRITE_COEF(0x1b, 0x880b), 5431 WRITE_COEF(0x45, 0xd089), 5432 WRITE_COEF(0x1b, 0x080b), 5433 WRITE_COEF(0x46, 0x0004), 5434 WRITE_COEF(0x1b, 0x0c0b), 5435 {} 5436 }; 5437 static const struct coef_fw alc256fw[] = { 5438 WRITE_COEF(0x1b, 0x884b), 5439 WRITE_COEF(0x45, 0xd089), 5440 WRITE_COEF(0x1b, 0x084b), 5441 WRITE_COEF(0x46, 0x0004), 5442 WRITE_COEF(0x1b, 0x0c4b), 5443 {} 5444 }; 5445 switch (codec->core.vendor_id) { 5446 case 0x10ec0255: 5447 alc_process_coef_fw(codec, alc255fw); 5448 break; 5449 case 0x10ec0236: 5450 case 0x10ec0256: 5451 alc_process_coef_fw(codec, alc256fw); 5452 break; 5453 } 5454 msleep(30); 5455 } 5456 5457 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec, 5458 const struct hda_fixup *fix, int action) 5459 { 5460 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5461 alc255_set_default_jack_type(codec); 5462 } 5463 alc_fixup_headset_mode(codec, fix, action); 5464 } 5465 5466 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec, 5467 const struct hda_fixup *fix, int action) 5468 { 5469 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5470 struct alc_spec *spec = codec->spec; 5471 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 5472 alc255_set_default_jack_type(codec); 5473 } 5474 else 5475 alc_fixup_headset_mode(codec, fix, action); 5476 } 5477 5478 static void alc288_update_headset_jack_cb(struct hda_codec *codec, 5479 struct hda_jack_callback *jack) 5480 { 5481 struct alc_spec *spec = codec->spec; 5482 5483 alc_update_headset_jack_cb(codec, jack); 5484 /* Headset Mic enable or disable, only for Dell Dino */ 5485 alc_update_gpio_data(codec, 0x40, spec->gen.hp_jack_present); 5486 } 5487 5488 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec, 5489 const struct hda_fixup *fix, int action) 5490 { 5491 alc_fixup_headset_mode(codec, fix, action); 5492 if (action == HDA_FIXUP_ACT_PROBE) { 5493 struct alc_spec *spec = codec->spec; 5494 /* toggled via hp_automute_hook */ 5495 spec->gpio_mask |= 0x40; 5496 spec->gpio_dir |= 0x40; 5497 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb; 5498 } 5499 } 5500 5501 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec, 5502 const struct hda_fixup *fix, int action) 5503 { 5504 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5505 struct alc_spec *spec = codec->spec; 5506 spec->gen.auto_mute_via_amp = 1; 5507 } 5508 } 5509 5510 static void alc_fixup_no_shutup(struct hda_codec *codec, 5511 const struct hda_fixup *fix, int action) 5512 { 5513 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5514 struct alc_spec *spec = codec->spec; 5515 spec->no_shutup_pins = 1; 5516 } 5517 } 5518 5519 static void alc_fixup_disable_aamix(struct hda_codec *codec, 5520 const struct hda_fixup *fix, int action) 5521 { 5522 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5523 struct alc_spec *spec = codec->spec; 5524 /* Disable AA-loopback as it causes white noise */ 5525 spec->gen.mixer_nid = 0; 5526 } 5527 } 5528 5529 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */ 5530 static void alc_fixup_tpt440_dock(struct hda_codec *codec, 5531 const struct hda_fixup *fix, int action) 5532 { 5533 static const struct hda_pintbl pincfgs[] = { 5534 { 0x16, 0x21211010 }, /* dock headphone */ 5535 { 0x19, 0x21a11010 }, /* dock mic */ 5536 { } 5537 }; 5538 struct alc_spec *spec = codec->spec; 5539 5540 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5541 spec->reboot_notify = snd_hda_gen_reboot_notify; /* reduce noise */ 5542 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 5543 codec->power_save_node = 0; /* avoid click noises */ 5544 snd_hda_apply_pincfgs(codec, pincfgs); 5545 } 5546 } 5547 5548 static void alc_fixup_tpt470_dock(struct hda_codec *codec, 5549 const struct hda_fixup *fix, int action) 5550 { 5551 static const struct hda_pintbl pincfgs[] = { 5552 { 0x17, 0x21211010 }, /* dock headphone */ 5553 { 0x19, 0x21a11010 }, /* dock mic */ 5554 { } 5555 }; 5556 struct alc_spec *spec = codec->spec; 5557 5558 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5559 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 5560 snd_hda_apply_pincfgs(codec, pincfgs); 5561 } else if (action == HDA_FIXUP_ACT_INIT) { 5562 /* Enable DOCK device */ 5563 snd_hda_codec_write(codec, 0x17, 0, 5564 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0); 5565 /* Enable DOCK device */ 5566 snd_hda_codec_write(codec, 0x19, 0, 5567 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0); 5568 } 5569 } 5570 5571 static void alc_fixup_tpt470_dacs(struct hda_codec *codec, 5572 const struct hda_fixup *fix, int action) 5573 { 5574 /* Assure the speaker pin to be coupled with DAC NID 0x03; otherwise 5575 * the speaker output becomes too low by some reason on Thinkpads with 5576 * ALC298 codec 5577 */ 5578 static const hda_nid_t preferred_pairs[] = { 5579 0x14, 0x03, 0x17, 0x02, 0x21, 0x02, 5580 0 5581 }; 5582 struct alc_spec *spec = codec->spec; 5583 5584 if (action == HDA_FIXUP_ACT_PRE_PROBE) 5585 spec->gen.preferred_dacs = preferred_pairs; 5586 } 5587 5588 static void alc_shutup_dell_xps13(struct hda_codec *codec) 5589 { 5590 struct alc_spec *spec = codec->spec; 5591 int hp_pin = alc_get_hp_pin(spec); 5592 5593 /* Prevent pop noises when headphones are plugged in */ 5594 snd_hda_codec_write(codec, hp_pin, 0, 5595 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 5596 msleep(20); 5597 } 5598 5599 static void alc_fixup_dell_xps13(struct hda_codec *codec, 5600 const struct hda_fixup *fix, int action) 5601 { 5602 struct alc_spec *spec = codec->spec; 5603 struct hda_input_mux *imux = &spec->gen.input_mux; 5604 int i; 5605 5606 switch (action) { 5607 case HDA_FIXUP_ACT_PRE_PROBE: 5608 /* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise 5609 * it causes a click noise at start up 5610 */ 5611 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ); 5612 spec->shutup = alc_shutup_dell_xps13; 5613 break; 5614 case HDA_FIXUP_ACT_PROBE: 5615 /* Make the internal mic the default input source. */ 5616 for (i = 0; i < imux->num_items; i++) { 5617 if (spec->gen.imux_pins[i] == 0x12) { 5618 spec->gen.cur_mux[0] = i; 5619 break; 5620 } 5621 } 5622 break; 5623 } 5624 } 5625 5626 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec, 5627 const struct hda_fixup *fix, int action) 5628 { 5629 struct alc_spec *spec = codec->spec; 5630 5631 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5632 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 5633 spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */ 5634 5635 /* Disable boost for mic-in permanently. (This code is only called 5636 from quirks that guarantee that the headphone is at NID 0x1b.) */ 5637 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000); 5638 snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP); 5639 } else 5640 alc_fixup_headset_mode(codec, fix, action); 5641 } 5642 5643 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec, 5644 const struct hda_fixup *fix, int action) 5645 { 5646 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5647 alc_write_coef_idx(codec, 0xc4, 0x8000); 5648 alc_update_coef_idx(codec, 0xc2, ~0xfe, 0); 5649 snd_hda_set_pin_ctl_cache(codec, 0x18, 0); 5650 } 5651 alc_fixup_headset_mode(codec, fix, action); 5652 } 5653 5654 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */ 5655 static int find_ext_mic_pin(struct hda_codec *codec) 5656 { 5657 struct alc_spec *spec = codec->spec; 5658 struct auto_pin_cfg *cfg = &spec->gen.autocfg; 5659 hda_nid_t nid; 5660 unsigned int defcfg; 5661 int i; 5662 5663 for (i = 0; i < cfg->num_inputs; i++) { 5664 if (cfg->inputs[i].type != AUTO_PIN_MIC) 5665 continue; 5666 nid = cfg->inputs[i].pin; 5667 defcfg = snd_hda_codec_get_pincfg(codec, nid); 5668 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT) 5669 continue; 5670 return nid; 5671 } 5672 5673 return 0; 5674 } 5675 5676 static void alc271_hp_gate_mic_jack(struct hda_codec *codec, 5677 const struct hda_fixup *fix, 5678 int action) 5679 { 5680 struct alc_spec *spec = codec->spec; 5681 5682 if (action == HDA_FIXUP_ACT_PROBE) { 5683 int mic_pin = find_ext_mic_pin(codec); 5684 int hp_pin = alc_get_hp_pin(spec); 5685 5686 if (snd_BUG_ON(!mic_pin || !hp_pin)) 5687 return; 5688 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin); 5689 } 5690 } 5691 5692 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec, 5693 const struct hda_fixup *fix, 5694 int action) 5695 { 5696 struct alc_spec *spec = codec->spec; 5697 struct auto_pin_cfg *cfg = &spec->gen.autocfg; 5698 int i; 5699 5700 /* The mic boosts on level 2 and 3 are too noisy 5701 on the internal mic input. 5702 Therefore limit the boost to 0 or 1. */ 5703 5704 if (action != HDA_FIXUP_ACT_PROBE) 5705 return; 5706 5707 for (i = 0; i < cfg->num_inputs; i++) { 5708 hda_nid_t nid = cfg->inputs[i].pin; 5709 unsigned int defcfg; 5710 if (cfg->inputs[i].type != AUTO_PIN_MIC) 5711 continue; 5712 defcfg = snd_hda_codec_get_pincfg(codec, nid); 5713 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT) 5714 continue; 5715 5716 snd_hda_override_amp_caps(codec, nid, HDA_INPUT, 5717 (0x00 << AC_AMPCAP_OFFSET_SHIFT) | 5718 (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) | 5719 (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) | 5720 (0 << AC_AMPCAP_MUTE_SHIFT)); 5721 } 5722 } 5723 5724 static void alc283_hp_automute_hook(struct hda_codec *codec, 5725 struct hda_jack_callback *jack) 5726 { 5727 struct alc_spec *spec = codec->spec; 5728 int vref; 5729 5730 msleep(200); 5731 snd_hda_gen_hp_automute(codec, jack); 5732 5733 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0; 5734 5735 msleep(600); 5736 snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 5737 vref); 5738 } 5739 5740 static void alc283_fixup_chromebook(struct hda_codec *codec, 5741 const struct hda_fixup *fix, int action) 5742 { 5743 struct alc_spec *spec = codec->spec; 5744 5745 switch (action) { 5746 case HDA_FIXUP_ACT_PRE_PROBE: 5747 snd_hda_override_wcaps(codec, 0x03, 0); 5748 /* Disable AA-loopback as it causes white noise */ 5749 spec->gen.mixer_nid = 0; 5750 break; 5751 case HDA_FIXUP_ACT_INIT: 5752 /* MIC2-VREF control */ 5753 /* Set to manual mode */ 5754 alc_update_coef_idx(codec, 0x06, 0x000c, 0); 5755 /* Enable Line1 input control by verb */ 5756 alc_update_coef_idx(codec, 0x1a, 0, 1 << 4); 5757 break; 5758 } 5759 } 5760 5761 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec, 5762 const struct hda_fixup *fix, int action) 5763 { 5764 struct alc_spec *spec = codec->spec; 5765 5766 switch (action) { 5767 case HDA_FIXUP_ACT_PRE_PROBE: 5768 spec->gen.hp_automute_hook = alc283_hp_automute_hook; 5769 break; 5770 case HDA_FIXUP_ACT_INIT: 5771 /* MIC2-VREF control */ 5772 /* Set to manual mode */ 5773 alc_update_coef_idx(codec, 0x06, 0x000c, 0); 5774 break; 5775 } 5776 } 5777 5778 /* mute tablet speaker pin (0x14) via dock plugging in addition */ 5779 static void asus_tx300_automute(struct hda_codec *codec) 5780 { 5781 struct alc_spec *spec = codec->spec; 5782 snd_hda_gen_update_outputs(codec); 5783 if (snd_hda_jack_detect(codec, 0x1b)) 5784 spec->gen.mute_bits |= (1ULL << 0x14); 5785 } 5786 5787 static void alc282_fixup_asus_tx300(struct hda_codec *codec, 5788 const struct hda_fixup *fix, int action) 5789 { 5790 struct alc_spec *spec = codec->spec; 5791 static const struct hda_pintbl dock_pins[] = { 5792 { 0x1b, 0x21114000 }, /* dock speaker pin */ 5793 {} 5794 }; 5795 5796 switch (action) { 5797 case HDA_FIXUP_ACT_PRE_PROBE: 5798 spec->init_amp = ALC_INIT_DEFAULT; 5799 /* TX300 needs to set up GPIO2 for the speaker amp */ 5800 alc_setup_gpio(codec, 0x04); 5801 snd_hda_apply_pincfgs(codec, dock_pins); 5802 spec->gen.auto_mute_via_amp = 1; 5803 spec->gen.automute_hook = asus_tx300_automute; 5804 snd_hda_jack_detect_enable_callback(codec, 0x1b, 5805 snd_hda_gen_hp_automute); 5806 break; 5807 case HDA_FIXUP_ACT_PROBE: 5808 spec->init_amp = ALC_INIT_DEFAULT; 5809 break; 5810 case HDA_FIXUP_ACT_BUILD: 5811 /* this is a bit tricky; give more sane names for the main 5812 * (tablet) speaker and the dock speaker, respectively 5813 */ 5814 rename_ctl(codec, "Speaker Playback Switch", 5815 "Dock Speaker Playback Switch"); 5816 rename_ctl(codec, "Bass Speaker Playback Switch", 5817 "Speaker Playback Switch"); 5818 break; 5819 } 5820 } 5821 5822 static void alc290_fixup_mono_speakers(struct hda_codec *codec, 5823 const struct hda_fixup *fix, int action) 5824 { 5825 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5826 /* DAC node 0x03 is giving mono output. We therefore want to 5827 make sure 0x14 (front speaker) and 0x15 (headphones) use the 5828 stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */ 5829 static const hda_nid_t conn1[] = { 0x0c }; 5830 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1); 5831 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1); 5832 } 5833 } 5834 5835 static void alc298_fixup_speaker_volume(struct hda_codec *codec, 5836 const struct hda_fixup *fix, int action) 5837 { 5838 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5839 /* The speaker is routed to the Node 0x06 by a mistake, as a result 5840 we can't adjust the speaker's volume since this node does not has 5841 Amp-out capability. we change the speaker's route to: 5842 Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 ( 5843 Pin Complex), since Node 0x02 has Amp-out caps, we can adjust 5844 speaker's volume now. */ 5845 5846 static const hda_nid_t conn1[] = { 0x0c }; 5847 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn1), conn1); 5848 } 5849 } 5850 5851 /* disable DAC3 (0x06) selection on NID 0x17 as it has no volume amp control */ 5852 static void alc295_fixup_disable_dac3(struct hda_codec *codec, 5853 const struct hda_fixup *fix, int action) 5854 { 5855 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5856 static const hda_nid_t conn[] = { 0x02, 0x03 }; 5857 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 5858 } 5859 } 5860 5861 /* force NID 0x17 (Bass Speaker) to DAC1 to share it with the main speaker */ 5862 static void alc285_fixup_speaker2_to_dac1(struct hda_codec *codec, 5863 const struct hda_fixup *fix, int action) 5864 { 5865 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5866 static const hda_nid_t conn[] = { 0x02 }; 5867 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 5868 } 5869 } 5870 5871 /* Hook to update amp GPIO4 for automute */ 5872 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec, 5873 struct hda_jack_callback *jack) 5874 { 5875 struct alc_spec *spec = codec->spec; 5876 5877 snd_hda_gen_hp_automute(codec, jack); 5878 /* mute_led_polarity is set to 0, so we pass inverted value here */ 5879 alc_update_gpio_led(codec, 0x10, spec->mute_led_polarity, 5880 !spec->gen.hp_jack_present); 5881 } 5882 5883 /* Manage GPIOs for HP EliteBook Folio 9480m. 5884 * 5885 * GPIO4 is the headphone amplifier power control 5886 * GPIO3 is the audio output mute indicator LED 5887 */ 5888 5889 static void alc280_fixup_hp_9480m(struct hda_codec *codec, 5890 const struct hda_fixup *fix, 5891 int action) 5892 { 5893 struct alc_spec *spec = codec->spec; 5894 5895 alc_fixup_hp_gpio_led(codec, action, 0x08, 0); 5896 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5897 /* amp at GPIO4; toggled via alc280_hp_gpio4_automute_hook() */ 5898 spec->gpio_mask |= 0x10; 5899 spec->gpio_dir |= 0x10; 5900 spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook; 5901 } 5902 } 5903 5904 static void alc275_fixup_gpio4_off(struct hda_codec *codec, 5905 const struct hda_fixup *fix, 5906 int action) 5907 { 5908 struct alc_spec *spec = codec->spec; 5909 5910 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5911 spec->gpio_mask |= 0x04; 5912 spec->gpio_dir |= 0x04; 5913 /* set data bit low */ 5914 } 5915 } 5916 5917 /* Quirk for Thinkpad X1 7th and 8th Gen 5918 * The following fixed routing needed 5919 * DAC1 (NID 0x02) -> Speaker (NID 0x14); some eq applied secretly 5920 * DAC2 (NID 0x03) -> Bass (NID 0x17) & Headphone (NID 0x21); sharing a DAC 5921 * DAC3 (NID 0x06) -> Unused, due to the lack of volume amp 5922 */ 5923 static void alc285_fixup_thinkpad_x1_gen7(struct hda_codec *codec, 5924 const struct hda_fixup *fix, int action) 5925 { 5926 static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */ 5927 static const hda_nid_t preferred_pairs[] = { 5928 0x14, 0x02, 0x17, 0x03, 0x21, 0x03, 0 5929 }; 5930 struct alc_spec *spec = codec->spec; 5931 5932 switch (action) { 5933 case HDA_FIXUP_ACT_PRE_PROBE: 5934 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 5935 spec->gen.preferred_dacs = preferred_pairs; 5936 break; 5937 case HDA_FIXUP_ACT_BUILD: 5938 /* The generic parser creates somewhat unintuitive volume ctls 5939 * with the fixed routing above, and the shared DAC2 may be 5940 * confusing for PA. 5941 * Rename those to unique names so that PA doesn't touch them 5942 * and use only Master volume. 5943 */ 5944 rename_ctl(codec, "Front Playback Volume", "DAC1 Playback Volume"); 5945 rename_ctl(codec, "Bass Speaker Playback Volume", "DAC2 Playback Volume"); 5946 break; 5947 } 5948 } 5949 5950 static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec, 5951 const struct hda_fixup *fix, 5952 int action) 5953 { 5954 alc_fixup_dual_codecs(codec, fix, action); 5955 switch (action) { 5956 case HDA_FIXUP_ACT_PRE_PROBE: 5957 /* override card longname to provide a unique UCM profile */ 5958 strcpy(codec->card->longname, "HDAudio-Lenovo-DualCodecs"); 5959 break; 5960 case HDA_FIXUP_ACT_BUILD: 5961 /* rename Capture controls depending on the codec */ 5962 rename_ctl(codec, "Capture Volume", 5963 codec->addr == 0 ? 5964 "Rear-Panel Capture Volume" : 5965 "Front-Panel Capture Volume"); 5966 rename_ctl(codec, "Capture Switch", 5967 codec->addr == 0 ? 5968 "Rear-Panel Capture Switch" : 5969 "Front-Panel Capture Switch"); 5970 break; 5971 } 5972 } 5973 5974 static void alc225_fixup_s3_pop_noise(struct hda_codec *codec, 5975 const struct hda_fixup *fix, int action) 5976 { 5977 if (action != HDA_FIXUP_ACT_PRE_PROBE) 5978 return; 5979 5980 codec->power_save_node = 1; 5981 } 5982 5983 /* Forcibly assign NID 0x03 to HP/LO while NID 0x02 to SPK for EQ */ 5984 static void alc274_fixup_bind_dacs(struct hda_codec *codec, 5985 const struct hda_fixup *fix, int action) 5986 { 5987 struct alc_spec *spec = codec->spec; 5988 static const hda_nid_t preferred_pairs[] = { 5989 0x21, 0x03, 0x1b, 0x03, 0x16, 0x02, 5990 0 5991 }; 5992 5993 if (action != HDA_FIXUP_ACT_PRE_PROBE) 5994 return; 5995 5996 spec->gen.preferred_dacs = preferred_pairs; 5997 spec->gen.auto_mute_via_amp = 1; 5998 codec->power_save_node = 0; 5999 } 6000 6001 /* The DAC of NID 0x3 will introduce click/pop noise on headphones, so invalidate it */ 6002 static void alc285_fixup_invalidate_dacs(struct hda_codec *codec, 6003 const struct hda_fixup *fix, int action) 6004 { 6005 if (action != HDA_FIXUP_ACT_PRE_PROBE) 6006 return; 6007 6008 snd_hda_override_wcaps(codec, 0x03, 0); 6009 } 6010 6011 static void alc295_fixup_chromebook(struct hda_codec *codec, 6012 const struct hda_fixup *fix, int action) 6013 { 6014 struct alc_spec *spec = codec->spec; 6015 6016 switch (action) { 6017 case HDA_FIXUP_ACT_PRE_PROBE: 6018 spec->ultra_low_power = true; 6019 break; 6020 case HDA_FIXUP_ACT_INIT: 6021 switch (codec->core.vendor_id) { 6022 case 0x10ec0295: 6023 alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */ 6024 alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15); 6025 break; 6026 case 0x10ec0236: 6027 alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */ 6028 alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15); 6029 break; 6030 } 6031 break; 6032 } 6033 } 6034 6035 static void alc_fixup_disable_mic_vref(struct hda_codec *codec, 6036 const struct hda_fixup *fix, int action) 6037 { 6038 if (action == HDA_FIXUP_ACT_PRE_PROBE) 6039 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ); 6040 } 6041 6042 6043 static void alc294_gx502_toggle_output(struct hda_codec *codec, 6044 struct hda_jack_callback *cb) 6045 { 6046 /* The Windows driver sets the codec up in a very different way where 6047 * it appears to leave 0x10 = 0x8a20 set. For Linux we need to toggle it 6048 */ 6049 if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT) 6050 alc_write_coef_idx(codec, 0x10, 0x8a20); 6051 else 6052 alc_write_coef_idx(codec, 0x10, 0x0a20); 6053 } 6054 6055 static void alc294_fixup_gx502_hp(struct hda_codec *codec, 6056 const struct hda_fixup *fix, int action) 6057 { 6058 /* Pin 0x21: headphones/headset mic */ 6059 if (!is_jack_detectable(codec, 0x21)) 6060 return; 6061 6062 switch (action) { 6063 case HDA_FIXUP_ACT_PRE_PROBE: 6064 snd_hda_jack_detect_enable_callback(codec, 0x21, 6065 alc294_gx502_toggle_output); 6066 break; 6067 case HDA_FIXUP_ACT_INIT: 6068 /* Make sure to start in a correct state, i.e. if 6069 * headphones have been plugged in before powering up the system 6070 */ 6071 alc294_gx502_toggle_output(codec, NULL); 6072 break; 6073 } 6074 } 6075 6076 static void alc285_fixup_hp_gpio_amp_init(struct hda_codec *codec, 6077 const struct hda_fixup *fix, int action) 6078 { 6079 if (action != HDA_FIXUP_ACT_INIT) 6080 return; 6081 6082 msleep(100); 6083 alc_write_coef_idx(codec, 0x65, 0x0); 6084 } 6085 6086 /* for hda_fixup_thinkpad_acpi() */ 6087 #include "thinkpad_helper.c" 6088 6089 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec, 6090 const struct hda_fixup *fix, int action) 6091 { 6092 alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */ 6093 hda_fixup_thinkpad_acpi(codec, fix, action); 6094 } 6095 6096 /* for alc295_fixup_hp_top_speakers */ 6097 #include "hp_x360_helper.c" 6098 6099 enum { 6100 ALC269_FIXUP_GPIO2, 6101 ALC269_FIXUP_SONY_VAIO, 6102 ALC275_FIXUP_SONY_VAIO_GPIO2, 6103 ALC269_FIXUP_DELL_M101Z, 6104 ALC269_FIXUP_SKU_IGNORE, 6105 ALC269_FIXUP_ASUS_G73JW, 6106 ALC269_FIXUP_LENOVO_EAPD, 6107 ALC275_FIXUP_SONY_HWEQ, 6108 ALC275_FIXUP_SONY_DISABLE_AAMIX, 6109 ALC271_FIXUP_DMIC, 6110 ALC269_FIXUP_PCM_44K, 6111 ALC269_FIXUP_STEREO_DMIC, 6112 ALC269_FIXUP_HEADSET_MIC, 6113 ALC269_FIXUP_QUANTA_MUTE, 6114 ALC269_FIXUP_LIFEBOOK, 6115 ALC269_FIXUP_LIFEBOOK_EXTMIC, 6116 ALC269_FIXUP_LIFEBOOK_HP_PIN, 6117 ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT, 6118 ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, 6119 ALC269_FIXUP_AMIC, 6120 ALC269_FIXUP_DMIC, 6121 ALC269VB_FIXUP_AMIC, 6122 ALC269VB_FIXUP_DMIC, 6123 ALC269_FIXUP_HP_MUTE_LED, 6124 ALC269_FIXUP_HP_MUTE_LED_MIC1, 6125 ALC269_FIXUP_HP_MUTE_LED_MIC2, 6126 ALC269_FIXUP_HP_MUTE_LED_MIC3, 6127 ALC269_FIXUP_HP_GPIO_LED, 6128 ALC269_FIXUP_HP_GPIO_MIC1_LED, 6129 ALC269_FIXUP_HP_LINE1_MIC1_LED, 6130 ALC269_FIXUP_INV_DMIC, 6131 ALC269_FIXUP_LENOVO_DOCK, 6132 ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, 6133 ALC269_FIXUP_NO_SHUTUP, 6134 ALC286_FIXUP_SONY_MIC_NO_PRESENCE, 6135 ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT, 6136 ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 6137 ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, 6138 ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, 6139 ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 6140 ALC269_FIXUP_HEADSET_MODE, 6141 ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, 6142 ALC269_FIXUP_ASPIRE_HEADSET_MIC, 6143 ALC269_FIXUP_ASUS_X101_FUNC, 6144 ALC269_FIXUP_ASUS_X101_VERB, 6145 ALC269_FIXUP_ASUS_X101, 6146 ALC271_FIXUP_AMIC_MIC2, 6147 ALC271_FIXUP_HP_GATE_MIC_JACK, 6148 ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, 6149 ALC269_FIXUP_ACER_AC700, 6150 ALC269_FIXUP_LIMIT_INT_MIC_BOOST, 6151 ALC269VB_FIXUP_ASUS_ZENBOOK, 6152 ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, 6153 ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED, 6154 ALC269VB_FIXUP_ORDISSIMO_EVE2, 6155 ALC283_FIXUP_CHROME_BOOK, 6156 ALC283_FIXUP_SENSE_COMBO_JACK, 6157 ALC282_FIXUP_ASUS_TX300, 6158 ALC283_FIXUP_INT_MIC, 6159 ALC290_FIXUP_MONO_SPEAKERS, 6160 ALC290_FIXUP_MONO_SPEAKERS_HSJACK, 6161 ALC290_FIXUP_SUBWOOFER, 6162 ALC290_FIXUP_SUBWOOFER_HSJACK, 6163 ALC269_FIXUP_THINKPAD_ACPI, 6164 ALC269_FIXUP_DMIC_THINKPAD_ACPI, 6165 ALC255_FIXUP_ACER_MIC_NO_PRESENCE, 6166 ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, 6167 ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 6168 ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, 6169 ALC255_FIXUP_HEADSET_MODE, 6170 ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC, 6171 ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, 6172 ALC292_FIXUP_TPT440_DOCK, 6173 ALC292_FIXUP_TPT440, 6174 ALC283_FIXUP_HEADSET_MIC, 6175 ALC255_FIXUP_MIC_MUTE_LED, 6176 ALC282_FIXUP_ASPIRE_V5_PINS, 6177 ALC280_FIXUP_HP_GPIO4, 6178 ALC286_FIXUP_HP_GPIO_LED, 6179 ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, 6180 ALC280_FIXUP_HP_DOCK_PINS, 6181 ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, 6182 ALC280_FIXUP_HP_9480M, 6183 ALC288_FIXUP_DELL_HEADSET_MODE, 6184 ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, 6185 ALC288_FIXUP_DELL_XPS_13, 6186 ALC288_FIXUP_DISABLE_AAMIX, 6187 ALC292_FIXUP_DELL_E7X_AAMIX, 6188 ALC292_FIXUP_DELL_E7X, 6189 ALC292_FIXUP_DISABLE_AAMIX, 6190 ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, 6191 ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE, 6192 ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 6193 ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, 6194 ALC275_FIXUP_DELL_XPS, 6195 ALC293_FIXUP_LENOVO_SPK_NOISE, 6196 ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, 6197 ALC255_FIXUP_DELL_SPK_NOISE, 6198 ALC225_FIXUP_DISABLE_MIC_VREF, 6199 ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 6200 ALC295_FIXUP_DISABLE_DAC3, 6201 ALC285_FIXUP_SPEAKER2_TO_DAC1, 6202 ALC280_FIXUP_HP_HEADSET_MIC, 6203 ALC221_FIXUP_HP_FRONT_MIC, 6204 ALC292_FIXUP_TPT460, 6205 ALC298_FIXUP_SPK_VOLUME, 6206 ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, 6207 ALC269_FIXUP_ATIV_BOOK_8, 6208 ALC221_FIXUP_HP_MIC_NO_PRESENCE, 6209 ALC256_FIXUP_ASUS_HEADSET_MODE, 6210 ALC256_FIXUP_ASUS_MIC, 6211 ALC256_FIXUP_ASUS_AIO_GPIO2, 6212 ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, 6213 ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, 6214 ALC233_FIXUP_LENOVO_MULTI_CODECS, 6215 ALC233_FIXUP_ACER_HEADSET_MIC, 6216 ALC294_FIXUP_LENOVO_MIC_LOCATION, 6217 ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, 6218 ALC225_FIXUP_S3_POP_NOISE, 6219 ALC700_FIXUP_INTEL_REFERENCE, 6220 ALC274_FIXUP_DELL_BIND_DACS, 6221 ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, 6222 ALC298_FIXUP_TPT470_DOCK_FIX, 6223 ALC298_FIXUP_TPT470_DOCK, 6224 ALC255_FIXUP_DUMMY_LINEOUT_VERB, 6225 ALC255_FIXUP_DELL_HEADSET_MIC, 6226 ALC256_FIXUP_HUAWEI_MACH_WX9_PINS, 6227 ALC298_FIXUP_HUAWEI_MBX_STEREO, 6228 ALC295_FIXUP_HP_X360, 6229 ALC221_FIXUP_HP_HEADSET_MIC, 6230 ALC285_FIXUP_LENOVO_HEADPHONE_NOISE, 6231 ALC295_FIXUP_HP_AUTO_MUTE, 6232 ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE, 6233 ALC294_FIXUP_ASUS_MIC, 6234 ALC294_FIXUP_ASUS_HEADSET_MIC, 6235 ALC294_FIXUP_ASUS_SPK, 6236 ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE, 6237 ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE, 6238 ALC255_FIXUP_ACER_HEADSET_MIC, 6239 ALC295_FIXUP_CHROME_BOOK, 6240 ALC225_FIXUP_HEADSET_JACK, 6241 ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE, 6242 ALC225_FIXUP_WYSE_AUTO_MUTE, 6243 ALC225_FIXUP_WYSE_DISABLE_MIC_VREF, 6244 ALC286_FIXUP_ACER_AIO_HEADSET_MIC, 6245 ALC256_FIXUP_ASUS_HEADSET_MIC, 6246 ALC256_FIXUP_ASUS_MIC_NO_PRESENCE, 6247 ALC299_FIXUP_PREDATOR_SPK, 6248 ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, 6249 ALC289_FIXUP_DELL_SPK2, 6250 ALC289_FIXUP_DUAL_SPK, 6251 ALC294_FIXUP_SPK2_TO_DAC1, 6252 ALC294_FIXUP_ASUS_DUAL_SPK, 6253 ALC285_FIXUP_THINKPAD_X1_GEN7, 6254 ALC285_FIXUP_THINKPAD_HEADSET_JACK, 6255 ALC294_FIXUP_ASUS_HPE, 6256 ALC294_FIXUP_ASUS_COEF_1B, 6257 ALC294_FIXUP_ASUS_GX502_HP, 6258 ALC294_FIXUP_ASUS_GX502_PINS, 6259 ALC294_FIXUP_ASUS_GX502_VERBS, 6260 ALC285_FIXUP_HP_GPIO_LED, 6261 ALC285_FIXUP_HP_MUTE_LED, 6262 ALC236_FIXUP_HP_MUTE_LED, 6263 ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, 6264 ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, 6265 ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS, 6266 ALC269VC_FIXUP_ACER_HEADSET_MIC, 6267 ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE, 6268 ALC289_FIXUP_ASUS_GA401, 6269 ALC289_FIXUP_ASUS_GA502, 6270 ALC256_FIXUP_ACER_MIC_NO_PRESENCE, 6271 ALC285_FIXUP_HP_GPIO_AMP_INIT, 6272 ALC269_FIXUP_CZC_B20, 6273 ALC269_FIXUP_CZC_TMI, 6274 ALC269_FIXUP_CZC_L101, 6275 ALC269_FIXUP_LEMOTE_A1802, 6276 ALC269_FIXUP_LEMOTE_A190X, 6277 ALC256_FIXUP_INTEL_NUC8_RUGGED, 6278 ALC255_FIXUP_XIAOMI_HEADSET_MIC, 6279 ALC274_FIXUP_HP_MIC, 6280 }; 6281 6282 static const struct hda_fixup alc269_fixups[] = { 6283 [ALC269_FIXUP_GPIO2] = { 6284 .type = HDA_FIXUP_FUNC, 6285 .v.func = alc_fixup_gpio2, 6286 }, 6287 [ALC269_FIXUP_SONY_VAIO] = { 6288 .type = HDA_FIXUP_PINCTLS, 6289 .v.pins = (const struct hda_pintbl[]) { 6290 {0x19, PIN_VREFGRD}, 6291 {} 6292 } 6293 }, 6294 [ALC275_FIXUP_SONY_VAIO_GPIO2] = { 6295 .type = HDA_FIXUP_FUNC, 6296 .v.func = alc275_fixup_gpio4_off, 6297 .chained = true, 6298 .chain_id = ALC269_FIXUP_SONY_VAIO 6299 }, 6300 [ALC269_FIXUP_DELL_M101Z] = { 6301 .type = HDA_FIXUP_VERBS, 6302 .v.verbs = (const struct hda_verb[]) { 6303 /* Enables internal speaker */ 6304 {0x20, AC_VERB_SET_COEF_INDEX, 13}, 6305 {0x20, AC_VERB_SET_PROC_COEF, 0x4040}, 6306 {} 6307 } 6308 }, 6309 [ALC269_FIXUP_SKU_IGNORE] = { 6310 .type = HDA_FIXUP_FUNC, 6311 .v.func = alc_fixup_sku_ignore, 6312 }, 6313 [ALC269_FIXUP_ASUS_G73JW] = { 6314 .type = HDA_FIXUP_PINS, 6315 .v.pins = (const struct hda_pintbl[]) { 6316 { 0x17, 0x99130111 }, /* subwoofer */ 6317 { } 6318 } 6319 }, 6320 [ALC269_FIXUP_LENOVO_EAPD] = { 6321 .type = HDA_FIXUP_VERBS, 6322 .v.verbs = (const struct hda_verb[]) { 6323 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0}, 6324 {} 6325 } 6326 }, 6327 [ALC275_FIXUP_SONY_HWEQ] = { 6328 .type = HDA_FIXUP_FUNC, 6329 .v.func = alc269_fixup_hweq, 6330 .chained = true, 6331 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2 6332 }, 6333 [ALC275_FIXUP_SONY_DISABLE_AAMIX] = { 6334 .type = HDA_FIXUP_FUNC, 6335 .v.func = alc_fixup_disable_aamix, 6336 .chained = true, 6337 .chain_id = ALC269_FIXUP_SONY_VAIO 6338 }, 6339 [ALC271_FIXUP_DMIC] = { 6340 .type = HDA_FIXUP_FUNC, 6341 .v.func = alc271_fixup_dmic, 6342 }, 6343 [ALC269_FIXUP_PCM_44K] = { 6344 .type = HDA_FIXUP_FUNC, 6345 .v.func = alc269_fixup_pcm_44k, 6346 .chained = true, 6347 .chain_id = ALC269_FIXUP_QUANTA_MUTE 6348 }, 6349 [ALC269_FIXUP_STEREO_DMIC] = { 6350 .type = HDA_FIXUP_FUNC, 6351 .v.func = alc269_fixup_stereo_dmic, 6352 }, 6353 [ALC269_FIXUP_HEADSET_MIC] = { 6354 .type = HDA_FIXUP_FUNC, 6355 .v.func = alc269_fixup_headset_mic, 6356 }, 6357 [ALC269_FIXUP_QUANTA_MUTE] = { 6358 .type = HDA_FIXUP_FUNC, 6359 .v.func = alc269_fixup_quanta_mute, 6360 }, 6361 [ALC269_FIXUP_LIFEBOOK] = { 6362 .type = HDA_FIXUP_PINS, 6363 .v.pins = (const struct hda_pintbl[]) { 6364 { 0x1a, 0x2101103f }, /* dock line-out */ 6365 { 0x1b, 0x23a11040 }, /* dock mic-in */ 6366 { } 6367 }, 6368 .chained = true, 6369 .chain_id = ALC269_FIXUP_QUANTA_MUTE 6370 }, 6371 [ALC269_FIXUP_LIFEBOOK_EXTMIC] = { 6372 .type = HDA_FIXUP_PINS, 6373 .v.pins = (const struct hda_pintbl[]) { 6374 { 0x19, 0x01a1903c }, /* headset mic, with jack detect */ 6375 { } 6376 }, 6377 }, 6378 [ALC269_FIXUP_LIFEBOOK_HP_PIN] = { 6379 .type = HDA_FIXUP_PINS, 6380 .v.pins = (const struct hda_pintbl[]) { 6381 { 0x21, 0x0221102f }, /* HP out */ 6382 { } 6383 }, 6384 }, 6385 [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = { 6386 .type = HDA_FIXUP_FUNC, 6387 .v.func = alc269_fixup_pincfg_no_hp_to_lineout, 6388 }, 6389 [ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = { 6390 .type = HDA_FIXUP_FUNC, 6391 .v.func = alc269_fixup_pincfg_U7x7_headset_mic, 6392 }, 6393 [ALC269_FIXUP_AMIC] = { 6394 .type = HDA_FIXUP_PINS, 6395 .v.pins = (const struct hda_pintbl[]) { 6396 { 0x14, 0x99130110 }, /* speaker */ 6397 { 0x15, 0x0121401f }, /* HP out */ 6398 { 0x18, 0x01a19c20 }, /* mic */ 6399 { 0x19, 0x99a3092f }, /* int-mic */ 6400 { } 6401 }, 6402 }, 6403 [ALC269_FIXUP_DMIC] = { 6404 .type = HDA_FIXUP_PINS, 6405 .v.pins = (const struct hda_pintbl[]) { 6406 { 0x12, 0x99a3092f }, /* int-mic */ 6407 { 0x14, 0x99130110 }, /* speaker */ 6408 { 0x15, 0x0121401f }, /* HP out */ 6409 { 0x18, 0x01a19c20 }, /* mic */ 6410 { } 6411 }, 6412 }, 6413 [ALC269VB_FIXUP_AMIC] = { 6414 .type = HDA_FIXUP_PINS, 6415 .v.pins = (const struct hda_pintbl[]) { 6416 { 0x14, 0x99130110 }, /* speaker */ 6417 { 0x18, 0x01a19c20 }, /* mic */ 6418 { 0x19, 0x99a3092f }, /* int-mic */ 6419 { 0x21, 0x0121401f }, /* HP out */ 6420 { } 6421 }, 6422 }, 6423 [ALC269VB_FIXUP_DMIC] = { 6424 .type = HDA_FIXUP_PINS, 6425 .v.pins = (const struct hda_pintbl[]) { 6426 { 0x12, 0x99a3092f }, /* int-mic */ 6427 { 0x14, 0x99130110 }, /* speaker */ 6428 { 0x18, 0x01a19c20 }, /* mic */ 6429 { 0x21, 0x0121401f }, /* HP out */ 6430 { } 6431 }, 6432 }, 6433 [ALC269_FIXUP_HP_MUTE_LED] = { 6434 .type = HDA_FIXUP_FUNC, 6435 .v.func = alc269_fixup_hp_mute_led, 6436 }, 6437 [ALC269_FIXUP_HP_MUTE_LED_MIC1] = { 6438 .type = HDA_FIXUP_FUNC, 6439 .v.func = alc269_fixup_hp_mute_led_mic1, 6440 }, 6441 [ALC269_FIXUP_HP_MUTE_LED_MIC2] = { 6442 .type = HDA_FIXUP_FUNC, 6443 .v.func = alc269_fixup_hp_mute_led_mic2, 6444 }, 6445 [ALC269_FIXUP_HP_MUTE_LED_MIC3] = { 6446 .type = HDA_FIXUP_FUNC, 6447 .v.func = alc269_fixup_hp_mute_led_mic3, 6448 .chained = true, 6449 .chain_id = ALC295_FIXUP_HP_AUTO_MUTE 6450 }, 6451 [ALC269_FIXUP_HP_GPIO_LED] = { 6452 .type = HDA_FIXUP_FUNC, 6453 .v.func = alc269_fixup_hp_gpio_led, 6454 }, 6455 [ALC269_FIXUP_HP_GPIO_MIC1_LED] = { 6456 .type = HDA_FIXUP_FUNC, 6457 .v.func = alc269_fixup_hp_gpio_mic1_led, 6458 }, 6459 [ALC269_FIXUP_HP_LINE1_MIC1_LED] = { 6460 .type = HDA_FIXUP_FUNC, 6461 .v.func = alc269_fixup_hp_line1_mic1_led, 6462 }, 6463 [ALC269_FIXUP_INV_DMIC] = { 6464 .type = HDA_FIXUP_FUNC, 6465 .v.func = alc_fixup_inv_dmic, 6466 }, 6467 [ALC269_FIXUP_NO_SHUTUP] = { 6468 .type = HDA_FIXUP_FUNC, 6469 .v.func = alc_fixup_no_shutup, 6470 }, 6471 [ALC269_FIXUP_LENOVO_DOCK] = { 6472 .type = HDA_FIXUP_PINS, 6473 .v.pins = (const struct hda_pintbl[]) { 6474 { 0x19, 0x23a11040 }, /* dock mic */ 6475 { 0x1b, 0x2121103f }, /* dock headphone */ 6476 { } 6477 }, 6478 .chained = true, 6479 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT 6480 }, 6481 [ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST] = { 6482 .type = HDA_FIXUP_FUNC, 6483 .v.func = alc269_fixup_limit_int_mic_boost, 6484 .chained = true, 6485 .chain_id = ALC269_FIXUP_LENOVO_DOCK, 6486 }, 6487 [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = { 6488 .type = HDA_FIXUP_FUNC, 6489 .v.func = alc269_fixup_pincfg_no_hp_to_lineout, 6490 .chained = true, 6491 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 6492 }, 6493 [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = { 6494 .type = HDA_FIXUP_PINS, 6495 .v.pins = (const struct hda_pintbl[]) { 6496 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 6497 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 6498 { } 6499 }, 6500 .chained = true, 6501 .chain_id = ALC269_FIXUP_HEADSET_MODE 6502 }, 6503 [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = { 6504 .type = HDA_FIXUP_PINS, 6505 .v.pins = (const struct hda_pintbl[]) { 6506 { 0x16, 0x21014020 }, /* dock line out */ 6507 { 0x19, 0x21a19030 }, /* dock mic */ 6508 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 6509 { } 6510 }, 6511 .chained = true, 6512 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 6513 }, 6514 [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = { 6515 .type = HDA_FIXUP_PINS, 6516 .v.pins = (const struct hda_pintbl[]) { 6517 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 6518 { } 6519 }, 6520 .chained = true, 6521 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 6522 }, 6523 [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = { 6524 .type = HDA_FIXUP_PINS, 6525 .v.pins = (const struct hda_pintbl[]) { 6526 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 6527 { 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 6528 { } 6529 }, 6530 .chained = true, 6531 .chain_id = ALC269_FIXUP_HEADSET_MODE 6532 }, 6533 [ALC269_FIXUP_HEADSET_MODE] = { 6534 .type = HDA_FIXUP_FUNC, 6535 .v.func = alc_fixup_headset_mode, 6536 .chained = true, 6537 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 6538 }, 6539 [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = { 6540 .type = HDA_FIXUP_FUNC, 6541 .v.func = alc_fixup_headset_mode_no_hp_mic, 6542 }, 6543 [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = { 6544 .type = HDA_FIXUP_PINS, 6545 .v.pins = (const struct hda_pintbl[]) { 6546 { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */ 6547 { } 6548 }, 6549 .chained = true, 6550 .chain_id = ALC269_FIXUP_HEADSET_MODE, 6551 }, 6552 [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = { 6553 .type = HDA_FIXUP_PINS, 6554 .v.pins = (const struct hda_pintbl[]) { 6555 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 6556 { } 6557 }, 6558 .chained = true, 6559 .chain_id = ALC269_FIXUP_HEADSET_MIC 6560 }, 6561 [ALC256_FIXUP_HUAWEI_MACH_WX9_PINS] = { 6562 .type = HDA_FIXUP_PINS, 6563 .v.pins = (const struct hda_pintbl[]) { 6564 {0x12, 0x90a60130}, 6565 {0x13, 0x40000000}, 6566 {0x14, 0x90170110}, 6567 {0x18, 0x411111f0}, 6568 {0x19, 0x04a11040}, 6569 {0x1a, 0x411111f0}, 6570 {0x1b, 0x90170112}, 6571 {0x1d, 0x40759a05}, 6572 {0x1e, 0x411111f0}, 6573 {0x21, 0x04211020}, 6574 { } 6575 }, 6576 .chained = true, 6577 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 6578 }, 6579 [ALC298_FIXUP_HUAWEI_MBX_STEREO] = { 6580 .type = HDA_FIXUP_FUNC, 6581 .v.func = alc298_fixup_huawei_mbx_stereo, 6582 .chained = true, 6583 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 6584 }, 6585 [ALC269_FIXUP_ASUS_X101_FUNC] = { 6586 .type = HDA_FIXUP_FUNC, 6587 .v.func = alc269_fixup_x101_headset_mic, 6588 }, 6589 [ALC269_FIXUP_ASUS_X101_VERB] = { 6590 .type = HDA_FIXUP_VERBS, 6591 .v.verbs = (const struct hda_verb[]) { 6592 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 6593 {0x20, AC_VERB_SET_COEF_INDEX, 0x08}, 6594 {0x20, AC_VERB_SET_PROC_COEF, 0x0310}, 6595 { } 6596 }, 6597 .chained = true, 6598 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC 6599 }, 6600 [ALC269_FIXUP_ASUS_X101] = { 6601 .type = HDA_FIXUP_PINS, 6602 .v.pins = (const struct hda_pintbl[]) { 6603 { 0x18, 0x04a1182c }, /* Headset mic */ 6604 { } 6605 }, 6606 .chained = true, 6607 .chain_id = ALC269_FIXUP_ASUS_X101_VERB 6608 }, 6609 [ALC271_FIXUP_AMIC_MIC2] = { 6610 .type = HDA_FIXUP_PINS, 6611 .v.pins = (const struct hda_pintbl[]) { 6612 { 0x14, 0x99130110 }, /* speaker */ 6613 { 0x19, 0x01a19c20 }, /* mic */ 6614 { 0x1b, 0x99a7012f }, /* int-mic */ 6615 { 0x21, 0x0121401f }, /* HP out */ 6616 { } 6617 }, 6618 }, 6619 [ALC271_FIXUP_HP_GATE_MIC_JACK] = { 6620 .type = HDA_FIXUP_FUNC, 6621 .v.func = alc271_hp_gate_mic_jack, 6622 .chained = true, 6623 .chain_id = ALC271_FIXUP_AMIC_MIC2, 6624 }, 6625 [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = { 6626 .type = HDA_FIXUP_FUNC, 6627 .v.func = alc269_fixup_limit_int_mic_boost, 6628 .chained = true, 6629 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK, 6630 }, 6631 [ALC269_FIXUP_ACER_AC700] = { 6632 .type = HDA_FIXUP_PINS, 6633 .v.pins = (const struct hda_pintbl[]) { 6634 { 0x12, 0x99a3092f }, /* int-mic */ 6635 { 0x14, 0x99130110 }, /* speaker */ 6636 { 0x18, 0x03a11c20 }, /* mic */ 6637 { 0x1e, 0x0346101e }, /* SPDIF1 */ 6638 { 0x21, 0x0321101f }, /* HP out */ 6639 { } 6640 }, 6641 .chained = true, 6642 .chain_id = ALC271_FIXUP_DMIC, 6643 }, 6644 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = { 6645 .type = HDA_FIXUP_FUNC, 6646 .v.func = alc269_fixup_limit_int_mic_boost, 6647 .chained = true, 6648 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 6649 }, 6650 [ALC269VB_FIXUP_ASUS_ZENBOOK] = { 6651 .type = HDA_FIXUP_FUNC, 6652 .v.func = alc269_fixup_limit_int_mic_boost, 6653 .chained = true, 6654 .chain_id = ALC269VB_FIXUP_DMIC, 6655 }, 6656 [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = { 6657 .type = HDA_FIXUP_VERBS, 6658 .v.verbs = (const struct hda_verb[]) { 6659 /* class-D output amp +5dB */ 6660 { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 }, 6661 { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 }, 6662 {} 6663 }, 6664 .chained = true, 6665 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK, 6666 }, 6667 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = { 6668 .type = HDA_FIXUP_FUNC, 6669 .v.func = alc269_fixup_limit_int_mic_boost, 6670 .chained = true, 6671 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1, 6672 }, 6673 [ALC269VB_FIXUP_ORDISSIMO_EVE2] = { 6674 .type = HDA_FIXUP_PINS, 6675 .v.pins = (const struct hda_pintbl[]) { 6676 { 0x12, 0x99a3092f }, /* int-mic */ 6677 { 0x18, 0x03a11d20 }, /* mic */ 6678 { 0x19, 0x411111f0 }, /* Unused bogus pin */ 6679 { } 6680 }, 6681 }, 6682 [ALC283_FIXUP_CHROME_BOOK] = { 6683 .type = HDA_FIXUP_FUNC, 6684 .v.func = alc283_fixup_chromebook, 6685 }, 6686 [ALC283_FIXUP_SENSE_COMBO_JACK] = { 6687 .type = HDA_FIXUP_FUNC, 6688 .v.func = alc283_fixup_sense_combo_jack, 6689 .chained = true, 6690 .chain_id = ALC283_FIXUP_CHROME_BOOK, 6691 }, 6692 [ALC282_FIXUP_ASUS_TX300] = { 6693 .type = HDA_FIXUP_FUNC, 6694 .v.func = alc282_fixup_asus_tx300, 6695 }, 6696 [ALC283_FIXUP_INT_MIC] = { 6697 .type = HDA_FIXUP_VERBS, 6698 .v.verbs = (const struct hda_verb[]) { 6699 {0x20, AC_VERB_SET_COEF_INDEX, 0x1a}, 6700 {0x20, AC_VERB_SET_PROC_COEF, 0x0011}, 6701 { } 6702 }, 6703 .chained = true, 6704 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST 6705 }, 6706 [ALC290_FIXUP_SUBWOOFER_HSJACK] = { 6707 .type = HDA_FIXUP_PINS, 6708 .v.pins = (const struct hda_pintbl[]) { 6709 { 0x17, 0x90170112 }, /* subwoofer */ 6710 { } 6711 }, 6712 .chained = true, 6713 .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, 6714 }, 6715 [ALC290_FIXUP_SUBWOOFER] = { 6716 .type = HDA_FIXUP_PINS, 6717 .v.pins = (const struct hda_pintbl[]) { 6718 { 0x17, 0x90170112 }, /* subwoofer */ 6719 { } 6720 }, 6721 .chained = true, 6722 .chain_id = ALC290_FIXUP_MONO_SPEAKERS, 6723 }, 6724 [ALC290_FIXUP_MONO_SPEAKERS] = { 6725 .type = HDA_FIXUP_FUNC, 6726 .v.func = alc290_fixup_mono_speakers, 6727 }, 6728 [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = { 6729 .type = HDA_FIXUP_FUNC, 6730 .v.func = alc290_fixup_mono_speakers, 6731 .chained = true, 6732 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, 6733 }, 6734 [ALC269_FIXUP_THINKPAD_ACPI] = { 6735 .type = HDA_FIXUP_FUNC, 6736 .v.func = alc_fixup_thinkpad_acpi, 6737 .chained = true, 6738 .chain_id = ALC269_FIXUP_SKU_IGNORE, 6739 }, 6740 [ALC269_FIXUP_DMIC_THINKPAD_ACPI] = { 6741 .type = HDA_FIXUP_FUNC, 6742 .v.func = alc_fixup_inv_dmic, 6743 .chained = true, 6744 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 6745 }, 6746 [ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = { 6747 .type = HDA_FIXUP_PINS, 6748 .v.pins = (const struct hda_pintbl[]) { 6749 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 6750 { } 6751 }, 6752 .chained = true, 6753 .chain_id = ALC255_FIXUP_HEADSET_MODE 6754 }, 6755 [ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = { 6756 .type = HDA_FIXUP_PINS, 6757 .v.pins = (const struct hda_pintbl[]) { 6758 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 6759 { } 6760 }, 6761 .chained = true, 6762 .chain_id = ALC255_FIXUP_HEADSET_MODE 6763 }, 6764 [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = { 6765 .type = HDA_FIXUP_PINS, 6766 .v.pins = (const struct hda_pintbl[]) { 6767 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 6768 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 6769 { } 6770 }, 6771 .chained = true, 6772 .chain_id = ALC255_FIXUP_HEADSET_MODE 6773 }, 6774 [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = { 6775 .type = HDA_FIXUP_PINS, 6776 .v.pins = (const struct hda_pintbl[]) { 6777 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 6778 { } 6779 }, 6780 .chained = true, 6781 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC 6782 }, 6783 [ALC255_FIXUP_HEADSET_MODE] = { 6784 .type = HDA_FIXUP_FUNC, 6785 .v.func = alc_fixup_headset_mode_alc255, 6786 .chained = true, 6787 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 6788 }, 6789 [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = { 6790 .type = HDA_FIXUP_FUNC, 6791 .v.func = alc_fixup_headset_mode_alc255_no_hp_mic, 6792 }, 6793 [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = { 6794 .type = HDA_FIXUP_PINS, 6795 .v.pins = (const struct hda_pintbl[]) { 6796 { 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 6797 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 6798 { } 6799 }, 6800 .chained = true, 6801 .chain_id = ALC269_FIXUP_HEADSET_MODE 6802 }, 6803 [ALC292_FIXUP_TPT440_DOCK] = { 6804 .type = HDA_FIXUP_FUNC, 6805 .v.func = alc_fixup_tpt440_dock, 6806 .chained = true, 6807 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST 6808 }, 6809 [ALC292_FIXUP_TPT440] = { 6810 .type = HDA_FIXUP_FUNC, 6811 .v.func = alc_fixup_disable_aamix, 6812 .chained = true, 6813 .chain_id = ALC292_FIXUP_TPT440_DOCK, 6814 }, 6815 [ALC283_FIXUP_HEADSET_MIC] = { 6816 .type = HDA_FIXUP_PINS, 6817 .v.pins = (const struct hda_pintbl[]) { 6818 { 0x19, 0x04a110f0 }, 6819 { }, 6820 }, 6821 }, 6822 [ALC255_FIXUP_MIC_MUTE_LED] = { 6823 .type = HDA_FIXUP_FUNC, 6824 .v.func = alc_fixup_micmute_led, 6825 }, 6826 [ALC282_FIXUP_ASPIRE_V5_PINS] = { 6827 .type = HDA_FIXUP_PINS, 6828 .v.pins = (const struct hda_pintbl[]) { 6829 { 0x12, 0x90a60130 }, 6830 { 0x14, 0x90170110 }, 6831 { 0x17, 0x40000008 }, 6832 { 0x18, 0x411111f0 }, 6833 { 0x19, 0x01a1913c }, 6834 { 0x1a, 0x411111f0 }, 6835 { 0x1b, 0x411111f0 }, 6836 { 0x1d, 0x40f89b2d }, 6837 { 0x1e, 0x411111f0 }, 6838 { 0x21, 0x0321101f }, 6839 { }, 6840 }, 6841 }, 6842 [ALC280_FIXUP_HP_GPIO4] = { 6843 .type = HDA_FIXUP_FUNC, 6844 .v.func = alc280_fixup_hp_gpio4, 6845 }, 6846 [ALC286_FIXUP_HP_GPIO_LED] = { 6847 .type = HDA_FIXUP_FUNC, 6848 .v.func = alc286_fixup_hp_gpio_led, 6849 }, 6850 [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = { 6851 .type = HDA_FIXUP_FUNC, 6852 .v.func = alc280_fixup_hp_gpio2_mic_hotkey, 6853 }, 6854 [ALC280_FIXUP_HP_DOCK_PINS] = { 6855 .type = HDA_FIXUP_PINS, 6856 .v.pins = (const struct hda_pintbl[]) { 6857 { 0x1b, 0x21011020 }, /* line-out */ 6858 { 0x1a, 0x01a1903c }, /* headset mic */ 6859 { 0x18, 0x2181103f }, /* line-in */ 6860 { }, 6861 }, 6862 .chained = true, 6863 .chain_id = ALC280_FIXUP_HP_GPIO4 6864 }, 6865 [ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = { 6866 .type = HDA_FIXUP_PINS, 6867 .v.pins = (const struct hda_pintbl[]) { 6868 { 0x1b, 0x21011020 }, /* line-out */ 6869 { 0x18, 0x2181103f }, /* line-in */ 6870 { }, 6871 }, 6872 .chained = true, 6873 .chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED 6874 }, 6875 [ALC280_FIXUP_HP_9480M] = { 6876 .type = HDA_FIXUP_FUNC, 6877 .v.func = alc280_fixup_hp_9480m, 6878 }, 6879 [ALC288_FIXUP_DELL_HEADSET_MODE] = { 6880 .type = HDA_FIXUP_FUNC, 6881 .v.func = alc_fixup_headset_mode_dell_alc288, 6882 .chained = true, 6883 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 6884 }, 6885 [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = { 6886 .type = HDA_FIXUP_PINS, 6887 .v.pins = (const struct hda_pintbl[]) { 6888 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 6889 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 6890 { } 6891 }, 6892 .chained = true, 6893 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE 6894 }, 6895 [ALC288_FIXUP_DISABLE_AAMIX] = { 6896 .type = HDA_FIXUP_FUNC, 6897 .v.func = alc_fixup_disable_aamix, 6898 .chained = true, 6899 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE 6900 }, 6901 [ALC288_FIXUP_DELL_XPS_13] = { 6902 .type = HDA_FIXUP_FUNC, 6903 .v.func = alc_fixup_dell_xps13, 6904 .chained = true, 6905 .chain_id = ALC288_FIXUP_DISABLE_AAMIX 6906 }, 6907 [ALC292_FIXUP_DISABLE_AAMIX] = { 6908 .type = HDA_FIXUP_FUNC, 6909 .v.func = alc_fixup_disable_aamix, 6910 .chained = true, 6911 .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE 6912 }, 6913 [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = { 6914 .type = HDA_FIXUP_FUNC, 6915 .v.func = alc_fixup_disable_aamix, 6916 .chained = true, 6917 .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE 6918 }, 6919 [ALC292_FIXUP_DELL_E7X_AAMIX] = { 6920 .type = HDA_FIXUP_FUNC, 6921 .v.func = alc_fixup_dell_xps13, 6922 .chained = true, 6923 .chain_id = ALC292_FIXUP_DISABLE_AAMIX 6924 }, 6925 [ALC292_FIXUP_DELL_E7X] = { 6926 .type = HDA_FIXUP_FUNC, 6927 .v.func = alc_fixup_micmute_led, 6928 /* micmute fixup must be applied at last */ 6929 .chained_before = true, 6930 .chain_id = ALC292_FIXUP_DELL_E7X_AAMIX, 6931 }, 6932 [ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE] = { 6933 .type = HDA_FIXUP_PINS, 6934 .v.pins = (const struct hda_pintbl[]) { 6935 { 0x18, 0x01a1913c }, /* headset mic w/o jack detect */ 6936 { } 6937 }, 6938 .chained_before = true, 6939 .chain_id = ALC269_FIXUP_HEADSET_MODE, 6940 }, 6941 [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = { 6942 .type = HDA_FIXUP_PINS, 6943 .v.pins = (const struct hda_pintbl[]) { 6944 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 6945 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 6946 { } 6947 }, 6948 .chained = true, 6949 .chain_id = ALC269_FIXUP_HEADSET_MODE 6950 }, 6951 [ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = { 6952 .type = HDA_FIXUP_PINS, 6953 .v.pins = (const struct hda_pintbl[]) { 6954 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 6955 { } 6956 }, 6957 .chained = true, 6958 .chain_id = ALC269_FIXUP_HEADSET_MODE 6959 }, 6960 [ALC275_FIXUP_DELL_XPS] = { 6961 .type = HDA_FIXUP_VERBS, 6962 .v.verbs = (const struct hda_verb[]) { 6963 /* Enables internal speaker */ 6964 {0x20, AC_VERB_SET_COEF_INDEX, 0x1f}, 6965 {0x20, AC_VERB_SET_PROC_COEF, 0x00c0}, 6966 {0x20, AC_VERB_SET_COEF_INDEX, 0x30}, 6967 {0x20, AC_VERB_SET_PROC_COEF, 0x00b1}, 6968 {} 6969 } 6970 }, 6971 [ALC293_FIXUP_LENOVO_SPK_NOISE] = { 6972 .type = HDA_FIXUP_FUNC, 6973 .v.func = alc_fixup_disable_aamix, 6974 .chained = true, 6975 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 6976 }, 6977 [ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = { 6978 .type = HDA_FIXUP_FUNC, 6979 .v.func = alc233_fixup_lenovo_line2_mic_hotkey, 6980 }, 6981 [ALC255_FIXUP_DELL_SPK_NOISE] = { 6982 .type = HDA_FIXUP_FUNC, 6983 .v.func = alc_fixup_disable_aamix, 6984 .chained = true, 6985 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE 6986 }, 6987 [ALC225_FIXUP_DISABLE_MIC_VREF] = { 6988 .type = HDA_FIXUP_FUNC, 6989 .v.func = alc_fixup_disable_mic_vref, 6990 .chained = true, 6991 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE 6992 }, 6993 [ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = { 6994 .type = HDA_FIXUP_VERBS, 6995 .v.verbs = (const struct hda_verb[]) { 6996 /* Disable pass-through path for FRONT 14h */ 6997 { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 }, 6998 { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 }, 6999 {} 7000 }, 7001 .chained = true, 7002 .chain_id = ALC225_FIXUP_DISABLE_MIC_VREF 7003 }, 7004 [ALC280_FIXUP_HP_HEADSET_MIC] = { 7005 .type = HDA_FIXUP_FUNC, 7006 .v.func = alc_fixup_disable_aamix, 7007 .chained = true, 7008 .chain_id = ALC269_FIXUP_HEADSET_MIC, 7009 }, 7010 [ALC221_FIXUP_HP_FRONT_MIC] = { 7011 .type = HDA_FIXUP_PINS, 7012 .v.pins = (const struct hda_pintbl[]) { 7013 { 0x19, 0x02a19020 }, /* Front Mic */ 7014 { } 7015 }, 7016 }, 7017 [ALC292_FIXUP_TPT460] = { 7018 .type = HDA_FIXUP_FUNC, 7019 .v.func = alc_fixup_tpt440_dock, 7020 .chained = true, 7021 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE, 7022 }, 7023 [ALC298_FIXUP_SPK_VOLUME] = { 7024 .type = HDA_FIXUP_FUNC, 7025 .v.func = alc298_fixup_speaker_volume, 7026 .chained = true, 7027 .chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, 7028 }, 7029 [ALC295_FIXUP_DISABLE_DAC3] = { 7030 .type = HDA_FIXUP_FUNC, 7031 .v.func = alc295_fixup_disable_dac3, 7032 }, 7033 [ALC285_FIXUP_SPEAKER2_TO_DAC1] = { 7034 .type = HDA_FIXUP_FUNC, 7035 .v.func = alc285_fixup_speaker2_to_dac1, 7036 .chained = true, 7037 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 7038 }, 7039 [ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = { 7040 .type = HDA_FIXUP_PINS, 7041 .v.pins = (const struct hda_pintbl[]) { 7042 { 0x1b, 0x90170151 }, 7043 { } 7044 }, 7045 .chained = true, 7046 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE 7047 }, 7048 [ALC269_FIXUP_ATIV_BOOK_8] = { 7049 .type = HDA_FIXUP_FUNC, 7050 .v.func = alc_fixup_auto_mute_via_amp, 7051 .chained = true, 7052 .chain_id = ALC269_FIXUP_NO_SHUTUP 7053 }, 7054 [ALC221_FIXUP_HP_MIC_NO_PRESENCE] = { 7055 .type = HDA_FIXUP_PINS, 7056 .v.pins = (const struct hda_pintbl[]) { 7057 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7058 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 7059 { } 7060 }, 7061 .chained = true, 7062 .chain_id = ALC269_FIXUP_HEADSET_MODE 7063 }, 7064 [ALC256_FIXUP_ASUS_HEADSET_MODE] = { 7065 .type = HDA_FIXUP_FUNC, 7066 .v.func = alc_fixup_headset_mode, 7067 }, 7068 [ALC256_FIXUP_ASUS_MIC] = { 7069 .type = HDA_FIXUP_PINS, 7070 .v.pins = (const struct hda_pintbl[]) { 7071 { 0x13, 0x90a60160 }, /* use as internal mic */ 7072 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */ 7073 { } 7074 }, 7075 .chained = true, 7076 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 7077 }, 7078 [ALC256_FIXUP_ASUS_AIO_GPIO2] = { 7079 .type = HDA_FIXUP_FUNC, 7080 /* Set up GPIO2 for the speaker amp */ 7081 .v.func = alc_fixup_gpio4, 7082 }, 7083 [ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = { 7084 .type = HDA_FIXUP_PINS, 7085 .v.pins = (const struct hda_pintbl[]) { 7086 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7087 { } 7088 }, 7089 .chained = true, 7090 .chain_id = ALC269_FIXUP_HEADSET_MIC 7091 }, 7092 [ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = { 7093 .type = HDA_FIXUP_VERBS, 7094 .v.verbs = (const struct hda_verb[]) { 7095 /* Enables internal speaker */ 7096 {0x20, AC_VERB_SET_COEF_INDEX, 0x40}, 7097 {0x20, AC_VERB_SET_PROC_COEF, 0x8800}, 7098 {} 7099 }, 7100 .chained = true, 7101 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE 7102 }, 7103 [ALC233_FIXUP_LENOVO_MULTI_CODECS] = { 7104 .type = HDA_FIXUP_FUNC, 7105 .v.func = alc233_alc662_fixup_lenovo_dual_codecs, 7106 .chained = true, 7107 .chain_id = ALC269_FIXUP_GPIO2 7108 }, 7109 [ALC233_FIXUP_ACER_HEADSET_MIC] = { 7110 .type = HDA_FIXUP_VERBS, 7111 .v.verbs = (const struct hda_verb[]) { 7112 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 }, 7113 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 }, 7114 { } 7115 }, 7116 .chained = true, 7117 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE 7118 }, 7119 [ALC294_FIXUP_LENOVO_MIC_LOCATION] = { 7120 .type = HDA_FIXUP_PINS, 7121 .v.pins = (const struct hda_pintbl[]) { 7122 /* Change the mic location from front to right, otherwise there are 7123 two front mics with the same name, pulseaudio can't handle them. 7124 This is just a temporary workaround, after applying this fixup, 7125 there will be one "Front Mic" and one "Mic" in this machine. 7126 */ 7127 { 0x1a, 0x04a19040 }, 7128 { } 7129 }, 7130 }, 7131 [ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = { 7132 .type = HDA_FIXUP_PINS, 7133 .v.pins = (const struct hda_pintbl[]) { 7134 { 0x16, 0x0101102f }, /* Rear Headset HP */ 7135 { 0x19, 0x02a1913c }, /* use as Front headset mic, without its own jack detect */ 7136 { 0x1a, 0x01a19030 }, /* Rear Headset MIC */ 7137 { 0x1b, 0x02011020 }, 7138 { } 7139 }, 7140 .chained = true, 7141 .chain_id = ALC225_FIXUP_S3_POP_NOISE 7142 }, 7143 [ALC225_FIXUP_S3_POP_NOISE] = { 7144 .type = HDA_FIXUP_FUNC, 7145 .v.func = alc225_fixup_s3_pop_noise, 7146 .chained = true, 7147 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 7148 }, 7149 [ALC700_FIXUP_INTEL_REFERENCE] = { 7150 .type = HDA_FIXUP_VERBS, 7151 .v.verbs = (const struct hda_verb[]) { 7152 /* Enables internal speaker */ 7153 {0x20, AC_VERB_SET_COEF_INDEX, 0x45}, 7154 {0x20, AC_VERB_SET_PROC_COEF, 0x5289}, 7155 {0x20, AC_VERB_SET_COEF_INDEX, 0x4A}, 7156 {0x20, AC_VERB_SET_PROC_COEF, 0x001b}, 7157 {0x58, AC_VERB_SET_COEF_INDEX, 0x00}, 7158 {0x58, AC_VERB_SET_PROC_COEF, 0x3888}, 7159 {0x20, AC_VERB_SET_COEF_INDEX, 0x6f}, 7160 {0x20, AC_VERB_SET_PROC_COEF, 0x2c0b}, 7161 {} 7162 } 7163 }, 7164 [ALC274_FIXUP_DELL_BIND_DACS] = { 7165 .type = HDA_FIXUP_FUNC, 7166 .v.func = alc274_fixup_bind_dacs, 7167 .chained = true, 7168 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE 7169 }, 7170 [ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = { 7171 .type = HDA_FIXUP_PINS, 7172 .v.pins = (const struct hda_pintbl[]) { 7173 { 0x1b, 0x0401102f }, 7174 { } 7175 }, 7176 .chained = true, 7177 .chain_id = ALC274_FIXUP_DELL_BIND_DACS 7178 }, 7179 [ALC298_FIXUP_TPT470_DOCK_FIX] = { 7180 .type = HDA_FIXUP_FUNC, 7181 .v.func = alc_fixup_tpt470_dock, 7182 .chained = true, 7183 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE 7184 }, 7185 [ALC298_FIXUP_TPT470_DOCK] = { 7186 .type = HDA_FIXUP_FUNC, 7187 .v.func = alc_fixup_tpt470_dacs, 7188 .chained = true, 7189 .chain_id = ALC298_FIXUP_TPT470_DOCK_FIX 7190 }, 7191 [ALC255_FIXUP_DUMMY_LINEOUT_VERB] = { 7192 .type = HDA_FIXUP_PINS, 7193 .v.pins = (const struct hda_pintbl[]) { 7194 { 0x14, 0x0201101f }, 7195 { } 7196 }, 7197 .chained = true, 7198 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE 7199 }, 7200 [ALC255_FIXUP_DELL_HEADSET_MIC] = { 7201 .type = HDA_FIXUP_PINS, 7202 .v.pins = (const struct hda_pintbl[]) { 7203 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7204 { } 7205 }, 7206 .chained = true, 7207 .chain_id = ALC269_FIXUP_HEADSET_MIC 7208 }, 7209 [ALC295_FIXUP_HP_X360] = { 7210 .type = HDA_FIXUP_FUNC, 7211 .v.func = alc295_fixup_hp_top_speakers, 7212 .chained = true, 7213 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3 7214 }, 7215 [ALC221_FIXUP_HP_HEADSET_MIC] = { 7216 .type = HDA_FIXUP_PINS, 7217 .v.pins = (const struct hda_pintbl[]) { 7218 { 0x19, 0x0181313f}, 7219 { } 7220 }, 7221 .chained = true, 7222 .chain_id = ALC269_FIXUP_HEADSET_MIC 7223 }, 7224 [ALC285_FIXUP_LENOVO_HEADPHONE_NOISE] = { 7225 .type = HDA_FIXUP_FUNC, 7226 .v.func = alc285_fixup_invalidate_dacs, 7227 .chained = true, 7228 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 7229 }, 7230 [ALC295_FIXUP_HP_AUTO_MUTE] = { 7231 .type = HDA_FIXUP_FUNC, 7232 .v.func = alc_fixup_auto_mute_via_amp, 7233 }, 7234 [ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE] = { 7235 .type = HDA_FIXUP_PINS, 7236 .v.pins = (const struct hda_pintbl[]) { 7237 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7238 { } 7239 }, 7240 .chained = true, 7241 .chain_id = ALC269_FIXUP_HEADSET_MIC 7242 }, 7243 [ALC294_FIXUP_ASUS_MIC] = { 7244 .type = HDA_FIXUP_PINS, 7245 .v.pins = (const struct hda_pintbl[]) { 7246 { 0x13, 0x90a60160 }, /* use as internal mic */ 7247 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */ 7248 { } 7249 }, 7250 .chained = true, 7251 .chain_id = ALC269_FIXUP_HEADSET_MIC 7252 }, 7253 [ALC294_FIXUP_ASUS_HEADSET_MIC] = { 7254 .type = HDA_FIXUP_PINS, 7255 .v.pins = (const struct hda_pintbl[]) { 7256 { 0x19, 0x01a1103c }, /* use as headset mic */ 7257 { } 7258 }, 7259 .chained = true, 7260 .chain_id = ALC269_FIXUP_HEADSET_MIC 7261 }, 7262 [ALC294_FIXUP_ASUS_SPK] = { 7263 .type = HDA_FIXUP_VERBS, 7264 .v.verbs = (const struct hda_verb[]) { 7265 /* Set EAPD high */ 7266 { 0x20, AC_VERB_SET_COEF_INDEX, 0x40 }, 7267 { 0x20, AC_VERB_SET_PROC_COEF, 0x8800 }, 7268 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f }, 7269 { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 }, 7270 { } 7271 }, 7272 .chained = true, 7273 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC 7274 }, 7275 [ALC295_FIXUP_CHROME_BOOK] = { 7276 .type = HDA_FIXUP_FUNC, 7277 .v.func = alc295_fixup_chromebook, 7278 .chained = true, 7279 .chain_id = ALC225_FIXUP_HEADSET_JACK 7280 }, 7281 [ALC225_FIXUP_HEADSET_JACK] = { 7282 .type = HDA_FIXUP_FUNC, 7283 .v.func = alc_fixup_headset_jack, 7284 }, 7285 [ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = { 7286 .type = HDA_FIXUP_PINS, 7287 .v.pins = (const struct hda_pintbl[]) { 7288 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7289 { } 7290 }, 7291 .chained = true, 7292 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 7293 }, 7294 [ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE] = { 7295 .type = HDA_FIXUP_VERBS, 7296 .v.verbs = (const struct hda_verb[]) { 7297 /* Disable PCBEEP-IN passthrough */ 7298 { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 }, 7299 { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 }, 7300 { } 7301 }, 7302 .chained = true, 7303 .chain_id = ALC285_FIXUP_LENOVO_HEADPHONE_NOISE 7304 }, 7305 [ALC255_FIXUP_ACER_HEADSET_MIC] = { 7306 .type = HDA_FIXUP_PINS, 7307 .v.pins = (const struct hda_pintbl[]) { 7308 { 0x19, 0x03a11130 }, 7309 { 0x1a, 0x90a60140 }, /* use as internal mic */ 7310 { } 7311 }, 7312 .chained = true, 7313 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC 7314 }, 7315 [ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE] = { 7316 .type = HDA_FIXUP_PINS, 7317 .v.pins = (const struct hda_pintbl[]) { 7318 { 0x16, 0x01011020 }, /* Rear Line out */ 7319 { 0x19, 0x01a1913c }, /* use as Front headset mic, without its own jack detect */ 7320 { } 7321 }, 7322 .chained = true, 7323 .chain_id = ALC225_FIXUP_WYSE_AUTO_MUTE 7324 }, 7325 [ALC225_FIXUP_WYSE_AUTO_MUTE] = { 7326 .type = HDA_FIXUP_FUNC, 7327 .v.func = alc_fixup_auto_mute_via_amp, 7328 .chained = true, 7329 .chain_id = ALC225_FIXUP_WYSE_DISABLE_MIC_VREF 7330 }, 7331 [ALC225_FIXUP_WYSE_DISABLE_MIC_VREF] = { 7332 .type = HDA_FIXUP_FUNC, 7333 .v.func = alc_fixup_disable_mic_vref, 7334 .chained = true, 7335 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 7336 }, 7337 [ALC286_FIXUP_ACER_AIO_HEADSET_MIC] = { 7338 .type = HDA_FIXUP_VERBS, 7339 .v.verbs = (const struct hda_verb[]) { 7340 { 0x20, AC_VERB_SET_COEF_INDEX, 0x4f }, 7341 { 0x20, AC_VERB_SET_PROC_COEF, 0x5029 }, 7342 { } 7343 }, 7344 .chained = true, 7345 .chain_id = ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE 7346 }, 7347 [ALC256_FIXUP_ASUS_HEADSET_MIC] = { 7348 .type = HDA_FIXUP_PINS, 7349 .v.pins = (const struct hda_pintbl[]) { 7350 { 0x19, 0x03a11020 }, /* headset mic with jack detect */ 7351 { } 7352 }, 7353 .chained = true, 7354 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 7355 }, 7356 [ALC256_FIXUP_ASUS_MIC_NO_PRESENCE] = { 7357 .type = HDA_FIXUP_PINS, 7358 .v.pins = (const struct hda_pintbl[]) { 7359 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */ 7360 { } 7361 }, 7362 .chained = true, 7363 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 7364 }, 7365 [ALC299_FIXUP_PREDATOR_SPK] = { 7366 .type = HDA_FIXUP_PINS, 7367 .v.pins = (const struct hda_pintbl[]) { 7368 { 0x21, 0x90170150 }, /* use as headset mic, without its own jack detect */ 7369 { } 7370 } 7371 }, 7372 [ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = { 7373 .type = HDA_FIXUP_PINS, 7374 .v.pins = (const struct hda_pintbl[]) { 7375 { 0x19, 0x04a11040 }, 7376 { 0x21, 0x04211020 }, 7377 { } 7378 }, 7379 .chained = true, 7380 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 7381 }, 7382 [ALC289_FIXUP_DELL_SPK2] = { 7383 .type = HDA_FIXUP_PINS, 7384 .v.pins = (const struct hda_pintbl[]) { 7385 { 0x17, 0x90170130 }, /* bass spk */ 7386 { } 7387 }, 7388 .chained = true, 7389 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE 7390 }, 7391 [ALC289_FIXUP_DUAL_SPK] = { 7392 .type = HDA_FIXUP_FUNC, 7393 .v.func = alc285_fixup_speaker2_to_dac1, 7394 .chained = true, 7395 .chain_id = ALC289_FIXUP_DELL_SPK2 7396 }, 7397 [ALC294_FIXUP_SPK2_TO_DAC1] = { 7398 .type = HDA_FIXUP_FUNC, 7399 .v.func = alc285_fixup_speaker2_to_dac1, 7400 .chained = true, 7401 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC 7402 }, 7403 [ALC294_FIXUP_ASUS_DUAL_SPK] = { 7404 .type = HDA_FIXUP_FUNC, 7405 /* The GPIO must be pulled to initialize the AMP */ 7406 .v.func = alc_fixup_gpio4, 7407 .chained = true, 7408 .chain_id = ALC294_FIXUP_SPK2_TO_DAC1 7409 }, 7410 [ALC285_FIXUP_THINKPAD_X1_GEN7] = { 7411 .type = HDA_FIXUP_FUNC, 7412 .v.func = alc285_fixup_thinkpad_x1_gen7, 7413 .chained = true, 7414 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 7415 }, 7416 [ALC285_FIXUP_THINKPAD_HEADSET_JACK] = { 7417 .type = HDA_FIXUP_FUNC, 7418 .v.func = alc_fixup_headset_jack, 7419 .chained = true, 7420 .chain_id = ALC285_FIXUP_THINKPAD_X1_GEN7 7421 }, 7422 [ALC294_FIXUP_ASUS_HPE] = { 7423 .type = HDA_FIXUP_VERBS, 7424 .v.verbs = (const struct hda_verb[]) { 7425 /* Set EAPD high */ 7426 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f }, 7427 { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 }, 7428 { } 7429 }, 7430 .chained = true, 7431 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC 7432 }, 7433 [ALC294_FIXUP_ASUS_GX502_PINS] = { 7434 .type = HDA_FIXUP_PINS, 7435 .v.pins = (const struct hda_pintbl[]) { 7436 { 0x19, 0x03a11050 }, /* front HP mic */ 7437 { 0x1a, 0x01a11830 }, /* rear external mic */ 7438 { 0x21, 0x03211020 }, /* front HP out */ 7439 { } 7440 }, 7441 .chained = true, 7442 .chain_id = ALC294_FIXUP_ASUS_GX502_VERBS 7443 }, 7444 [ALC294_FIXUP_ASUS_GX502_VERBS] = { 7445 .type = HDA_FIXUP_VERBS, 7446 .v.verbs = (const struct hda_verb[]) { 7447 /* set 0x15 to HP-OUT ctrl */ 7448 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 7449 /* unmute the 0x15 amp */ 7450 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 }, 7451 { } 7452 }, 7453 .chained = true, 7454 .chain_id = ALC294_FIXUP_ASUS_GX502_HP 7455 }, 7456 [ALC294_FIXUP_ASUS_GX502_HP] = { 7457 .type = HDA_FIXUP_FUNC, 7458 .v.func = alc294_fixup_gx502_hp, 7459 }, 7460 [ALC294_FIXUP_ASUS_COEF_1B] = { 7461 .type = HDA_FIXUP_VERBS, 7462 .v.verbs = (const struct hda_verb[]) { 7463 /* Set bit 10 to correct noisy output after reboot from 7464 * Windows 10 (due to pop noise reduction?) 7465 */ 7466 { 0x20, AC_VERB_SET_COEF_INDEX, 0x1b }, 7467 { 0x20, AC_VERB_SET_PROC_COEF, 0x4e4b }, 7468 { } 7469 }, 7470 }, 7471 [ALC285_FIXUP_HP_GPIO_LED] = { 7472 .type = HDA_FIXUP_FUNC, 7473 .v.func = alc285_fixup_hp_gpio_led, 7474 }, 7475 [ALC285_FIXUP_HP_MUTE_LED] = { 7476 .type = HDA_FIXUP_FUNC, 7477 .v.func = alc285_fixup_hp_mute_led, 7478 }, 7479 [ALC236_FIXUP_HP_MUTE_LED] = { 7480 .type = HDA_FIXUP_FUNC, 7481 .v.func = alc236_fixup_hp_mute_led, 7482 }, 7483 [ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = { 7484 .type = HDA_FIXUP_VERBS, 7485 .v.verbs = (const struct hda_verb[]) { 7486 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc5 }, 7487 { } 7488 }, 7489 }, 7490 [ALC295_FIXUP_ASUS_MIC_NO_PRESENCE] = { 7491 .type = HDA_FIXUP_PINS, 7492 .v.pins = (const struct hda_pintbl[]) { 7493 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7494 { } 7495 }, 7496 .chained = true, 7497 .chain_id = ALC269_FIXUP_HEADSET_MODE 7498 }, 7499 [ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS] = { 7500 .type = HDA_FIXUP_PINS, 7501 .v.pins = (const struct hda_pintbl[]) { 7502 { 0x14, 0x90100120 }, /* use as internal speaker */ 7503 { 0x18, 0x02a111f0 }, /* use as headset mic, without its own jack detect */ 7504 { 0x1a, 0x01011020 }, /* use as line out */ 7505 { }, 7506 }, 7507 .chained = true, 7508 .chain_id = ALC269_FIXUP_HEADSET_MIC 7509 }, 7510 [ALC269VC_FIXUP_ACER_HEADSET_MIC] = { 7511 .type = HDA_FIXUP_PINS, 7512 .v.pins = (const struct hda_pintbl[]) { 7513 { 0x18, 0x02a11030 }, /* use as headset mic */ 7514 { } 7515 }, 7516 .chained = true, 7517 .chain_id = ALC269_FIXUP_HEADSET_MIC 7518 }, 7519 [ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE] = { 7520 .type = HDA_FIXUP_PINS, 7521 .v.pins = (const struct hda_pintbl[]) { 7522 { 0x18, 0x01a11130 }, /* use as headset mic, without its own jack detect */ 7523 { } 7524 }, 7525 .chained = true, 7526 .chain_id = ALC269_FIXUP_HEADSET_MIC 7527 }, 7528 [ALC289_FIXUP_ASUS_GA401] = { 7529 .type = HDA_FIXUP_PINS, 7530 .v.pins = (const struct hda_pintbl[]) { 7531 { 0x19, 0x03a11020 }, /* headset mic with jack detect */ 7532 { } 7533 }, 7534 }, 7535 [ALC289_FIXUP_ASUS_GA502] = { 7536 .type = HDA_FIXUP_PINS, 7537 .v.pins = (const struct hda_pintbl[]) { 7538 { 0x19, 0x03a11020 }, /* headset mic with jack detect */ 7539 { } 7540 }, 7541 }, 7542 [ALC256_FIXUP_ACER_MIC_NO_PRESENCE] = { 7543 .type = HDA_FIXUP_PINS, 7544 .v.pins = (const struct hda_pintbl[]) { 7545 { 0x19, 0x02a11120 }, /* use as headset mic, without its own jack detect */ 7546 { } 7547 }, 7548 .chained = true, 7549 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 7550 }, 7551 [ALC285_FIXUP_HP_GPIO_AMP_INIT] = { 7552 .type = HDA_FIXUP_FUNC, 7553 .v.func = alc285_fixup_hp_gpio_amp_init, 7554 .chained = true, 7555 .chain_id = ALC285_FIXUP_HP_GPIO_LED 7556 }, 7557 [ALC269_FIXUP_CZC_B20] = { 7558 .type = HDA_FIXUP_PINS, 7559 .v.pins = (const struct hda_pintbl[]) { 7560 { 0x12, 0x411111f0 }, 7561 { 0x14, 0x90170110 }, /* speaker */ 7562 { 0x15, 0x032f1020 }, /* HP out */ 7563 { 0x17, 0x411111f0 }, 7564 { 0x18, 0x03ab1040 }, /* mic */ 7565 { 0x19, 0xb7a7013f }, 7566 { 0x1a, 0x0181305f }, 7567 { 0x1b, 0x411111f0 }, 7568 { 0x1d, 0x411111f0 }, 7569 { 0x1e, 0x411111f0 }, 7570 { } 7571 }, 7572 .chain_id = ALC269_FIXUP_DMIC, 7573 }, 7574 [ALC269_FIXUP_CZC_TMI] = { 7575 .type = HDA_FIXUP_PINS, 7576 .v.pins = (const struct hda_pintbl[]) { 7577 { 0x12, 0x4000c000 }, 7578 { 0x14, 0x90170110 }, /* speaker */ 7579 { 0x15, 0x0421401f }, /* HP out */ 7580 { 0x17, 0x411111f0 }, 7581 { 0x18, 0x04a19020 }, /* mic */ 7582 { 0x19, 0x411111f0 }, 7583 { 0x1a, 0x411111f0 }, 7584 { 0x1b, 0x411111f0 }, 7585 { 0x1d, 0x40448505 }, 7586 { 0x1e, 0x411111f0 }, 7587 { 0x20, 0x8000ffff }, 7588 { } 7589 }, 7590 .chain_id = ALC269_FIXUP_DMIC, 7591 }, 7592 [ALC269_FIXUP_CZC_L101] = { 7593 .type = HDA_FIXUP_PINS, 7594 .v.pins = (const struct hda_pintbl[]) { 7595 { 0x12, 0x40000000 }, 7596 { 0x14, 0x01014010 }, /* speaker */ 7597 { 0x15, 0x411111f0 }, /* HP out */ 7598 { 0x16, 0x411111f0 }, 7599 { 0x18, 0x01a19020 }, /* mic */ 7600 { 0x19, 0x02a19021 }, 7601 { 0x1a, 0x0181302f }, 7602 { 0x1b, 0x0221401f }, 7603 { 0x1c, 0x411111f0 }, 7604 { 0x1d, 0x4044c601 }, 7605 { 0x1e, 0x411111f0 }, 7606 { } 7607 }, 7608 .chain_id = ALC269_FIXUP_DMIC, 7609 }, 7610 [ALC269_FIXUP_LEMOTE_A1802] = { 7611 .type = HDA_FIXUP_PINS, 7612 .v.pins = (const struct hda_pintbl[]) { 7613 { 0x12, 0x40000000 }, 7614 { 0x14, 0x90170110 }, /* speaker */ 7615 { 0x17, 0x411111f0 }, 7616 { 0x18, 0x03a19040 }, /* mic1 */ 7617 { 0x19, 0x90a70130 }, /* mic2 */ 7618 { 0x1a, 0x411111f0 }, 7619 { 0x1b, 0x411111f0 }, 7620 { 0x1d, 0x40489d2d }, 7621 { 0x1e, 0x411111f0 }, 7622 { 0x20, 0x0003ffff }, 7623 { 0x21, 0x03214020 }, 7624 { } 7625 }, 7626 .chain_id = ALC269_FIXUP_DMIC, 7627 }, 7628 [ALC269_FIXUP_LEMOTE_A190X] = { 7629 .type = HDA_FIXUP_PINS, 7630 .v.pins = (const struct hda_pintbl[]) { 7631 { 0x14, 0x99130110 }, /* speaker */ 7632 { 0x15, 0x0121401f }, /* HP out */ 7633 { 0x18, 0x01a19c20 }, /* rear mic */ 7634 { 0x19, 0x99a3092f }, /* front mic */ 7635 { 0x1b, 0x0201401f }, /* front lineout */ 7636 { } 7637 }, 7638 .chain_id = ALC269_FIXUP_DMIC, 7639 }, 7640 [ALC256_FIXUP_INTEL_NUC8_RUGGED] = { 7641 .type = HDA_FIXUP_PINS, 7642 .v.pins = (const struct hda_pintbl[]) { 7643 { 0x1b, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7644 { } 7645 }, 7646 .chained = true, 7647 .chain_id = ALC269_FIXUP_HEADSET_MODE 7648 }, 7649 [ALC255_FIXUP_XIAOMI_HEADSET_MIC] = { 7650 .type = HDA_FIXUP_VERBS, 7651 .v.verbs = (const struct hda_verb[]) { 7652 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 }, 7653 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 }, 7654 { } 7655 }, 7656 .chained = true, 7657 .chain_id = ALC289_FIXUP_ASUS_GA401 7658 }, 7659 [ALC274_FIXUP_HP_MIC] = { 7660 .type = HDA_FIXUP_VERBS, 7661 .v.verbs = (const struct hda_verb[]) { 7662 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 }, 7663 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 }, 7664 { } 7665 }, 7666 }, 7667 }; 7668 7669 static const struct snd_pci_quirk alc269_fixup_tbl[] = { 7670 SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC), 7671 SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC), 7672 SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC), 7673 SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700), 7674 SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC), 7675 SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC), 7676 SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK), 7677 SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK), 7678 SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572), 7679 SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572), 7680 SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS), 7681 SND_PCI_QUIRK(0x1025, 0x102b, "Acer Aspire C24-860", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE), 7682 SND_PCI_QUIRK(0x1025, 0x1065, "Acer Aspire C20-820", ALC269VC_FIXUP_ACER_HEADSET_MIC), 7683 SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK), 7684 SND_PCI_QUIRK(0x1025, 0x1099, "Acer Aspire E5-523G", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 7685 SND_PCI_QUIRK(0x1025, 0x110e, "Acer Aspire ES1-432", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 7686 SND_PCI_QUIRK(0x1025, 0x1246, "Acer Predator Helios 500", ALC299_FIXUP_PREDATOR_SPK), 7687 SND_PCI_QUIRK(0x1025, 0x1247, "Acer vCopperbox", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS), 7688 SND_PCI_QUIRK(0x1025, 0x1248, "Acer Veriton N4660G", ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE), 7689 SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), 7690 SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), 7691 SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), 7692 SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), 7693 SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC), 7694 SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC), 7695 SND_PCI_QUIRK(0x1025, 0x1430, "Acer TravelMate B311R-31", ALC256_FIXUP_ACER_MIC_NO_PRESENCE), 7696 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z), 7697 SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS), 7698 SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X), 7699 SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X), 7700 SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X), 7701 SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X), 7702 SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER), 7703 SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE), 7704 SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE), 7705 SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE), 7706 SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK), 7707 SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK), 7708 SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X), 7709 SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X), 7710 SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK), 7711 SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 7712 SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 7713 SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13), 7714 SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE), 7715 SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK), 7716 SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE), 7717 SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 7718 SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 7719 SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 7720 SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 7721 SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 7722 SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 7723 SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 7724 SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER), 7725 SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE), 7726 SND_PCI_QUIRK(0x1028, 0x0738, "Dell Precision 5820", ALC269_FIXUP_NO_SHUTUP), 7727 SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME), 7728 SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME), 7729 SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3), 7730 SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER), 7731 SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE), 7732 SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB), 7733 SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB), 7734 SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC), 7735 SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC), 7736 SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB), 7737 SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE), 7738 SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE), 7739 SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB), 7740 SND_PCI_QUIRK(0x1028, 0x097e, "Dell Precision", ALC289_FIXUP_DUAL_SPK), 7741 SND_PCI_QUIRK(0x1028, 0x097d, "Dell Precision", ALC289_FIXUP_DUAL_SPK), 7742 SND_PCI_QUIRK(0x1028, 0x098d, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE), 7743 SND_PCI_QUIRK(0x1028, 0x09bf, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE), 7744 SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 7745 SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 7746 SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2), 7747 SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED), 7748 SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED), 7749 SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY), 7750 /* ALC282 */ 7751 SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7752 SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7753 SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7754 SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 7755 SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 7756 SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 7757 SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 7758 SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 7759 SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7760 SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7761 SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7762 SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7763 SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED), 7764 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS), 7765 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS), 7766 SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7767 SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7768 SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7769 SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7770 SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7771 SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M), 7772 SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7773 SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7774 /* ALC290 */ 7775 SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7776 SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7777 SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7778 SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7779 SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7780 SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7781 SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7782 SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7783 SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7784 SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED), 7785 SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7786 SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7787 SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7788 SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7789 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7790 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7791 SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7792 SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7793 SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7794 SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7795 SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7796 SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7797 SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7798 SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7799 SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7800 SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7801 SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7802 SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7803 SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7804 SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC), 7805 SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE), 7806 SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE), 7807 SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3), 7808 SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC), 7809 SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360), 7810 SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE), 7811 SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE), 7812 SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3), 7813 SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3), 7814 SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3), 7815 SND_PCI_QUIRK(0x103c, 0x869d, "HP", ALC236_FIXUP_HP_MUTE_LED), 7816 SND_PCI_QUIRK(0x103c, 0x8729, "HP", ALC285_FIXUP_HP_GPIO_LED), 7817 SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_AMP_INIT), 7818 SND_PCI_QUIRK(0x103c, 0x874e, "HP", ALC274_FIXUP_HP_MIC), 7819 SND_PCI_QUIRK(0x103c, 0x8760, "HP", ALC285_FIXUP_HP_MUTE_LED), 7820 SND_PCI_QUIRK(0x103c, 0x877a, "HP", ALC285_FIXUP_HP_MUTE_LED), 7821 SND_PCI_QUIRK(0x103c, 0x877d, "HP", ALC236_FIXUP_HP_MUTE_LED), 7822 SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC), 7823 SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300), 7824 SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 7825 SND_PCI_QUIRK(0x1043, 0x10a1, "ASUS UX391UA", ALC294_FIXUP_ASUS_SPK), 7826 SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC), 7827 SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE), 7828 SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 7829 SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE), 7830 SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE), 7831 SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE), 7832 SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC), 7833 SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC), 7834 SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC), 7835 SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK), 7836 SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A), 7837 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC), 7838 SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_DUAL_SPK), 7839 SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC), 7840 SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC), 7841 SND_PCI_QUIRK(0x1043, 0x194e, "ASUS UX563FD", ALC294_FIXUP_ASUS_HPE), 7842 SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE), 7843 SND_PCI_QUIRK(0x1043, 0x19e1, "ASUS UX581LV", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE), 7844 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW), 7845 SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC), 7846 SND_PCI_QUIRK(0x1043, 0x1b11, "ASUS UX431DA", ALC294_FIXUP_ASUS_COEF_1B), 7847 SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC), 7848 SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE), 7849 SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 7850 SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC), 7851 SND_PCI_QUIRK(0x1043, 0x1e11, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA502), 7852 SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401), 7853 SND_PCI_QUIRK(0x1043, 0x1881, "ASUS Zephyrus S/M", ALC294_FIXUP_ASUS_GX502_PINS), 7854 SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2), 7855 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC), 7856 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC), 7857 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC), 7858 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC), 7859 SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101), 7860 SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE), 7861 SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE), 7862 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2), 7863 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ), 7864 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ), 7865 SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX), 7866 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK), 7867 SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT), 7868 SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN), 7869 SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN), 7870 SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC), 7871 SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC), 7872 SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE), 7873 SND_PCI_QUIRK(0x10ec, 0x1230, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 7874 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_HEADSET_MODE), 7875 SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC), 7876 SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), 7877 SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), 7878 SND_PCI_QUIRK(0x144d, 0xc189, "Samsung Galaxy Flex Book (NT950QCG-X716)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), 7879 SND_PCI_QUIRK(0x144d, 0xc18a, "Samsung Galaxy Book Ion (NP930XCJ-K01US)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), 7880 SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), 7881 SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8), 7882 SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), 7883 SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC), 7884 SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC), 7885 SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC), 7886 SND_PCI_QUIRK(0x1558, 0x1325, "System76 Darter Pro (darp5)", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7887 SND_PCI_QUIRK(0x1558, 0x8550, "System76 Gazelle (gaze14)", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7888 SND_PCI_QUIRK(0x1558, 0x8551, "System76 Gazelle (gaze14)", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7889 SND_PCI_QUIRK(0x1558, 0x8560, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC), 7890 SND_PCI_QUIRK(0x1558, 0x8561, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC), 7891 SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS), 7892 SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC), 7893 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE), 7894 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE), 7895 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE), 7896 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE), 7897 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE), 7898 SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST), 7899 SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK), 7900 SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK), 7901 SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK), 7902 SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK), 7903 SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK), 7904 SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440), 7905 SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK), 7906 SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK), 7907 SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK), 7908 SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK), 7909 SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK), 7910 SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 7911 SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK), 7912 SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK), 7913 SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK), 7914 SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 7915 SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 7916 SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460), 7917 SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460), 7918 SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK), 7919 SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 7920 SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 7921 SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460), 7922 SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 7923 SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 7924 SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 7925 SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 7926 SND_PCI_QUIRK(0x17aa, 0x2292, "Thinkpad X1 Carbon 7th", ALC285_FIXUP_THINKPAD_HEADSET_JACK), 7927 SND_PCI_QUIRK(0x17aa, 0x22be, "Thinkpad X1 Carbon 8th", ALC285_FIXUP_THINKPAD_HEADSET_JACK), 7928 SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY), 7929 SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY), 7930 SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 7931 SND_PCI_QUIRK(0x17aa, 0x3111, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 7932 SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 7933 SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 7934 SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 7935 SND_PCI_QUIRK(0x17aa, 0x3151, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC), 7936 SND_PCI_QUIRK(0x17aa, 0x3176, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC), 7937 SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC), 7938 SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI), 7939 SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC), 7940 SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI), 7941 SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 7942 SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC), 7943 SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK), 7944 SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 7945 SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK), 7946 SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK), 7947 SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK), 7948 SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK), 7949 SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE), 7950 SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460), 7951 SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460), 7952 SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460), 7953 SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 7954 SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 7955 SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 7956 SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 7957 SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 7958 SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 7959 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K), 7960 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD), 7961 SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS), 7962 SND_PCI_QUIRK(0x1b35, 0x1235, "CZC B20", ALC269_FIXUP_CZC_B20), 7963 SND_PCI_QUIRK(0x1b35, 0x1236, "CZC TMI", ALC269_FIXUP_CZC_TMI), 7964 SND_PCI_QUIRK(0x1b35, 0x1237, "CZC L101", ALC269_FIXUP_CZC_L101), 7965 SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */ 7966 SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC), 7967 SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC), 7968 SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE), 7969 SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802), 7970 SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X), 7971 SND_PCI_QUIRK(0x8086, 0x2080, "Intel NUC 8 Rugged", ALC256_FIXUP_INTEL_NUC8_RUGGED), 7972 7973 #if 0 7974 /* Below is a quirk table taken from the old code. 7975 * Basically the device should work as is without the fixup table. 7976 * If BIOS doesn't give a proper info, enable the corresponding 7977 * fixup entry. 7978 */ 7979 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A", 7980 ALC269_FIXUP_AMIC), 7981 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC), 7982 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC), 7983 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC), 7984 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC), 7985 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC), 7986 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC), 7987 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC), 7988 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC), 7989 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC), 7990 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC), 7991 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC), 7992 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC), 7993 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC), 7994 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC), 7995 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC), 7996 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC), 7997 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC), 7998 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC), 7999 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC), 8000 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC), 8001 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC), 8002 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC), 8003 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC), 8004 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC), 8005 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC), 8006 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC), 8007 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC), 8008 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC), 8009 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC), 8010 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC), 8011 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC), 8012 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC), 8013 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC), 8014 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC), 8015 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC), 8016 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC), 8017 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC), 8018 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC), 8019 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC), 8020 #endif 8021 {} 8022 }; 8023 8024 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = { 8025 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC), 8026 SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED), 8027 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO), 8028 SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI), 8029 SND_PCI_QUIRK_VENDOR(0x19e5, "Huawei Matebook", ALC255_FIXUP_MIC_MUTE_LED), 8030 {} 8031 }; 8032 8033 static const struct hda_model_fixup alc269_fixup_models[] = { 8034 {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"}, 8035 {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"}, 8036 {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"}, 8037 {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"}, 8038 {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"}, 8039 {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"}, 8040 {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"}, 8041 {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"}, 8042 {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"}, 8043 {.id = ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, .name = "lenovo-dock-limit-boost"}, 8044 {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"}, 8045 {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"}, 8046 {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"}, 8047 {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"}, 8048 {.id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, .name = "dell-headset3"}, 8049 {.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, .name = "dell-headset4"}, 8050 {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"}, 8051 {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"}, 8052 {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"}, 8053 {.id = ALC292_FIXUP_TPT440, .name = "tpt440"}, 8054 {.id = ALC292_FIXUP_TPT460, .name = "tpt460"}, 8055 {.id = ALC298_FIXUP_TPT470_DOCK_FIX, .name = "tpt470-dock-fix"}, 8056 {.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"}, 8057 {.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"}, 8058 {.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"}, 8059 {.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"}, 8060 {.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"}, 8061 {.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"}, 8062 {.id = ALC269_FIXUP_LENOVO_EAPD, .name = "lenovo-eapd"}, 8063 {.id = ALC275_FIXUP_SONY_HWEQ, .name = "sony-hweq"}, 8064 {.id = ALC269_FIXUP_PCM_44K, .name = "pcm44k"}, 8065 {.id = ALC269_FIXUP_LIFEBOOK, .name = "lifebook"}, 8066 {.id = ALC269_FIXUP_LIFEBOOK_EXTMIC, .name = "lifebook-extmic"}, 8067 {.id = ALC269_FIXUP_LIFEBOOK_HP_PIN, .name = "lifebook-hp-pin"}, 8068 {.id = ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, .name = "lifebook-u7x7"}, 8069 {.id = ALC269VB_FIXUP_AMIC, .name = "alc269vb-amic"}, 8070 {.id = ALC269VB_FIXUP_DMIC, .name = "alc269vb-dmic"}, 8071 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC1, .name = "hp-mute-led-mic1"}, 8072 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC2, .name = "hp-mute-led-mic2"}, 8073 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC3, .name = "hp-mute-led-mic3"}, 8074 {.id = ALC269_FIXUP_HP_GPIO_MIC1_LED, .name = "hp-gpio-mic1"}, 8075 {.id = ALC269_FIXUP_HP_LINE1_MIC1_LED, .name = "hp-line1-mic1"}, 8076 {.id = ALC269_FIXUP_NO_SHUTUP, .name = "noshutup"}, 8077 {.id = ALC286_FIXUP_SONY_MIC_NO_PRESENCE, .name = "sony-nomic"}, 8078 {.id = ALC269_FIXUP_ASPIRE_HEADSET_MIC, .name = "aspire-headset-mic"}, 8079 {.id = ALC269_FIXUP_ASUS_X101, .name = "asus-x101"}, 8080 {.id = ALC271_FIXUP_HP_GATE_MIC_JACK, .name = "acer-ao7xx"}, 8081 {.id = ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, .name = "acer-aspire-e1"}, 8082 {.id = ALC269_FIXUP_ACER_AC700, .name = "acer-ac700"}, 8083 {.id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, .name = "limit-mic-boost"}, 8084 {.id = ALC269VB_FIXUP_ASUS_ZENBOOK, .name = "asus-zenbook"}, 8085 {.id = ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, .name = "asus-zenbook-ux31a"}, 8086 {.id = ALC269VB_FIXUP_ORDISSIMO_EVE2, .name = "ordissimo"}, 8087 {.id = ALC282_FIXUP_ASUS_TX300, .name = "asus-tx300"}, 8088 {.id = ALC283_FIXUP_INT_MIC, .name = "alc283-int-mic"}, 8089 {.id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, .name = "mono-speakers"}, 8090 {.id = ALC290_FIXUP_SUBWOOFER_HSJACK, .name = "alc290-subwoofer"}, 8091 {.id = ALC269_FIXUP_THINKPAD_ACPI, .name = "thinkpad"}, 8092 {.id = ALC269_FIXUP_DMIC_THINKPAD_ACPI, .name = "dmic-thinkpad"}, 8093 {.id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, .name = "alc255-acer"}, 8094 {.id = ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc255-asus"}, 8095 {.id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc255-dell1"}, 8096 {.id = ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "alc255-dell2"}, 8097 {.id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc293-dell1"}, 8098 {.id = ALC283_FIXUP_HEADSET_MIC, .name = "alc283-headset"}, 8099 {.id = ALC255_FIXUP_MIC_MUTE_LED, .name = "alc255-dell-mute"}, 8100 {.id = ALC282_FIXUP_ASPIRE_V5_PINS, .name = "aspire-v5"}, 8101 {.id = ALC280_FIXUP_HP_GPIO4, .name = "hp-gpio4"}, 8102 {.id = ALC286_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"}, 8103 {.id = ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, .name = "hp-gpio2-hotkey"}, 8104 {.id = ALC280_FIXUP_HP_DOCK_PINS, .name = "hp-dock-pins"}, 8105 {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic"}, 8106 {.id = ALC280_FIXUP_HP_9480M, .name = "hp-9480m"}, 8107 {.id = ALC288_FIXUP_DELL_HEADSET_MODE, .name = "alc288-dell-headset"}, 8108 {.id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc288-dell1"}, 8109 {.id = ALC288_FIXUP_DELL_XPS_13, .name = "alc288-dell-xps13"}, 8110 {.id = ALC292_FIXUP_DELL_E7X, .name = "dell-e7x"}, 8111 {.id = ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, .name = "alc293-dell"}, 8112 {.id = ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc298-dell1"}, 8113 {.id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, .name = "alc298-dell-aio"}, 8114 {.id = ALC275_FIXUP_DELL_XPS, .name = "alc275-dell-xps"}, 8115 {.id = ALC293_FIXUP_LENOVO_SPK_NOISE, .name = "lenovo-spk-noise"}, 8116 {.id = ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, .name = "lenovo-hotkey"}, 8117 {.id = ALC255_FIXUP_DELL_SPK_NOISE, .name = "dell-spk-noise"}, 8118 {.id = ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc225-dell1"}, 8119 {.id = ALC295_FIXUP_DISABLE_DAC3, .name = "alc295-disable-dac3"}, 8120 {.id = ALC285_FIXUP_SPEAKER2_TO_DAC1, .name = "alc285-speaker2-to-dac1"}, 8121 {.id = ALC280_FIXUP_HP_HEADSET_MIC, .name = "alc280-hp-headset"}, 8122 {.id = ALC221_FIXUP_HP_FRONT_MIC, .name = "alc221-hp-mic"}, 8123 {.id = ALC298_FIXUP_SPK_VOLUME, .name = "alc298-spk-volume"}, 8124 {.id = ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, .name = "dell-inspiron-7559"}, 8125 {.id = ALC269_FIXUP_ATIV_BOOK_8, .name = "ativ-book"}, 8126 {.id = ALC221_FIXUP_HP_MIC_NO_PRESENCE, .name = "alc221-hp-mic"}, 8127 {.id = ALC256_FIXUP_ASUS_HEADSET_MODE, .name = "alc256-asus-headset"}, 8128 {.id = ALC256_FIXUP_ASUS_MIC, .name = "alc256-asus-mic"}, 8129 {.id = ALC256_FIXUP_ASUS_AIO_GPIO2, .name = "alc256-asus-aio"}, 8130 {.id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc233-asus"}, 8131 {.id = ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, .name = "alc233-eapd"}, 8132 {.id = ALC294_FIXUP_LENOVO_MIC_LOCATION, .name = "alc294-lenovo-mic"}, 8133 {.id = ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, .name = "alc225-wyse"}, 8134 {.id = ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, .name = "alc274-dell-aio"}, 8135 {.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"}, 8136 {.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"}, 8137 {.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"}, 8138 {.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"}, 8139 {.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"}, 8140 {.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"}, 8141 {.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"}, 8142 {.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"}, 8143 {.id = ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc298-samsung-headphone"}, 8144 {.id = ALC255_FIXUP_XIAOMI_HEADSET_MIC, .name = "alc255-xiaomi-headset"}, 8145 {.id = ALC274_FIXUP_HP_MIC, .name = "alc274-hp-mic-detect"}, 8146 {} 8147 }; 8148 #define ALC225_STANDARD_PINS \ 8149 {0x21, 0x04211020} 8150 8151 #define ALC256_STANDARD_PINS \ 8152 {0x12, 0x90a60140}, \ 8153 {0x14, 0x90170110}, \ 8154 {0x21, 0x02211020} 8155 8156 #define ALC282_STANDARD_PINS \ 8157 {0x14, 0x90170110} 8158 8159 #define ALC290_STANDARD_PINS \ 8160 {0x12, 0x99a30130} 8161 8162 #define ALC292_STANDARD_PINS \ 8163 {0x14, 0x90170110}, \ 8164 {0x15, 0x0221401f} 8165 8166 #define ALC295_STANDARD_PINS \ 8167 {0x12, 0xb7a60130}, \ 8168 {0x14, 0x90170110}, \ 8169 {0x21, 0x04211020} 8170 8171 #define ALC298_STANDARD_PINS \ 8172 {0x12, 0x90a60130}, \ 8173 {0x21, 0x03211020} 8174 8175 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = { 8176 SND_HDA_PIN_QUIRK(0x10ec0221, 0x103c, "HP Workstation", ALC221_FIXUP_HP_HEADSET_MIC, 8177 {0x14, 0x01014020}, 8178 {0x17, 0x90170110}, 8179 {0x18, 0x02a11030}, 8180 {0x19, 0x0181303F}, 8181 {0x21, 0x0221102f}), 8182 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE, 8183 {0x12, 0x90a601c0}, 8184 {0x14, 0x90171120}, 8185 {0x21, 0x02211030}), 8186 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, 8187 {0x14, 0x90170110}, 8188 {0x1b, 0x90a70130}, 8189 {0x21, 0x03211020}), 8190 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, 8191 {0x1a, 0x90a70130}, 8192 {0x1b, 0x90170110}, 8193 {0x21, 0x03211020}), 8194 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 8195 ALC225_STANDARD_PINS, 8196 {0x12, 0xb7a60130}, 8197 {0x14, 0x901701a0}), 8198 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 8199 ALC225_STANDARD_PINS, 8200 {0x12, 0xb7a60130}, 8201 {0x14, 0x901701b0}), 8202 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 8203 ALC225_STANDARD_PINS, 8204 {0x12, 0xb7a60150}, 8205 {0x14, 0x901701a0}), 8206 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 8207 ALC225_STANDARD_PINS, 8208 {0x12, 0xb7a60150}, 8209 {0x14, 0x901701b0}), 8210 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 8211 ALC225_STANDARD_PINS, 8212 {0x12, 0xb7a60130}, 8213 {0x1b, 0x90170110}), 8214 SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 8215 {0x1b, 0x01111010}, 8216 {0x1e, 0x01451130}, 8217 {0x21, 0x02211020}), 8218 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, 8219 {0x12, 0x90a60140}, 8220 {0x14, 0x90170110}, 8221 {0x19, 0x02a11030}, 8222 {0x21, 0x02211020}), 8223 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION, 8224 {0x14, 0x90170110}, 8225 {0x19, 0x02a11030}, 8226 {0x1a, 0x02a11040}, 8227 {0x1b, 0x01014020}, 8228 {0x21, 0x0221101f}), 8229 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION, 8230 {0x14, 0x90170110}, 8231 {0x19, 0x02a11030}, 8232 {0x1a, 0x02a11040}, 8233 {0x1b, 0x01011020}, 8234 {0x21, 0x0221101f}), 8235 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION, 8236 {0x14, 0x90170110}, 8237 {0x19, 0x02a11020}, 8238 {0x1a, 0x02a11030}, 8239 {0x21, 0x0221101f}), 8240 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, 8241 {0x14, 0x90170110}, 8242 {0x21, 0x02211020}), 8243 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8244 {0x14, 0x90170130}, 8245 {0x21, 0x02211040}), 8246 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8247 {0x12, 0x90a60140}, 8248 {0x14, 0x90170110}, 8249 {0x21, 0x02211020}), 8250 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8251 {0x12, 0x90a60160}, 8252 {0x14, 0x90170120}, 8253 {0x21, 0x02211030}), 8254 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8255 {0x14, 0x90170110}, 8256 {0x1b, 0x02011020}, 8257 {0x21, 0x0221101f}), 8258 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8259 {0x14, 0x90170110}, 8260 {0x1b, 0x01011020}, 8261 {0x21, 0x0221101f}), 8262 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8263 {0x14, 0x90170130}, 8264 {0x1b, 0x01014020}, 8265 {0x21, 0x0221103f}), 8266 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8267 {0x14, 0x90170130}, 8268 {0x1b, 0x01011020}, 8269 {0x21, 0x0221103f}), 8270 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8271 {0x14, 0x90170130}, 8272 {0x1b, 0x02011020}, 8273 {0x21, 0x0221103f}), 8274 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8275 {0x14, 0x90170150}, 8276 {0x1b, 0x02011020}, 8277 {0x21, 0x0221105f}), 8278 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8279 {0x14, 0x90170110}, 8280 {0x1b, 0x01014020}, 8281 {0x21, 0x0221101f}), 8282 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8283 {0x12, 0x90a60160}, 8284 {0x14, 0x90170120}, 8285 {0x17, 0x90170140}, 8286 {0x21, 0x0321102f}), 8287 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8288 {0x12, 0x90a60160}, 8289 {0x14, 0x90170130}, 8290 {0x21, 0x02211040}), 8291 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8292 {0x12, 0x90a60160}, 8293 {0x14, 0x90170140}, 8294 {0x21, 0x02211050}), 8295 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8296 {0x12, 0x90a60170}, 8297 {0x14, 0x90170120}, 8298 {0x21, 0x02211030}), 8299 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8300 {0x12, 0x90a60170}, 8301 {0x14, 0x90170130}, 8302 {0x21, 0x02211040}), 8303 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8304 {0x12, 0x90a60170}, 8305 {0x14, 0x90171130}, 8306 {0x21, 0x02211040}), 8307 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8308 {0x12, 0x90a60170}, 8309 {0x14, 0x90170140}, 8310 {0x21, 0x02211050}), 8311 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8312 {0x12, 0x90a60180}, 8313 {0x14, 0x90170130}, 8314 {0x21, 0x02211040}), 8315 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8316 {0x12, 0x90a60180}, 8317 {0x14, 0x90170120}, 8318 {0x21, 0x02211030}), 8319 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8320 {0x1b, 0x01011020}, 8321 {0x21, 0x02211010}), 8322 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC, 8323 {0x14, 0x90170110}, 8324 {0x1b, 0x90a70130}, 8325 {0x21, 0x04211020}), 8326 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC, 8327 {0x14, 0x90170110}, 8328 {0x1b, 0x90a70130}, 8329 {0x21, 0x03211020}), 8330 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE, 8331 {0x12, 0x90a60130}, 8332 {0x14, 0x90170110}, 8333 {0x21, 0x03211020}), 8334 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE, 8335 {0x12, 0x90a60130}, 8336 {0x14, 0x90170110}, 8337 {0x21, 0x04211020}), 8338 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE, 8339 {0x1a, 0x90a70130}, 8340 {0x1b, 0x90170110}, 8341 {0x21, 0x03211020}), 8342 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4, 8343 {0x12, 0x90a60130}, 8344 {0x14, 0x90170110}, 8345 {0x15, 0x0421101f}, 8346 {0x1a, 0x04a11020}), 8347 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED, 8348 {0x12, 0x90a60140}, 8349 {0x14, 0x90170110}, 8350 {0x15, 0x0421101f}, 8351 {0x18, 0x02811030}, 8352 {0x1a, 0x04a1103f}, 8353 {0x1b, 0x02011020}), 8354 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1, 8355 ALC282_STANDARD_PINS, 8356 {0x12, 0x99a30130}, 8357 {0x19, 0x03a11020}, 8358 {0x21, 0x0321101f}), 8359 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 8360 ALC282_STANDARD_PINS, 8361 {0x12, 0x99a30130}, 8362 {0x19, 0x03a11020}, 8363 {0x21, 0x03211040}), 8364 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 8365 ALC282_STANDARD_PINS, 8366 {0x12, 0x99a30130}, 8367 {0x19, 0x03a11030}, 8368 {0x21, 0x03211020}), 8369 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 8370 ALC282_STANDARD_PINS, 8371 {0x12, 0x99a30130}, 8372 {0x19, 0x04a11020}, 8373 {0x21, 0x0421101f}), 8374 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED, 8375 ALC282_STANDARD_PINS, 8376 {0x12, 0x90a60140}, 8377 {0x19, 0x04a11030}, 8378 {0x21, 0x04211020}), 8379 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 8380 ALC282_STANDARD_PINS, 8381 {0x12, 0x90a60130}, 8382 {0x21, 0x0321101f}), 8383 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 8384 {0x12, 0x90a60160}, 8385 {0x14, 0x90170120}, 8386 {0x21, 0x02211030}), 8387 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 8388 ALC282_STANDARD_PINS, 8389 {0x12, 0x90a60130}, 8390 {0x19, 0x03a11020}, 8391 {0x21, 0x0321101f}), 8392 SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE, 8393 {0x12, 0x90a60130}, 8394 {0x14, 0x90170110}, 8395 {0x19, 0x04a11040}, 8396 {0x21, 0x04211020}), 8397 SND_HDA_PIN_QUIRK(0x10ec0286, 0x1025, "Acer", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE, 8398 {0x12, 0x90a60130}, 8399 {0x17, 0x90170110}, 8400 {0x21, 0x02211020}), 8401 SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, 8402 {0x12, 0x90a60120}, 8403 {0x14, 0x90170110}, 8404 {0x21, 0x0321101f}), 8405 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 8406 ALC290_STANDARD_PINS, 8407 {0x15, 0x04211040}, 8408 {0x18, 0x90170112}, 8409 {0x1a, 0x04a11020}), 8410 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 8411 ALC290_STANDARD_PINS, 8412 {0x15, 0x04211040}, 8413 {0x18, 0x90170110}, 8414 {0x1a, 0x04a11020}), 8415 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 8416 ALC290_STANDARD_PINS, 8417 {0x15, 0x0421101f}, 8418 {0x1a, 0x04a11020}), 8419 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 8420 ALC290_STANDARD_PINS, 8421 {0x15, 0x04211020}, 8422 {0x1a, 0x04a11040}), 8423 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 8424 ALC290_STANDARD_PINS, 8425 {0x14, 0x90170110}, 8426 {0x15, 0x04211020}, 8427 {0x1a, 0x04a11040}), 8428 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 8429 ALC290_STANDARD_PINS, 8430 {0x14, 0x90170110}, 8431 {0x15, 0x04211020}, 8432 {0x1a, 0x04a11020}), 8433 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 8434 ALC290_STANDARD_PINS, 8435 {0x14, 0x90170110}, 8436 {0x15, 0x0421101f}, 8437 {0x1a, 0x04a11020}), 8438 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, 8439 ALC292_STANDARD_PINS, 8440 {0x12, 0x90a60140}, 8441 {0x16, 0x01014020}, 8442 {0x19, 0x01a19030}), 8443 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, 8444 ALC292_STANDARD_PINS, 8445 {0x12, 0x90a60140}, 8446 {0x16, 0x01014020}, 8447 {0x18, 0x02a19031}, 8448 {0x19, 0x01a1903e}), 8449 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, 8450 ALC292_STANDARD_PINS, 8451 {0x12, 0x90a60140}), 8452 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, 8453 ALC292_STANDARD_PINS, 8454 {0x13, 0x90a60140}, 8455 {0x16, 0x21014020}, 8456 {0x19, 0x21a19030}), 8457 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, 8458 ALC292_STANDARD_PINS, 8459 {0x13, 0x90a60140}), 8460 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC, 8461 {0x14, 0x90170110}, 8462 {0x1b, 0x90a70130}, 8463 {0x21, 0x04211020}), 8464 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK, 8465 {0x12, 0x90a60130}, 8466 {0x17, 0x90170110}, 8467 {0x21, 0x03211020}), 8468 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK, 8469 {0x12, 0x90a60130}, 8470 {0x17, 0x90170110}, 8471 {0x21, 0x04211020}), 8472 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK, 8473 {0x12, 0x90a60130}, 8474 {0x17, 0x90170110}, 8475 {0x21, 0x03211020}), 8476 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, 8477 {0x12, 0x90a60120}, 8478 {0x17, 0x90170110}, 8479 {0x21, 0x04211030}), 8480 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, 8481 {0x12, 0x90a60130}, 8482 {0x17, 0x90170110}, 8483 {0x21, 0x03211020}), 8484 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, 8485 {0x12, 0x90a60130}, 8486 {0x17, 0x90170110}, 8487 {0x21, 0x03211020}), 8488 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 8489 {0x14, 0x90170110}, 8490 {0x21, 0x04211020}), 8491 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 8492 {0x14, 0x90170110}, 8493 {0x21, 0x04211030}), 8494 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 8495 ALC295_STANDARD_PINS, 8496 {0x17, 0x21014020}, 8497 {0x18, 0x21a19030}), 8498 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 8499 ALC295_STANDARD_PINS, 8500 {0x17, 0x21014040}, 8501 {0x18, 0x21a19050}), 8502 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 8503 ALC295_STANDARD_PINS), 8504 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 8505 ALC298_STANDARD_PINS, 8506 {0x17, 0x90170110}), 8507 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 8508 ALC298_STANDARD_PINS, 8509 {0x17, 0x90170140}), 8510 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 8511 ALC298_STANDARD_PINS, 8512 {0x17, 0x90170150}), 8513 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME, 8514 {0x12, 0xb7a60140}, 8515 {0x13, 0xb7a60150}, 8516 {0x17, 0x90170110}, 8517 {0x1a, 0x03011020}, 8518 {0x21, 0x03211030}), 8519 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE, 8520 {0x12, 0xb7a60140}, 8521 {0x17, 0x90170110}, 8522 {0x1a, 0x03a11030}, 8523 {0x21, 0x03211020}), 8524 SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 8525 ALC225_STANDARD_PINS, 8526 {0x12, 0xb7a60130}, 8527 {0x17, 0x90170110}), 8528 SND_HDA_PIN_QUIRK(0x10ec0623, 0x17aa, "Lenovo", ALC283_FIXUP_HEADSET_MIC, 8529 {0x14, 0x01014010}, 8530 {0x17, 0x90170120}, 8531 {0x18, 0x02a11030}, 8532 {0x19, 0x02a1103f}, 8533 {0x21, 0x0221101f}), 8534 {} 8535 }; 8536 8537 /* This is the fallback pin_fixup_tbl for alc269 family, to make the tbl match 8538 * more machines, don't need to match all valid pins, just need to match 8539 * all the pins defined in the tbl. Just because of this reason, it is possible 8540 * that a single machine matches multiple tbls, so there is one limitation: 8541 * at most one tbl is allowed to define for the same vendor and same codec 8542 */ 8543 static const struct snd_hda_pin_quirk alc269_fallback_pin_fixup_tbl[] = { 8544 SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 8545 {0x19, 0x40000000}, 8546 {0x1b, 0x40000000}), 8547 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8548 {0x19, 0x40000000}, 8549 {0x1a, 0x40000000}), 8550 SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8551 {0x19, 0x40000000}, 8552 {0x1a, 0x40000000}), 8553 SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, 8554 {0x19, 0x40000000}, 8555 {0x1a, 0x40000000}), 8556 {} 8557 }; 8558 8559 static void alc269_fill_coef(struct hda_codec *codec) 8560 { 8561 struct alc_spec *spec = codec->spec; 8562 int val; 8563 8564 if (spec->codec_variant != ALC269_TYPE_ALC269VB) 8565 return; 8566 8567 if ((alc_get_coef0(codec) & 0x00ff) < 0x015) { 8568 alc_write_coef_idx(codec, 0xf, 0x960b); 8569 alc_write_coef_idx(codec, 0xe, 0x8817); 8570 } 8571 8572 if ((alc_get_coef0(codec) & 0x00ff) == 0x016) { 8573 alc_write_coef_idx(codec, 0xf, 0x960b); 8574 alc_write_coef_idx(codec, 0xe, 0x8814); 8575 } 8576 8577 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) { 8578 /* Power up output pin */ 8579 alc_update_coef_idx(codec, 0x04, 0, 1<<11); 8580 } 8581 8582 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) { 8583 val = alc_read_coef_idx(codec, 0xd); 8584 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) { 8585 /* Capless ramp up clock control */ 8586 alc_write_coef_idx(codec, 0xd, val | (1<<10)); 8587 } 8588 val = alc_read_coef_idx(codec, 0x17); 8589 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) { 8590 /* Class D power on reset */ 8591 alc_write_coef_idx(codec, 0x17, val | (1<<7)); 8592 } 8593 } 8594 8595 /* HP */ 8596 alc_update_coef_idx(codec, 0x4, 0, 1<<11); 8597 } 8598 8599 /* 8600 */ 8601 static int patch_alc269(struct hda_codec *codec) 8602 { 8603 struct alc_spec *spec; 8604 int err; 8605 8606 err = alc_alloc_spec(codec, 0x0b); 8607 if (err < 0) 8608 return err; 8609 8610 spec = codec->spec; 8611 spec->gen.shared_mic_vref_pin = 0x18; 8612 codec->power_save_node = 0; 8613 8614 #ifdef CONFIG_PM 8615 codec->patch_ops.suspend = alc269_suspend; 8616 codec->patch_ops.resume = alc269_resume; 8617 #endif 8618 spec->shutup = alc_default_shutup; 8619 spec->init_hook = alc_default_init; 8620 8621 switch (codec->core.vendor_id) { 8622 case 0x10ec0269: 8623 spec->codec_variant = ALC269_TYPE_ALC269VA; 8624 switch (alc_get_coef0(codec) & 0x00f0) { 8625 case 0x0010: 8626 if (codec->bus->pci && 8627 codec->bus->pci->subsystem_vendor == 0x1025 && 8628 spec->cdefine.platform_type == 1) 8629 err = alc_codec_rename(codec, "ALC271X"); 8630 spec->codec_variant = ALC269_TYPE_ALC269VB; 8631 break; 8632 case 0x0020: 8633 if (codec->bus->pci && 8634 codec->bus->pci->subsystem_vendor == 0x17aa && 8635 codec->bus->pci->subsystem_device == 0x21f3) 8636 err = alc_codec_rename(codec, "ALC3202"); 8637 spec->codec_variant = ALC269_TYPE_ALC269VC; 8638 break; 8639 case 0x0030: 8640 spec->codec_variant = ALC269_TYPE_ALC269VD; 8641 break; 8642 default: 8643 alc_fix_pll_init(codec, 0x20, 0x04, 15); 8644 } 8645 if (err < 0) 8646 goto error; 8647 spec->shutup = alc269_shutup; 8648 spec->init_hook = alc269_fill_coef; 8649 alc269_fill_coef(codec); 8650 break; 8651 8652 case 0x10ec0280: 8653 case 0x10ec0290: 8654 spec->codec_variant = ALC269_TYPE_ALC280; 8655 break; 8656 case 0x10ec0282: 8657 spec->codec_variant = ALC269_TYPE_ALC282; 8658 spec->shutup = alc282_shutup; 8659 spec->init_hook = alc282_init; 8660 break; 8661 case 0x10ec0233: 8662 case 0x10ec0283: 8663 spec->codec_variant = ALC269_TYPE_ALC283; 8664 spec->shutup = alc283_shutup; 8665 spec->init_hook = alc283_init; 8666 break; 8667 case 0x10ec0284: 8668 case 0x10ec0292: 8669 spec->codec_variant = ALC269_TYPE_ALC284; 8670 break; 8671 case 0x10ec0293: 8672 spec->codec_variant = ALC269_TYPE_ALC293; 8673 break; 8674 case 0x10ec0286: 8675 case 0x10ec0288: 8676 spec->codec_variant = ALC269_TYPE_ALC286; 8677 break; 8678 case 0x10ec0298: 8679 spec->codec_variant = ALC269_TYPE_ALC298; 8680 break; 8681 case 0x10ec0235: 8682 case 0x10ec0255: 8683 spec->codec_variant = ALC269_TYPE_ALC255; 8684 spec->shutup = alc256_shutup; 8685 spec->init_hook = alc256_init; 8686 break; 8687 case 0x10ec0236: 8688 case 0x10ec0256: 8689 spec->codec_variant = ALC269_TYPE_ALC256; 8690 spec->shutup = alc256_shutup; 8691 spec->init_hook = alc256_init; 8692 spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */ 8693 break; 8694 case 0x10ec0257: 8695 spec->codec_variant = ALC269_TYPE_ALC257; 8696 spec->shutup = alc256_shutup; 8697 spec->init_hook = alc256_init; 8698 spec->gen.mixer_nid = 0; 8699 break; 8700 case 0x10ec0215: 8701 case 0x10ec0245: 8702 case 0x10ec0285: 8703 case 0x10ec0287: 8704 case 0x10ec0289: 8705 spec->codec_variant = ALC269_TYPE_ALC215; 8706 spec->shutup = alc225_shutup; 8707 spec->init_hook = alc225_init; 8708 spec->gen.mixer_nid = 0; 8709 break; 8710 case 0x10ec0225: 8711 case 0x10ec0295: 8712 case 0x10ec0299: 8713 spec->codec_variant = ALC269_TYPE_ALC225; 8714 spec->shutup = alc225_shutup; 8715 spec->init_hook = alc225_init; 8716 spec->gen.mixer_nid = 0; /* no loopback on ALC225, ALC295 and ALC299 */ 8717 break; 8718 case 0x10ec0234: 8719 case 0x10ec0274: 8720 case 0x10ec0294: 8721 spec->codec_variant = ALC269_TYPE_ALC294; 8722 spec->gen.mixer_nid = 0; /* ALC2x4 does not have any loopback mixer path */ 8723 alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3)); /* UAJ MIC Vref control by verb */ 8724 spec->init_hook = alc294_init; 8725 break; 8726 case 0x10ec0300: 8727 spec->codec_variant = ALC269_TYPE_ALC300; 8728 spec->gen.mixer_nid = 0; /* no loopback on ALC300 */ 8729 break; 8730 case 0x10ec0623: 8731 spec->codec_variant = ALC269_TYPE_ALC623; 8732 break; 8733 case 0x10ec0700: 8734 case 0x10ec0701: 8735 case 0x10ec0703: 8736 case 0x10ec0711: 8737 spec->codec_variant = ALC269_TYPE_ALC700; 8738 spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */ 8739 alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */ 8740 spec->init_hook = alc294_init; 8741 break; 8742 8743 } 8744 8745 if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) { 8746 spec->has_alc5505_dsp = 1; 8747 spec->init_hook = alc5505_dsp_init; 8748 } 8749 8750 alc_pre_init(codec); 8751 8752 snd_hda_pick_fixup(codec, alc269_fixup_models, 8753 alc269_fixup_tbl, alc269_fixups); 8754 snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups, true); 8755 snd_hda_pick_pin_fixup(codec, alc269_fallback_pin_fixup_tbl, alc269_fixups, false); 8756 snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl, 8757 alc269_fixups); 8758 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 8759 8760 alc_auto_parse_customize_define(codec); 8761 8762 if (has_cdefine_beep(codec)) 8763 spec->gen.beep_nid = 0x01; 8764 8765 /* automatic parse from the BIOS config */ 8766 err = alc269_parse_auto_config(codec); 8767 if (err < 0) 8768 goto error; 8769 8770 if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) { 8771 err = set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT); 8772 if (err < 0) 8773 goto error; 8774 } 8775 8776 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 8777 8778 return 0; 8779 8780 error: 8781 alc_free(codec); 8782 return err; 8783 } 8784 8785 /* 8786 * ALC861 8787 */ 8788 8789 static int alc861_parse_auto_config(struct hda_codec *codec) 8790 { 8791 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 }; 8792 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 }; 8793 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids); 8794 } 8795 8796 /* Pin config fixes */ 8797 enum { 8798 ALC861_FIXUP_FSC_AMILO_PI1505, 8799 ALC861_FIXUP_AMP_VREF_0F, 8800 ALC861_FIXUP_NO_JACK_DETECT, 8801 ALC861_FIXUP_ASUS_A6RP, 8802 ALC660_FIXUP_ASUS_W7J, 8803 }; 8804 8805 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */ 8806 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec, 8807 const struct hda_fixup *fix, int action) 8808 { 8809 struct alc_spec *spec = codec->spec; 8810 unsigned int val; 8811 8812 if (action != HDA_FIXUP_ACT_INIT) 8813 return; 8814 val = snd_hda_codec_get_pin_target(codec, 0x0f); 8815 if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))) 8816 val |= AC_PINCTL_IN_EN; 8817 val |= AC_PINCTL_VREF_50; 8818 snd_hda_set_pin_ctl(codec, 0x0f, val); 8819 spec->gen.keep_vref_in_automute = 1; 8820 } 8821 8822 /* suppress the jack-detection */ 8823 static void alc_fixup_no_jack_detect(struct hda_codec *codec, 8824 const struct hda_fixup *fix, int action) 8825 { 8826 if (action == HDA_FIXUP_ACT_PRE_PROBE) 8827 codec->no_jack_detect = 1; 8828 } 8829 8830 static const struct hda_fixup alc861_fixups[] = { 8831 [ALC861_FIXUP_FSC_AMILO_PI1505] = { 8832 .type = HDA_FIXUP_PINS, 8833 .v.pins = (const struct hda_pintbl[]) { 8834 { 0x0b, 0x0221101f }, /* HP */ 8835 { 0x0f, 0x90170310 }, /* speaker */ 8836 { } 8837 } 8838 }, 8839 [ALC861_FIXUP_AMP_VREF_0F] = { 8840 .type = HDA_FIXUP_FUNC, 8841 .v.func = alc861_fixup_asus_amp_vref_0f, 8842 }, 8843 [ALC861_FIXUP_NO_JACK_DETECT] = { 8844 .type = HDA_FIXUP_FUNC, 8845 .v.func = alc_fixup_no_jack_detect, 8846 }, 8847 [ALC861_FIXUP_ASUS_A6RP] = { 8848 .type = HDA_FIXUP_FUNC, 8849 .v.func = alc861_fixup_asus_amp_vref_0f, 8850 .chained = true, 8851 .chain_id = ALC861_FIXUP_NO_JACK_DETECT, 8852 }, 8853 [ALC660_FIXUP_ASUS_W7J] = { 8854 .type = HDA_FIXUP_VERBS, 8855 .v.verbs = (const struct hda_verb[]) { 8856 /* ASUS W7J needs a magic pin setup on unused NID 0x10 8857 * for enabling outputs 8858 */ 8859 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 8860 { } 8861 }, 8862 } 8863 }; 8864 8865 static const struct snd_pci_quirk alc861_fixup_tbl[] = { 8866 SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J), 8867 SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J), 8868 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP), 8869 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F), 8870 SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT), 8871 SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F), 8872 SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F), 8873 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505), 8874 {} 8875 }; 8876 8877 /* 8878 */ 8879 static int patch_alc861(struct hda_codec *codec) 8880 { 8881 struct alc_spec *spec; 8882 int err; 8883 8884 err = alc_alloc_spec(codec, 0x15); 8885 if (err < 0) 8886 return err; 8887 8888 spec = codec->spec; 8889 if (has_cdefine_beep(codec)) 8890 spec->gen.beep_nid = 0x23; 8891 8892 #ifdef CONFIG_PM 8893 spec->power_hook = alc_power_eapd; 8894 #endif 8895 8896 alc_pre_init(codec); 8897 8898 snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups); 8899 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 8900 8901 /* automatic parse from the BIOS config */ 8902 err = alc861_parse_auto_config(codec); 8903 if (err < 0) 8904 goto error; 8905 8906 if (!spec->gen.no_analog) { 8907 err = set_beep_amp(spec, 0x23, 0, HDA_OUTPUT); 8908 if (err < 0) 8909 goto error; 8910 } 8911 8912 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 8913 8914 return 0; 8915 8916 error: 8917 alc_free(codec); 8918 return err; 8919 } 8920 8921 /* 8922 * ALC861-VD support 8923 * 8924 * Based on ALC882 8925 * 8926 * In addition, an independent DAC 8927 */ 8928 static int alc861vd_parse_auto_config(struct hda_codec *codec) 8929 { 8930 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 }; 8931 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 8932 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids); 8933 } 8934 8935 enum { 8936 ALC660VD_FIX_ASUS_GPIO1, 8937 ALC861VD_FIX_DALLAS, 8938 }; 8939 8940 /* exclude VREF80 */ 8941 static void alc861vd_fixup_dallas(struct hda_codec *codec, 8942 const struct hda_fixup *fix, int action) 8943 { 8944 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 8945 snd_hda_override_pin_caps(codec, 0x18, 0x00000734); 8946 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c); 8947 } 8948 } 8949 8950 /* reset GPIO1 */ 8951 static void alc660vd_fixup_asus_gpio1(struct hda_codec *codec, 8952 const struct hda_fixup *fix, int action) 8953 { 8954 struct alc_spec *spec = codec->spec; 8955 8956 if (action == HDA_FIXUP_ACT_PRE_PROBE) 8957 spec->gpio_mask |= 0x02; 8958 alc_fixup_gpio(codec, action, 0x01); 8959 } 8960 8961 static const struct hda_fixup alc861vd_fixups[] = { 8962 [ALC660VD_FIX_ASUS_GPIO1] = { 8963 .type = HDA_FIXUP_FUNC, 8964 .v.func = alc660vd_fixup_asus_gpio1, 8965 }, 8966 [ALC861VD_FIX_DALLAS] = { 8967 .type = HDA_FIXUP_FUNC, 8968 .v.func = alc861vd_fixup_dallas, 8969 }, 8970 }; 8971 8972 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = { 8973 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS), 8974 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1), 8975 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS), 8976 {} 8977 }; 8978 8979 /* 8980 */ 8981 static int patch_alc861vd(struct hda_codec *codec) 8982 { 8983 struct alc_spec *spec; 8984 int err; 8985 8986 err = alc_alloc_spec(codec, 0x0b); 8987 if (err < 0) 8988 return err; 8989 8990 spec = codec->spec; 8991 if (has_cdefine_beep(codec)) 8992 spec->gen.beep_nid = 0x23; 8993 8994 spec->shutup = alc_eapd_shutup; 8995 8996 alc_pre_init(codec); 8997 8998 snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups); 8999 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 9000 9001 /* automatic parse from the BIOS config */ 9002 err = alc861vd_parse_auto_config(codec); 9003 if (err < 0) 9004 goto error; 9005 9006 if (!spec->gen.no_analog) { 9007 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 9008 if (err < 0) 9009 goto error; 9010 } 9011 9012 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 9013 9014 return 0; 9015 9016 error: 9017 alc_free(codec); 9018 return err; 9019 } 9020 9021 /* 9022 * ALC662 support 9023 * 9024 * ALC662 is almost identical with ALC880 but has cleaner and more flexible 9025 * configuration. Each pin widget can choose any input DACs and a mixer. 9026 * Each ADC is connected from a mixer of all inputs. This makes possible 9027 * 6-channel independent captures. 9028 * 9029 * In addition, an independent DAC for the multi-playback (not used in this 9030 * driver yet). 9031 */ 9032 9033 /* 9034 * BIOS auto configuration 9035 */ 9036 9037 static int alc662_parse_auto_config(struct hda_codec *codec) 9038 { 9039 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 }; 9040 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 }; 9041 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 9042 const hda_nid_t *ssids; 9043 9044 if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 || 9045 codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 || 9046 codec->core.vendor_id == 0x10ec0671) 9047 ssids = alc663_ssids; 9048 else 9049 ssids = alc662_ssids; 9050 return alc_parse_auto_config(codec, alc662_ignore, ssids); 9051 } 9052 9053 static void alc272_fixup_mario(struct hda_codec *codec, 9054 const struct hda_fixup *fix, int action) 9055 { 9056 if (action != HDA_FIXUP_ACT_PRE_PROBE) 9057 return; 9058 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT, 9059 (0x3b << AC_AMPCAP_OFFSET_SHIFT) | 9060 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) | 9061 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) | 9062 (0 << AC_AMPCAP_MUTE_SHIFT))) 9063 codec_warn(codec, "failed to override amp caps for NID 0x2\n"); 9064 } 9065 9066 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = { 9067 { .channels = 2, 9068 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } }, 9069 { .channels = 4, 9070 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, 9071 SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */ 9072 { } 9073 }; 9074 9075 /* override the 2.1 chmap */ 9076 static void alc_fixup_bass_chmap(struct hda_codec *codec, 9077 const struct hda_fixup *fix, int action) 9078 { 9079 if (action == HDA_FIXUP_ACT_BUILD) { 9080 struct alc_spec *spec = codec->spec; 9081 spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps; 9082 } 9083 } 9084 9085 /* avoid D3 for keeping GPIO up */ 9086 static unsigned int gpio_led_power_filter(struct hda_codec *codec, 9087 hda_nid_t nid, 9088 unsigned int power_state) 9089 { 9090 struct alc_spec *spec = codec->spec; 9091 if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_data) 9092 return AC_PWRST_D0; 9093 return power_state; 9094 } 9095 9096 static void alc662_fixup_led_gpio1(struct hda_codec *codec, 9097 const struct hda_fixup *fix, int action) 9098 { 9099 struct alc_spec *spec = codec->spec; 9100 9101 alc_fixup_hp_gpio_led(codec, action, 0x01, 0); 9102 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 9103 spec->mute_led_polarity = 1; 9104 codec->power_filter = gpio_led_power_filter; 9105 } 9106 } 9107 9108 static void alc662_usi_automute_hook(struct hda_codec *codec, 9109 struct hda_jack_callback *jack) 9110 { 9111 struct alc_spec *spec = codec->spec; 9112 int vref; 9113 msleep(200); 9114 snd_hda_gen_hp_automute(codec, jack); 9115 9116 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0; 9117 msleep(100); 9118 snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 9119 vref); 9120 } 9121 9122 static void alc662_fixup_usi_headset_mic(struct hda_codec *codec, 9123 const struct hda_fixup *fix, int action) 9124 { 9125 struct alc_spec *spec = codec->spec; 9126 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 9127 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 9128 spec->gen.hp_automute_hook = alc662_usi_automute_hook; 9129 } 9130 } 9131 9132 static void alc662_aspire_ethos_mute_speakers(struct hda_codec *codec, 9133 struct hda_jack_callback *cb) 9134 { 9135 /* surround speakers at 0x1b already get muted automatically when 9136 * headphones are plugged in, but we have to mute/unmute the remaining 9137 * channels manually: 9138 * 0x15 - front left/front right 9139 * 0x18 - front center/ LFE 9140 */ 9141 if (snd_hda_jack_detect_state(codec, 0x1b) == HDA_JACK_PRESENT) { 9142 snd_hda_set_pin_ctl_cache(codec, 0x15, 0); 9143 snd_hda_set_pin_ctl_cache(codec, 0x18, 0); 9144 } else { 9145 snd_hda_set_pin_ctl_cache(codec, 0x15, PIN_OUT); 9146 snd_hda_set_pin_ctl_cache(codec, 0x18, PIN_OUT); 9147 } 9148 } 9149 9150 static void alc662_fixup_aspire_ethos_hp(struct hda_codec *codec, 9151 const struct hda_fixup *fix, int action) 9152 { 9153 /* Pin 0x1b: shared headphones jack and surround speakers */ 9154 if (!is_jack_detectable(codec, 0x1b)) 9155 return; 9156 9157 switch (action) { 9158 case HDA_FIXUP_ACT_PRE_PROBE: 9159 snd_hda_jack_detect_enable_callback(codec, 0x1b, 9160 alc662_aspire_ethos_mute_speakers); 9161 /* subwoofer needs an extra GPIO setting to become audible */ 9162 alc_setup_gpio(codec, 0x02); 9163 break; 9164 case HDA_FIXUP_ACT_INIT: 9165 /* Make sure to start in a correct state, i.e. if 9166 * headphones have been plugged in before powering up the system 9167 */ 9168 alc662_aspire_ethos_mute_speakers(codec, NULL); 9169 break; 9170 } 9171 } 9172 9173 static void alc671_fixup_hp_headset_mic2(struct hda_codec *codec, 9174 const struct hda_fixup *fix, int action) 9175 { 9176 struct alc_spec *spec = codec->spec; 9177 9178 static const struct hda_pintbl pincfgs[] = { 9179 { 0x19, 0x02a11040 }, /* use as headset mic, with its own jack detect */ 9180 { 0x1b, 0x0181304f }, 9181 { } 9182 }; 9183 9184 switch (action) { 9185 case HDA_FIXUP_ACT_PRE_PROBE: 9186 spec->gen.mixer_nid = 0; 9187 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 9188 snd_hda_apply_pincfgs(codec, pincfgs); 9189 break; 9190 case HDA_FIXUP_ACT_INIT: 9191 alc_write_coef_idx(codec, 0x19, 0xa054); 9192 break; 9193 } 9194 } 9195 9196 static const struct coef_fw alc668_coefs[] = { 9197 WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03, 0x0), 9198 WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06, 0x0), WRITE_COEF(0x07, 0x0f80), 9199 WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b, 0x0), 9200 WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f), 9201 WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001), 9202 WRITE_COEF(0x13, 0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940), 9203 WRITE_COEF(0x19, 0x0), WRITE_COEF(0x1a, 0x0), WRITE_COEF(0x1b, 0x0), 9204 WRITE_COEF(0x1c, 0x0), WRITE_COEF(0x1d, 0x0), WRITE_COEF(0x1e, 0x7418), 9205 WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468), 9206 WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418), 9207 WRITE_COEF(0x27, 0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00), 9208 WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000), 9209 WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac, 0x0), 9210 WRITE_COEF(0xad, 0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480), 9211 WRITE_COEF(0xb0, 0x0), WRITE_COEF(0xb1, 0x0), WRITE_COEF(0xb2, 0x0), 9212 WRITE_COEF(0xb3, 0x0), WRITE_COEF(0xb4, 0x0), WRITE_COEF(0xb5, 0x1040), 9213 WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697), 9214 WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab), 9215 WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02), 9216 WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6), 9217 {} 9218 }; 9219 9220 static void alc668_restore_default_value(struct hda_codec *codec) 9221 { 9222 alc_process_coef_fw(codec, alc668_coefs); 9223 } 9224 9225 enum { 9226 ALC662_FIXUP_ASPIRE, 9227 ALC662_FIXUP_LED_GPIO1, 9228 ALC662_FIXUP_IDEAPAD, 9229 ALC272_FIXUP_MARIO, 9230 ALC662_FIXUP_CZC_ET26, 9231 ALC662_FIXUP_CZC_P10T, 9232 ALC662_FIXUP_SKU_IGNORE, 9233 ALC662_FIXUP_HP_RP5800, 9234 ALC662_FIXUP_ASUS_MODE1, 9235 ALC662_FIXUP_ASUS_MODE2, 9236 ALC662_FIXUP_ASUS_MODE3, 9237 ALC662_FIXUP_ASUS_MODE4, 9238 ALC662_FIXUP_ASUS_MODE5, 9239 ALC662_FIXUP_ASUS_MODE6, 9240 ALC662_FIXUP_ASUS_MODE7, 9241 ALC662_FIXUP_ASUS_MODE8, 9242 ALC662_FIXUP_NO_JACK_DETECT, 9243 ALC662_FIXUP_ZOTAC_Z68, 9244 ALC662_FIXUP_INV_DMIC, 9245 ALC662_FIXUP_DELL_MIC_NO_PRESENCE, 9246 ALC668_FIXUP_DELL_MIC_NO_PRESENCE, 9247 ALC662_FIXUP_HEADSET_MODE, 9248 ALC668_FIXUP_HEADSET_MODE, 9249 ALC662_FIXUP_BASS_MODE4_CHMAP, 9250 ALC662_FIXUP_BASS_16, 9251 ALC662_FIXUP_BASS_1A, 9252 ALC662_FIXUP_BASS_CHMAP, 9253 ALC668_FIXUP_AUTO_MUTE, 9254 ALC668_FIXUP_DELL_DISABLE_AAMIX, 9255 ALC668_FIXUP_DELL_XPS13, 9256 ALC662_FIXUP_ASUS_Nx50, 9257 ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE, 9258 ALC668_FIXUP_ASUS_Nx51, 9259 ALC668_FIXUP_MIC_COEF, 9260 ALC668_FIXUP_ASUS_G751, 9261 ALC891_FIXUP_HEADSET_MODE, 9262 ALC891_FIXUP_DELL_MIC_NO_PRESENCE, 9263 ALC662_FIXUP_ACER_VERITON, 9264 ALC892_FIXUP_ASROCK_MOBO, 9265 ALC662_FIXUP_USI_FUNC, 9266 ALC662_FIXUP_USI_HEADSET_MODE, 9267 ALC662_FIXUP_LENOVO_MULTI_CODECS, 9268 ALC669_FIXUP_ACER_ASPIRE_ETHOS, 9269 ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET, 9270 ALC671_FIXUP_HP_HEADSET_MIC2, 9271 ALC662_FIXUP_ACER_X2660G_HEADSET_MODE, 9272 ALC662_FIXUP_ACER_NITRO_HEADSET_MODE, 9273 }; 9274 9275 static const struct hda_fixup alc662_fixups[] = { 9276 [ALC662_FIXUP_ASPIRE] = { 9277 .type = HDA_FIXUP_PINS, 9278 .v.pins = (const struct hda_pintbl[]) { 9279 { 0x15, 0x99130112 }, /* subwoofer */ 9280 { } 9281 } 9282 }, 9283 [ALC662_FIXUP_LED_GPIO1] = { 9284 .type = HDA_FIXUP_FUNC, 9285 .v.func = alc662_fixup_led_gpio1, 9286 }, 9287 [ALC662_FIXUP_IDEAPAD] = { 9288 .type = HDA_FIXUP_PINS, 9289 .v.pins = (const struct hda_pintbl[]) { 9290 { 0x17, 0x99130112 }, /* subwoofer */ 9291 { } 9292 }, 9293 .chained = true, 9294 .chain_id = ALC662_FIXUP_LED_GPIO1, 9295 }, 9296 [ALC272_FIXUP_MARIO] = { 9297 .type = HDA_FIXUP_FUNC, 9298 .v.func = alc272_fixup_mario, 9299 }, 9300 [ALC662_FIXUP_CZC_ET26] = { 9301 .type = HDA_FIXUP_PINS, 9302 .v.pins = (const struct hda_pintbl[]) { 9303 {0x12, 0x403cc000}, 9304 {0x14, 0x90170110}, /* speaker */ 9305 {0x15, 0x411111f0}, 9306 {0x16, 0x411111f0}, 9307 {0x18, 0x01a19030}, /* mic */ 9308 {0x19, 0x90a7013f}, /* int-mic */ 9309 {0x1a, 0x01014020}, 9310 {0x1b, 0x0121401f}, 9311 {0x1c, 0x411111f0}, 9312 {0x1d, 0x411111f0}, 9313 {0x1e, 0x40478e35}, 9314 {} 9315 }, 9316 .chained = true, 9317 .chain_id = ALC662_FIXUP_SKU_IGNORE 9318 }, 9319 [ALC662_FIXUP_CZC_P10T] = { 9320 .type = HDA_FIXUP_VERBS, 9321 .v.verbs = (const struct hda_verb[]) { 9322 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0}, 9323 {} 9324 } 9325 }, 9326 [ALC662_FIXUP_SKU_IGNORE] = { 9327 .type = HDA_FIXUP_FUNC, 9328 .v.func = alc_fixup_sku_ignore, 9329 }, 9330 [ALC662_FIXUP_HP_RP5800] = { 9331 .type = HDA_FIXUP_PINS, 9332 .v.pins = (const struct hda_pintbl[]) { 9333 { 0x14, 0x0221201f }, /* HP out */ 9334 { } 9335 }, 9336 .chained = true, 9337 .chain_id = ALC662_FIXUP_SKU_IGNORE 9338 }, 9339 [ALC662_FIXUP_ASUS_MODE1] = { 9340 .type = HDA_FIXUP_PINS, 9341 .v.pins = (const struct hda_pintbl[]) { 9342 { 0x14, 0x99130110 }, /* speaker */ 9343 { 0x18, 0x01a19c20 }, /* mic */ 9344 { 0x19, 0x99a3092f }, /* int-mic */ 9345 { 0x21, 0x0121401f }, /* HP out */ 9346 { } 9347 }, 9348 .chained = true, 9349 .chain_id = ALC662_FIXUP_SKU_IGNORE 9350 }, 9351 [ALC662_FIXUP_ASUS_MODE2] = { 9352 .type = HDA_FIXUP_PINS, 9353 .v.pins = (const struct hda_pintbl[]) { 9354 { 0x14, 0x99130110 }, /* speaker */ 9355 { 0x18, 0x01a19820 }, /* mic */ 9356 { 0x19, 0x99a3092f }, /* int-mic */ 9357 { 0x1b, 0x0121401f }, /* HP out */ 9358 { } 9359 }, 9360 .chained = true, 9361 .chain_id = ALC662_FIXUP_SKU_IGNORE 9362 }, 9363 [ALC662_FIXUP_ASUS_MODE3] = { 9364 .type = HDA_FIXUP_PINS, 9365 .v.pins = (const struct hda_pintbl[]) { 9366 { 0x14, 0x99130110 }, /* speaker */ 9367 { 0x15, 0x0121441f }, /* HP */ 9368 { 0x18, 0x01a19840 }, /* mic */ 9369 { 0x19, 0x99a3094f }, /* int-mic */ 9370 { 0x21, 0x01211420 }, /* HP2 */ 9371 { } 9372 }, 9373 .chained = true, 9374 .chain_id = ALC662_FIXUP_SKU_IGNORE 9375 }, 9376 [ALC662_FIXUP_ASUS_MODE4] = { 9377 .type = HDA_FIXUP_PINS, 9378 .v.pins = (const struct hda_pintbl[]) { 9379 { 0x14, 0x99130110 }, /* speaker */ 9380 { 0x16, 0x99130111 }, /* speaker */ 9381 { 0x18, 0x01a19840 }, /* mic */ 9382 { 0x19, 0x99a3094f }, /* int-mic */ 9383 { 0x21, 0x0121441f }, /* HP */ 9384 { } 9385 }, 9386 .chained = true, 9387 .chain_id = ALC662_FIXUP_SKU_IGNORE 9388 }, 9389 [ALC662_FIXUP_ASUS_MODE5] = { 9390 .type = HDA_FIXUP_PINS, 9391 .v.pins = (const struct hda_pintbl[]) { 9392 { 0x14, 0x99130110 }, /* speaker */ 9393 { 0x15, 0x0121441f }, /* HP */ 9394 { 0x16, 0x99130111 }, /* speaker */ 9395 { 0x18, 0x01a19840 }, /* mic */ 9396 { 0x19, 0x99a3094f }, /* int-mic */ 9397 { } 9398 }, 9399 .chained = true, 9400 .chain_id = ALC662_FIXUP_SKU_IGNORE 9401 }, 9402 [ALC662_FIXUP_ASUS_MODE6] = { 9403 .type = HDA_FIXUP_PINS, 9404 .v.pins = (const struct hda_pintbl[]) { 9405 { 0x14, 0x99130110 }, /* speaker */ 9406 { 0x15, 0x01211420 }, /* HP2 */ 9407 { 0x18, 0x01a19840 }, /* mic */ 9408 { 0x19, 0x99a3094f }, /* int-mic */ 9409 { 0x1b, 0x0121441f }, /* HP */ 9410 { } 9411 }, 9412 .chained = true, 9413 .chain_id = ALC662_FIXUP_SKU_IGNORE 9414 }, 9415 [ALC662_FIXUP_ASUS_MODE7] = { 9416 .type = HDA_FIXUP_PINS, 9417 .v.pins = (const struct hda_pintbl[]) { 9418 { 0x14, 0x99130110 }, /* speaker */ 9419 { 0x17, 0x99130111 }, /* speaker */ 9420 { 0x18, 0x01a19840 }, /* mic */ 9421 { 0x19, 0x99a3094f }, /* int-mic */ 9422 { 0x1b, 0x01214020 }, /* HP */ 9423 { 0x21, 0x0121401f }, /* HP */ 9424 { } 9425 }, 9426 .chained = true, 9427 .chain_id = ALC662_FIXUP_SKU_IGNORE 9428 }, 9429 [ALC662_FIXUP_ASUS_MODE8] = { 9430 .type = HDA_FIXUP_PINS, 9431 .v.pins = (const struct hda_pintbl[]) { 9432 { 0x14, 0x99130110 }, /* speaker */ 9433 { 0x12, 0x99a30970 }, /* int-mic */ 9434 { 0x15, 0x01214020 }, /* HP */ 9435 { 0x17, 0x99130111 }, /* speaker */ 9436 { 0x18, 0x01a19840 }, /* mic */ 9437 { 0x21, 0x0121401f }, /* HP */ 9438 { } 9439 }, 9440 .chained = true, 9441 .chain_id = ALC662_FIXUP_SKU_IGNORE 9442 }, 9443 [ALC662_FIXUP_NO_JACK_DETECT] = { 9444 .type = HDA_FIXUP_FUNC, 9445 .v.func = alc_fixup_no_jack_detect, 9446 }, 9447 [ALC662_FIXUP_ZOTAC_Z68] = { 9448 .type = HDA_FIXUP_PINS, 9449 .v.pins = (const struct hda_pintbl[]) { 9450 { 0x1b, 0x02214020 }, /* Front HP */ 9451 { } 9452 } 9453 }, 9454 [ALC662_FIXUP_INV_DMIC] = { 9455 .type = HDA_FIXUP_FUNC, 9456 .v.func = alc_fixup_inv_dmic, 9457 }, 9458 [ALC668_FIXUP_DELL_XPS13] = { 9459 .type = HDA_FIXUP_FUNC, 9460 .v.func = alc_fixup_dell_xps13, 9461 .chained = true, 9462 .chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX 9463 }, 9464 [ALC668_FIXUP_DELL_DISABLE_AAMIX] = { 9465 .type = HDA_FIXUP_FUNC, 9466 .v.func = alc_fixup_disable_aamix, 9467 .chained = true, 9468 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE 9469 }, 9470 [ALC668_FIXUP_AUTO_MUTE] = { 9471 .type = HDA_FIXUP_FUNC, 9472 .v.func = alc_fixup_auto_mute_via_amp, 9473 .chained = true, 9474 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE 9475 }, 9476 [ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = { 9477 .type = HDA_FIXUP_PINS, 9478 .v.pins = (const struct hda_pintbl[]) { 9479 { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */ 9480 /* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */ 9481 { } 9482 }, 9483 .chained = true, 9484 .chain_id = ALC662_FIXUP_HEADSET_MODE 9485 }, 9486 [ALC662_FIXUP_HEADSET_MODE] = { 9487 .type = HDA_FIXUP_FUNC, 9488 .v.func = alc_fixup_headset_mode_alc662, 9489 }, 9490 [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = { 9491 .type = HDA_FIXUP_PINS, 9492 .v.pins = (const struct hda_pintbl[]) { 9493 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */ 9494 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */ 9495 { } 9496 }, 9497 .chained = true, 9498 .chain_id = ALC668_FIXUP_HEADSET_MODE 9499 }, 9500 [ALC668_FIXUP_HEADSET_MODE] = { 9501 .type = HDA_FIXUP_FUNC, 9502 .v.func = alc_fixup_headset_mode_alc668, 9503 }, 9504 [ALC662_FIXUP_BASS_MODE4_CHMAP] = { 9505 .type = HDA_FIXUP_FUNC, 9506 .v.func = alc_fixup_bass_chmap, 9507 .chained = true, 9508 .chain_id = ALC662_FIXUP_ASUS_MODE4 9509 }, 9510 [ALC662_FIXUP_BASS_16] = { 9511 .type = HDA_FIXUP_PINS, 9512 .v.pins = (const struct hda_pintbl[]) { 9513 {0x16, 0x80106111}, /* bass speaker */ 9514 {} 9515 }, 9516 .chained = true, 9517 .chain_id = ALC662_FIXUP_BASS_CHMAP, 9518 }, 9519 [ALC662_FIXUP_BASS_1A] = { 9520 .type = HDA_FIXUP_PINS, 9521 .v.pins = (const struct hda_pintbl[]) { 9522 {0x1a, 0x80106111}, /* bass speaker */ 9523 {} 9524 }, 9525 .chained = true, 9526 .chain_id = ALC662_FIXUP_BASS_CHMAP, 9527 }, 9528 [ALC662_FIXUP_BASS_CHMAP] = { 9529 .type = HDA_FIXUP_FUNC, 9530 .v.func = alc_fixup_bass_chmap, 9531 }, 9532 [ALC662_FIXUP_ASUS_Nx50] = { 9533 .type = HDA_FIXUP_FUNC, 9534 .v.func = alc_fixup_auto_mute_via_amp, 9535 .chained = true, 9536 .chain_id = ALC662_FIXUP_BASS_1A 9537 }, 9538 [ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = { 9539 .type = HDA_FIXUP_FUNC, 9540 .v.func = alc_fixup_headset_mode_alc668, 9541 .chain_id = ALC662_FIXUP_BASS_CHMAP 9542 }, 9543 [ALC668_FIXUP_ASUS_Nx51] = { 9544 .type = HDA_FIXUP_PINS, 9545 .v.pins = (const struct hda_pintbl[]) { 9546 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */ 9547 { 0x1a, 0x90170151 }, /* bass speaker */ 9548 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */ 9549 {} 9550 }, 9551 .chained = true, 9552 .chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE, 9553 }, 9554 [ALC668_FIXUP_MIC_COEF] = { 9555 .type = HDA_FIXUP_VERBS, 9556 .v.verbs = (const struct hda_verb[]) { 9557 { 0x20, AC_VERB_SET_COEF_INDEX, 0xc3 }, 9558 { 0x20, AC_VERB_SET_PROC_COEF, 0x4000 }, 9559 {} 9560 }, 9561 }, 9562 [ALC668_FIXUP_ASUS_G751] = { 9563 .type = HDA_FIXUP_PINS, 9564 .v.pins = (const struct hda_pintbl[]) { 9565 { 0x16, 0x0421101f }, /* HP */ 9566 {} 9567 }, 9568 .chained = true, 9569 .chain_id = ALC668_FIXUP_MIC_COEF 9570 }, 9571 [ALC891_FIXUP_HEADSET_MODE] = { 9572 .type = HDA_FIXUP_FUNC, 9573 .v.func = alc_fixup_headset_mode, 9574 }, 9575 [ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = { 9576 .type = HDA_FIXUP_PINS, 9577 .v.pins = (const struct hda_pintbl[]) { 9578 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */ 9579 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */ 9580 { } 9581 }, 9582 .chained = true, 9583 .chain_id = ALC891_FIXUP_HEADSET_MODE 9584 }, 9585 [ALC662_FIXUP_ACER_VERITON] = { 9586 .type = HDA_FIXUP_PINS, 9587 .v.pins = (const struct hda_pintbl[]) { 9588 { 0x15, 0x50170120 }, /* no internal speaker */ 9589 { } 9590 } 9591 }, 9592 [ALC892_FIXUP_ASROCK_MOBO] = { 9593 .type = HDA_FIXUP_PINS, 9594 .v.pins = (const struct hda_pintbl[]) { 9595 { 0x15, 0x40f000f0 }, /* disabled */ 9596 { 0x16, 0x40f000f0 }, /* disabled */ 9597 { } 9598 } 9599 }, 9600 [ALC662_FIXUP_USI_FUNC] = { 9601 .type = HDA_FIXUP_FUNC, 9602 .v.func = alc662_fixup_usi_headset_mic, 9603 }, 9604 [ALC662_FIXUP_USI_HEADSET_MODE] = { 9605 .type = HDA_FIXUP_PINS, 9606 .v.pins = (const struct hda_pintbl[]) { 9607 { 0x19, 0x02a1913c }, /* use as headset mic, without its own jack detect */ 9608 { 0x18, 0x01a1903d }, 9609 { } 9610 }, 9611 .chained = true, 9612 .chain_id = ALC662_FIXUP_USI_FUNC 9613 }, 9614 [ALC662_FIXUP_LENOVO_MULTI_CODECS] = { 9615 .type = HDA_FIXUP_FUNC, 9616 .v.func = alc233_alc662_fixup_lenovo_dual_codecs, 9617 }, 9618 [ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET] = { 9619 .type = HDA_FIXUP_FUNC, 9620 .v.func = alc662_fixup_aspire_ethos_hp, 9621 }, 9622 [ALC669_FIXUP_ACER_ASPIRE_ETHOS] = { 9623 .type = HDA_FIXUP_PINS, 9624 .v.pins = (const struct hda_pintbl[]) { 9625 { 0x15, 0x92130110 }, /* front speakers */ 9626 { 0x18, 0x99130111 }, /* center/subwoofer */ 9627 { 0x1b, 0x11130012 }, /* surround plus jack for HP */ 9628 { } 9629 }, 9630 .chained = true, 9631 .chain_id = ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET 9632 }, 9633 [ALC671_FIXUP_HP_HEADSET_MIC2] = { 9634 .type = HDA_FIXUP_FUNC, 9635 .v.func = alc671_fixup_hp_headset_mic2, 9636 }, 9637 [ALC662_FIXUP_ACER_X2660G_HEADSET_MODE] = { 9638 .type = HDA_FIXUP_PINS, 9639 .v.pins = (const struct hda_pintbl[]) { 9640 { 0x1a, 0x02a1113c }, /* use as headset mic, without its own jack detect */ 9641 { } 9642 }, 9643 .chained = true, 9644 .chain_id = ALC662_FIXUP_USI_FUNC 9645 }, 9646 [ALC662_FIXUP_ACER_NITRO_HEADSET_MODE] = { 9647 .type = HDA_FIXUP_PINS, 9648 .v.pins = (const struct hda_pintbl[]) { 9649 { 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */ 9650 { 0x1b, 0x0221144f }, 9651 { } 9652 }, 9653 .chained = true, 9654 .chain_id = ALC662_FIXUP_USI_FUNC 9655 }, 9656 }; 9657 9658 static const struct snd_pci_quirk alc662_fixup_tbl[] = { 9659 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2), 9660 SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC), 9661 SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC), 9662 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE), 9663 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE), 9664 SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC), 9665 SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC), 9666 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE), 9667 SND_PCI_QUIRK(0x1025, 0x123c, "Acer Nitro N50-600", ALC662_FIXUP_ACER_NITRO_HEADSET_MODE), 9668 SND_PCI_QUIRK(0x1025, 0x124e, "Acer 2660G", ALC662_FIXUP_ACER_X2660G_HEADSET_MODE), 9669 SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 9670 SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 9671 SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13), 9672 SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13), 9673 SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13), 9674 SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 9675 SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 9676 SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 9677 SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 9678 SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 9679 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800), 9680 SND_PCI_QUIRK(0x103c, 0x873e, "HP", ALC671_FIXUP_HP_HEADSET_MIC2), 9681 SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE), 9682 SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50), 9683 SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A), 9684 SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50), 9685 SND_PCI_QUIRK(0x1043, 0x12ff, "ASUS G751", ALC668_FIXUP_ASUS_G751), 9686 SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP), 9687 SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16), 9688 SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51), 9689 SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51), 9690 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8), 9691 SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16), 9692 SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP), 9693 SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT), 9694 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2), 9695 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD), 9696 SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE), 9697 SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS), 9698 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD), 9699 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD), 9700 SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO), 9701 SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68), 9702 SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON), 9703 SND_PCI_QUIRK(0x1b35, 0x1234, "CZC ET26", ALC662_FIXUP_CZC_ET26), 9704 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T), 9705 SND_PCI_QUIRK(0x1025, 0x0566, "Acer Aspire Ethos 8951G", ALC669_FIXUP_ACER_ASPIRE_ETHOS), 9706 9707 #if 0 9708 /* Below is a quirk table taken from the old code. 9709 * Basically the device should work as is without the fixup table. 9710 * If BIOS doesn't give a proper info, enable the corresponding 9711 * fixup entry. 9712 */ 9713 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1), 9714 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3), 9715 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1), 9716 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3), 9717 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 9718 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 9719 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 9720 SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1), 9721 SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1), 9722 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 9723 SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7), 9724 SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7), 9725 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8), 9726 SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3), 9727 SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1), 9728 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 9729 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2), 9730 SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1), 9731 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 9732 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6), 9733 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6), 9734 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 9735 SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1), 9736 SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3), 9737 SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2), 9738 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 9739 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5), 9740 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6), 9741 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 9742 SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1), 9743 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 9744 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 9745 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3), 9746 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3), 9747 SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1), 9748 SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1), 9749 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1), 9750 SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1), 9751 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1), 9752 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 9753 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2), 9754 SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1), 9755 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 9756 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3), 9757 SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1), 9758 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1), 9759 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1), 9760 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2), 9761 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 9762 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4), 9763 #endif 9764 {} 9765 }; 9766 9767 static const struct hda_model_fixup alc662_fixup_models[] = { 9768 {.id = ALC662_FIXUP_ASPIRE, .name = "aspire"}, 9769 {.id = ALC662_FIXUP_IDEAPAD, .name = "ideapad"}, 9770 {.id = ALC272_FIXUP_MARIO, .name = "mario"}, 9771 {.id = ALC662_FIXUP_HP_RP5800, .name = "hp-rp5800"}, 9772 {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"}, 9773 {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"}, 9774 {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"}, 9775 {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"}, 9776 {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"}, 9777 {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"}, 9778 {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"}, 9779 {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"}, 9780 {.id = ALC662_FIXUP_ZOTAC_Z68, .name = "zotac-z68"}, 9781 {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"}, 9782 {.id = ALC662_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc662-headset-multi"}, 9783 {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"}, 9784 {.id = ALC662_FIXUP_HEADSET_MODE, .name = "alc662-headset"}, 9785 {.id = ALC668_FIXUP_HEADSET_MODE, .name = "alc668-headset"}, 9786 {.id = ALC662_FIXUP_BASS_16, .name = "bass16"}, 9787 {.id = ALC662_FIXUP_BASS_1A, .name = "bass1a"}, 9788 {.id = ALC668_FIXUP_AUTO_MUTE, .name = "automute"}, 9789 {.id = ALC668_FIXUP_DELL_XPS13, .name = "dell-xps13"}, 9790 {.id = ALC662_FIXUP_ASUS_Nx50, .name = "asus-nx50"}, 9791 {.id = ALC668_FIXUP_ASUS_Nx51, .name = "asus-nx51"}, 9792 {.id = ALC668_FIXUP_ASUS_G751, .name = "asus-g751"}, 9793 {.id = ALC891_FIXUP_HEADSET_MODE, .name = "alc891-headset"}, 9794 {.id = ALC891_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc891-headset-multi"}, 9795 {.id = ALC662_FIXUP_ACER_VERITON, .name = "acer-veriton"}, 9796 {.id = ALC892_FIXUP_ASROCK_MOBO, .name = "asrock-mobo"}, 9797 {.id = ALC662_FIXUP_USI_HEADSET_MODE, .name = "usi-headset"}, 9798 {.id = ALC662_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"}, 9799 {.id = ALC669_FIXUP_ACER_ASPIRE_ETHOS, .name = "aspire-ethos"}, 9800 {} 9801 }; 9802 9803 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = { 9804 SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE, 9805 {0x17, 0x02211010}, 9806 {0x18, 0x01a19030}, 9807 {0x1a, 0x01813040}, 9808 {0x21, 0x01014020}), 9809 SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE, 9810 {0x16, 0x01813030}, 9811 {0x17, 0x02211010}, 9812 {0x18, 0x01a19040}, 9813 {0x21, 0x01014020}), 9814 SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE, 9815 {0x14, 0x01014010}, 9816 {0x18, 0x01a19020}, 9817 {0x1a, 0x0181302f}, 9818 {0x1b, 0x0221401f}), 9819 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE, 9820 {0x12, 0x99a30130}, 9821 {0x14, 0x90170110}, 9822 {0x15, 0x0321101f}, 9823 {0x16, 0x03011020}), 9824 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE, 9825 {0x12, 0x99a30140}, 9826 {0x14, 0x90170110}, 9827 {0x15, 0x0321101f}, 9828 {0x16, 0x03011020}), 9829 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE, 9830 {0x12, 0x99a30150}, 9831 {0x14, 0x90170110}, 9832 {0x15, 0x0321101f}, 9833 {0x16, 0x03011020}), 9834 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE, 9835 {0x14, 0x90170110}, 9836 {0x15, 0x0321101f}, 9837 {0x16, 0x03011020}), 9838 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE, 9839 {0x12, 0x90a60130}, 9840 {0x14, 0x90170110}, 9841 {0x15, 0x0321101f}), 9842 SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2, 9843 {0x14, 0x01014010}, 9844 {0x17, 0x90170150}, 9845 {0x19, 0x02a11060}, 9846 {0x1b, 0x01813030}, 9847 {0x21, 0x02211020}), 9848 SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2, 9849 {0x14, 0x01014010}, 9850 {0x18, 0x01a19040}, 9851 {0x1b, 0x01813030}, 9852 {0x21, 0x02211020}), 9853 SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2, 9854 {0x14, 0x01014020}, 9855 {0x17, 0x90170110}, 9856 {0x18, 0x01a19050}, 9857 {0x1b, 0x01813040}, 9858 {0x21, 0x02211030}), 9859 {} 9860 }; 9861 9862 /* 9863 */ 9864 static int patch_alc662(struct hda_codec *codec) 9865 { 9866 struct alc_spec *spec; 9867 int err; 9868 9869 err = alc_alloc_spec(codec, 0x0b); 9870 if (err < 0) 9871 return err; 9872 9873 spec = codec->spec; 9874 9875 spec->shutup = alc_eapd_shutup; 9876 9877 /* handle multiple HPs as is */ 9878 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 9879 9880 alc_fix_pll_init(codec, 0x20, 0x04, 15); 9881 9882 switch (codec->core.vendor_id) { 9883 case 0x10ec0668: 9884 spec->init_hook = alc668_restore_default_value; 9885 break; 9886 } 9887 9888 alc_pre_init(codec); 9889 9890 snd_hda_pick_fixup(codec, alc662_fixup_models, 9891 alc662_fixup_tbl, alc662_fixups); 9892 snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups, true); 9893 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 9894 9895 alc_auto_parse_customize_define(codec); 9896 9897 if (has_cdefine_beep(codec)) 9898 spec->gen.beep_nid = 0x01; 9899 9900 if ((alc_get_coef0(codec) & (1 << 14)) && 9901 codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 && 9902 spec->cdefine.platform_type == 1) { 9903 err = alc_codec_rename(codec, "ALC272X"); 9904 if (err < 0) 9905 goto error; 9906 } 9907 9908 /* automatic parse from the BIOS config */ 9909 err = alc662_parse_auto_config(codec); 9910 if (err < 0) 9911 goto error; 9912 9913 if (!spec->gen.no_analog && spec->gen.beep_nid) { 9914 switch (codec->core.vendor_id) { 9915 case 0x10ec0662: 9916 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 9917 break; 9918 case 0x10ec0272: 9919 case 0x10ec0663: 9920 case 0x10ec0665: 9921 case 0x10ec0668: 9922 err = set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT); 9923 break; 9924 case 0x10ec0273: 9925 err = set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT); 9926 break; 9927 } 9928 if (err < 0) 9929 goto error; 9930 } 9931 9932 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 9933 9934 return 0; 9935 9936 error: 9937 alc_free(codec); 9938 return err; 9939 } 9940 9941 /* 9942 * ALC680 support 9943 */ 9944 9945 static int alc680_parse_auto_config(struct hda_codec *codec) 9946 { 9947 return alc_parse_auto_config(codec, NULL, NULL); 9948 } 9949 9950 /* 9951 */ 9952 static int patch_alc680(struct hda_codec *codec) 9953 { 9954 int err; 9955 9956 /* ALC680 has no aa-loopback mixer */ 9957 err = alc_alloc_spec(codec, 0); 9958 if (err < 0) 9959 return err; 9960 9961 /* automatic parse from the BIOS config */ 9962 err = alc680_parse_auto_config(codec); 9963 if (err < 0) { 9964 alc_free(codec); 9965 return err; 9966 } 9967 9968 return 0; 9969 } 9970 9971 /* 9972 * patch entries 9973 */ 9974 static const struct hda_device_id snd_hda_id_realtek[] = { 9975 HDA_CODEC_ENTRY(0x10ec0215, "ALC215", patch_alc269), 9976 HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269), 9977 HDA_CODEC_ENTRY(0x10ec0222, "ALC222", patch_alc269), 9978 HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269), 9979 HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269), 9980 HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269), 9981 HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269), 9982 HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269), 9983 HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269), 9984 HDA_CODEC_ENTRY(0x10ec0245, "ALC245", patch_alc269), 9985 HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269), 9986 HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269), 9987 HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269), 9988 HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260), 9989 HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262), 9990 HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268), 9991 HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268), 9992 HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269), 9993 HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269), 9994 HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662), 9995 HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269), 9996 HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269), 9997 HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269), 9998 HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269), 9999 HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269), 10000 HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269), 10001 HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269), 10002 HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269), 10003 HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269), 10004 HDA_CODEC_ENTRY(0x10ec0287, "ALC287", patch_alc269), 10005 HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269), 10006 HDA_CODEC_ENTRY(0x10ec0289, "ALC289", patch_alc269), 10007 HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269), 10008 HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269), 10009 HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269), 10010 HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269), 10011 HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269), 10012 HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269), 10013 HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269), 10014 HDA_CODEC_ENTRY(0x10ec0300, "ALC300", patch_alc269), 10015 HDA_CODEC_ENTRY(0x10ec0623, "ALC623", patch_alc269), 10016 HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861), 10017 HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd), 10018 HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861), 10019 HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd), 10020 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882), 10021 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662), 10022 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662), 10023 HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662), 10024 HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662), 10025 HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662), 10026 HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662), 10027 HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662), 10028 HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662), 10029 HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680), 10030 HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269), 10031 HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269), 10032 HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269), 10033 HDA_CODEC_ENTRY(0x10ec0711, "ALC711", patch_alc269), 10034 HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662), 10035 HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880), 10036 HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882), 10037 HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882), 10038 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882), 10039 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882), 10040 HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882), 10041 HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882), 10042 HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882), 10043 HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882), 10044 HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882), 10045 HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662), 10046 HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882), 10047 HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882), 10048 HDA_CODEC_ENTRY(0x10ec0b00, "ALCS1200A", patch_alc882), 10049 HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882), 10050 HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882), 10051 {} /* terminator */ 10052 }; 10053 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek); 10054 10055 MODULE_LICENSE("GPL"); 10056 MODULE_DESCRIPTION("Realtek HD-audio codec"); 10057 10058 static struct hda_codec_driver realtek_driver = { 10059 .id = snd_hda_id_realtek, 10060 }; 10061 10062 module_hda_codec_driver(realtek_driver); 10063