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/acpi.h> 14 #include <linux/cleanup.h> 15 #include <linux/init.h> 16 #include <linux/delay.h> 17 #include <linux/slab.h> 18 #include <linux/pci.h> 19 #include <linux/dmi.h> 20 #include <linux/module.h> 21 #include <linux/i2c.h> 22 #include <linux/input.h> 23 #include <linux/leds.h> 24 #include <linux/ctype.h> 25 #include <linux/spi/spi.h> 26 #include <sound/core.h> 27 #include <sound/jack.h> 28 #include <sound/hda_codec.h> 29 #include "hda_local.h" 30 #include "hda_auto_parser.h" 31 #include "hda_jack.h" 32 #include "hda_generic.h" 33 #include "hda_component.h" 34 35 /* keep halting ALC5505 DSP, for power saving */ 36 #define HALT_REALTEK_ALC5505 37 38 /* extra amp-initialization sequence types */ 39 enum { 40 ALC_INIT_UNDEFINED, 41 ALC_INIT_NONE, 42 ALC_INIT_DEFAULT, 43 }; 44 45 enum { 46 ALC_HEADSET_MODE_UNKNOWN, 47 ALC_HEADSET_MODE_UNPLUGGED, 48 ALC_HEADSET_MODE_HEADSET, 49 ALC_HEADSET_MODE_MIC, 50 ALC_HEADSET_MODE_HEADPHONE, 51 }; 52 53 enum { 54 ALC_HEADSET_TYPE_UNKNOWN, 55 ALC_HEADSET_TYPE_CTIA, 56 ALC_HEADSET_TYPE_OMTP, 57 }; 58 59 enum { 60 ALC_KEY_MICMUTE_INDEX, 61 }; 62 63 struct alc_customize_define { 64 unsigned int sku_cfg; 65 unsigned char port_connectivity; 66 unsigned char check_sum; 67 unsigned char customization; 68 unsigned char external_amp; 69 unsigned int enable_pcbeep:1; 70 unsigned int platform_type:1; 71 unsigned int swap:1; 72 unsigned int override:1; 73 unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */ 74 }; 75 76 struct alc_coef_led { 77 unsigned int idx; 78 unsigned int mask; 79 unsigned int on; 80 unsigned int off; 81 }; 82 83 struct alc_spec { 84 struct hda_gen_spec gen; /* must be at head */ 85 86 /* codec parameterization */ 87 struct alc_customize_define cdefine; 88 unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */ 89 90 /* GPIO bits */ 91 unsigned int gpio_mask; 92 unsigned int gpio_dir; 93 unsigned int gpio_data; 94 bool gpio_write_delay; /* add a delay before writing gpio_data */ 95 96 /* mute LED for HP laptops, see vref_mute_led_set() */ 97 int mute_led_polarity; 98 int micmute_led_polarity; 99 hda_nid_t mute_led_nid; 100 hda_nid_t cap_mute_led_nid; 101 102 unsigned int gpio_mute_led_mask; 103 unsigned int gpio_mic_led_mask; 104 struct alc_coef_led mute_led_coef; 105 struct alc_coef_led mic_led_coef; 106 struct mutex coef_mutex; 107 108 hda_nid_t headset_mic_pin; 109 hda_nid_t headphone_mic_pin; 110 int current_headset_mode; 111 int current_headset_type; 112 113 /* hooks */ 114 void (*init_hook)(struct hda_codec *codec); 115 void (*power_hook)(struct hda_codec *codec); 116 void (*shutup)(struct hda_codec *codec); 117 118 int init_amp; 119 int codec_variant; /* flag for other variants */ 120 unsigned int has_alc5505_dsp:1; 121 unsigned int no_depop_delay:1; 122 unsigned int done_hp_init:1; 123 unsigned int no_shutup_pins:1; 124 unsigned int ultra_low_power:1; 125 unsigned int has_hs_key:1; 126 unsigned int no_internal_mic_pin:1; 127 unsigned int en_3kpull_low:1; 128 int num_speaker_amps; 129 130 /* for PLL fix */ 131 hda_nid_t pll_nid; 132 unsigned int pll_coef_idx, pll_coef_bit; 133 unsigned int coef0; 134 struct input_dev *kb_dev; 135 u8 alc_mute_keycode_map[1]; 136 137 /* component binding */ 138 struct hda_component_parent comps; 139 }; 140 141 /* 142 * COEF access helper functions 143 */ 144 145 static void coef_mutex_lock(struct hda_codec *codec) 146 { 147 struct alc_spec *spec = codec->spec; 148 149 snd_hda_power_up_pm(codec); 150 mutex_lock(&spec->coef_mutex); 151 } 152 153 static void coef_mutex_unlock(struct hda_codec *codec) 154 { 155 struct alc_spec *spec = codec->spec; 156 157 mutex_unlock(&spec->coef_mutex); 158 snd_hda_power_down_pm(codec); 159 } 160 161 static int __alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid, 162 unsigned int coef_idx) 163 { 164 unsigned int val; 165 166 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx); 167 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0); 168 return val; 169 } 170 171 static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid, 172 unsigned int coef_idx) 173 { 174 unsigned int val; 175 176 coef_mutex_lock(codec); 177 val = __alc_read_coefex_idx(codec, nid, coef_idx); 178 coef_mutex_unlock(codec); 179 return val; 180 } 181 182 #define alc_read_coef_idx(codec, coef_idx) \ 183 alc_read_coefex_idx(codec, 0x20, coef_idx) 184 185 static void __alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid, 186 unsigned int coef_idx, unsigned int coef_val) 187 { 188 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx); 189 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val); 190 } 191 192 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid, 193 unsigned int coef_idx, unsigned int coef_val) 194 { 195 coef_mutex_lock(codec); 196 __alc_write_coefex_idx(codec, nid, coef_idx, coef_val); 197 coef_mutex_unlock(codec); 198 } 199 200 #define alc_write_coef_idx(codec, coef_idx, coef_val) \ 201 alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val) 202 203 static void __alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid, 204 unsigned int coef_idx, unsigned int mask, 205 unsigned int bits_set) 206 { 207 unsigned int val = __alc_read_coefex_idx(codec, nid, coef_idx); 208 209 if (val != -1) 210 __alc_write_coefex_idx(codec, nid, coef_idx, 211 (val & ~mask) | bits_set); 212 } 213 214 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid, 215 unsigned int coef_idx, unsigned int mask, 216 unsigned int bits_set) 217 { 218 coef_mutex_lock(codec); 219 __alc_update_coefex_idx(codec, nid, coef_idx, mask, bits_set); 220 coef_mutex_unlock(codec); 221 } 222 223 #define alc_update_coef_idx(codec, coef_idx, mask, bits_set) \ 224 alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set) 225 226 /* a special bypass for COEF 0; read the cached value at the second time */ 227 static unsigned int alc_get_coef0(struct hda_codec *codec) 228 { 229 struct alc_spec *spec = codec->spec; 230 231 if (!spec->coef0) 232 spec->coef0 = alc_read_coef_idx(codec, 0); 233 return spec->coef0; 234 } 235 236 /* coef writes/updates batch */ 237 struct coef_fw { 238 unsigned char nid; 239 unsigned char idx; 240 unsigned short mask; 241 unsigned short val; 242 }; 243 244 #define UPDATE_COEFEX(_nid, _idx, _mask, _val) \ 245 { .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) } 246 #define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val) 247 #define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val) 248 #define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val) 249 250 static void alc_process_coef_fw(struct hda_codec *codec, 251 const struct coef_fw *fw) 252 { 253 coef_mutex_lock(codec); 254 for (; fw->nid; fw++) { 255 if (fw->mask == (unsigned short)-1) 256 __alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val); 257 else 258 __alc_update_coefex_idx(codec, fw->nid, fw->idx, 259 fw->mask, fw->val); 260 } 261 coef_mutex_unlock(codec); 262 } 263 264 /* 265 * GPIO setup tables, used in initialization 266 */ 267 268 /* Enable GPIO mask and set output */ 269 static void alc_setup_gpio(struct hda_codec *codec, unsigned int mask) 270 { 271 struct alc_spec *spec = codec->spec; 272 273 spec->gpio_mask |= mask; 274 spec->gpio_dir |= mask; 275 spec->gpio_data |= mask; 276 } 277 278 static void alc_write_gpio_data(struct hda_codec *codec) 279 { 280 struct alc_spec *spec = codec->spec; 281 282 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 283 spec->gpio_data); 284 } 285 286 static void alc_update_gpio_data(struct hda_codec *codec, unsigned int mask, 287 bool on) 288 { 289 struct alc_spec *spec = codec->spec; 290 unsigned int oldval = spec->gpio_data; 291 292 if (on) 293 spec->gpio_data |= mask; 294 else 295 spec->gpio_data &= ~mask; 296 if (oldval != spec->gpio_data) 297 alc_write_gpio_data(codec); 298 } 299 300 static void alc_write_gpio(struct hda_codec *codec) 301 { 302 struct alc_spec *spec = codec->spec; 303 304 if (!spec->gpio_mask) 305 return; 306 307 snd_hda_codec_write(codec, codec->core.afg, 0, 308 AC_VERB_SET_GPIO_MASK, spec->gpio_mask); 309 snd_hda_codec_write(codec, codec->core.afg, 0, 310 AC_VERB_SET_GPIO_DIRECTION, spec->gpio_dir); 311 if (spec->gpio_write_delay) 312 msleep(1); 313 alc_write_gpio_data(codec); 314 } 315 316 static void alc_fixup_gpio(struct hda_codec *codec, int action, 317 unsigned int mask) 318 { 319 if (action == HDA_FIXUP_ACT_PRE_PROBE) 320 alc_setup_gpio(codec, mask); 321 } 322 323 static void alc_fixup_gpio1(struct hda_codec *codec, 324 const struct hda_fixup *fix, int action) 325 { 326 alc_fixup_gpio(codec, action, 0x01); 327 } 328 329 static void alc_fixup_gpio2(struct hda_codec *codec, 330 const struct hda_fixup *fix, int action) 331 { 332 alc_fixup_gpio(codec, action, 0x02); 333 } 334 335 static void alc_fixup_gpio3(struct hda_codec *codec, 336 const struct hda_fixup *fix, int action) 337 { 338 alc_fixup_gpio(codec, action, 0x03); 339 } 340 341 static void alc_fixup_gpio4(struct hda_codec *codec, 342 const struct hda_fixup *fix, int action) 343 { 344 alc_fixup_gpio(codec, action, 0x04); 345 } 346 347 static void alc_fixup_micmute_led(struct hda_codec *codec, 348 const struct hda_fixup *fix, int action) 349 { 350 if (action == HDA_FIXUP_ACT_PRE_PROBE) 351 snd_hda_gen_add_micmute_led_cdev(codec, NULL); 352 } 353 354 /* 355 * Fix hardware PLL issue 356 * On some codecs, the analog PLL gating control must be off while 357 * the default value is 1. 358 */ 359 static void alc_fix_pll(struct hda_codec *codec) 360 { 361 struct alc_spec *spec = codec->spec; 362 363 if (spec->pll_nid) 364 alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx, 365 1 << spec->pll_coef_bit, 0); 366 } 367 368 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid, 369 unsigned int coef_idx, unsigned int coef_bit) 370 { 371 struct alc_spec *spec = codec->spec; 372 spec->pll_nid = nid; 373 spec->pll_coef_idx = coef_idx; 374 spec->pll_coef_bit = coef_bit; 375 alc_fix_pll(codec); 376 } 377 378 /* update the master volume per volume-knob's unsol event */ 379 static void alc_update_knob_master(struct hda_codec *codec, 380 struct hda_jack_callback *jack) 381 { 382 unsigned int val; 383 struct snd_kcontrol *kctl; 384 struct snd_ctl_elem_value *uctl; 385 386 kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume"); 387 if (!kctl) 388 return; 389 uctl = kzalloc(sizeof(*uctl), GFP_KERNEL); 390 if (!uctl) 391 return; 392 val = snd_hda_codec_read(codec, jack->nid, 0, 393 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0); 394 val &= HDA_AMP_VOLMASK; 395 uctl->value.integer.value[0] = val; 396 uctl->value.integer.value[1] = val; 397 kctl->put(kctl, uctl); 398 kfree(uctl); 399 } 400 401 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res) 402 { 403 /* For some reason, the res given from ALC880 is broken. 404 Here we adjust it properly. */ 405 snd_hda_jack_unsol_event(codec, res >> 2); 406 } 407 408 /* Change EAPD to verb control */ 409 static void alc_fill_eapd_coef(struct hda_codec *codec) 410 { 411 int coef; 412 413 coef = alc_get_coef0(codec); 414 415 switch (codec->core.vendor_id) { 416 case 0x10ec0262: 417 alc_update_coef_idx(codec, 0x7, 0, 1<<5); 418 break; 419 case 0x10ec0267: 420 case 0x10ec0268: 421 alc_update_coef_idx(codec, 0x7, 0, 1<<13); 422 break; 423 case 0x10ec0269: 424 if ((coef & 0x00f0) == 0x0010) 425 alc_update_coef_idx(codec, 0xd, 0, 1<<14); 426 if ((coef & 0x00f0) == 0x0020) 427 alc_update_coef_idx(codec, 0x4, 1<<15, 0); 428 if ((coef & 0x00f0) == 0x0030) 429 alc_update_coef_idx(codec, 0x10, 1<<9, 0); 430 break; 431 case 0x10ec0280: 432 case 0x10ec0284: 433 case 0x10ec0290: 434 case 0x10ec0292: 435 alc_update_coef_idx(codec, 0x4, 1<<15, 0); 436 break; 437 case 0x10ec0225: 438 case 0x10ec0295: 439 case 0x10ec0299: 440 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000); 441 fallthrough; 442 case 0x10ec0215: 443 case 0x10ec0285: 444 case 0x10ec0289: 445 alc_update_coef_idx(codec, 0x36, 1<<13, 0); 446 fallthrough; 447 case 0x10ec0230: 448 case 0x10ec0233: 449 case 0x10ec0235: 450 case 0x10ec0236: 451 case 0x10ec0245: 452 case 0x10ec0255: 453 case 0x10ec0256: 454 case 0x19e58326: 455 case 0x10ec0257: 456 case 0x10ec0282: 457 case 0x10ec0283: 458 case 0x10ec0286: 459 case 0x10ec0288: 460 case 0x10ec0298: 461 case 0x10ec0300: 462 alc_update_coef_idx(codec, 0x10, 1<<9, 0); 463 break; 464 case 0x10ec0275: 465 alc_update_coef_idx(codec, 0xe, 0, 1<<0); 466 break; 467 case 0x10ec0287: 468 alc_update_coef_idx(codec, 0x10, 1<<9, 0); 469 alc_write_coef_idx(codec, 0x8, 0x4ab7); 470 break; 471 case 0x10ec0293: 472 alc_update_coef_idx(codec, 0xa, 1<<13, 0); 473 break; 474 case 0x10ec0234: 475 case 0x10ec0274: 476 case 0x10ec0294: 477 case 0x10ec0700: 478 case 0x10ec0701: 479 case 0x10ec0703: 480 case 0x10ec0711: 481 alc_update_coef_idx(codec, 0x10, 1<<15, 0); 482 break; 483 case 0x10ec0662: 484 if ((coef & 0x00f0) == 0x0030) 485 alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */ 486 break; 487 case 0x10ec0272: 488 case 0x10ec0273: 489 case 0x10ec0663: 490 case 0x10ec0665: 491 case 0x10ec0670: 492 case 0x10ec0671: 493 case 0x10ec0672: 494 alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */ 495 break; 496 case 0x10ec0222: 497 case 0x10ec0623: 498 alc_update_coef_idx(codec, 0x19, 1<<13, 0); 499 break; 500 case 0x10ec0668: 501 alc_update_coef_idx(codec, 0x7, 3<<13, 0); 502 break; 503 case 0x10ec0867: 504 alc_update_coef_idx(codec, 0x4, 1<<10, 0); 505 break; 506 case 0x10ec0888: 507 if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030) 508 alc_update_coef_idx(codec, 0x7, 1<<5, 0); 509 break; 510 case 0x10ec0892: 511 case 0x10ec0897: 512 alc_update_coef_idx(codec, 0x7, 1<<5, 0); 513 break; 514 case 0x10ec0899: 515 case 0x10ec0900: 516 case 0x10ec0b00: 517 case 0x10ec1168: 518 case 0x10ec1220: 519 alc_update_coef_idx(codec, 0x7, 1<<1, 0); 520 break; 521 } 522 } 523 524 /* additional initialization for ALC888 variants */ 525 static void alc888_coef_init(struct hda_codec *codec) 526 { 527 switch (alc_get_coef0(codec) & 0x00f0) { 528 /* alc888-VA */ 529 case 0x00: 530 /* alc888-VB */ 531 case 0x10: 532 alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */ 533 break; 534 } 535 } 536 537 /* turn on/off EAPD control (only if available) */ 538 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on) 539 { 540 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN) 541 return; 542 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD) 543 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE, 544 on ? 2 : 0); 545 } 546 547 /* turn on/off EAPD controls of the codec */ 548 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on) 549 { 550 /* We currently only handle front, HP */ 551 static const hda_nid_t pins[] = { 552 0x0f, 0x10, 0x14, 0x15, 0x17, 0 553 }; 554 const hda_nid_t *p; 555 for (p = pins; *p; p++) 556 set_eapd(codec, *p, on); 557 } 558 559 static int find_ext_mic_pin(struct hda_codec *codec); 560 561 static void alc_headset_mic_no_shutup(struct hda_codec *codec) 562 { 563 const struct hda_pincfg *pin; 564 int mic_pin = find_ext_mic_pin(codec); 565 int i; 566 567 /* don't shut up pins when unloading the driver; otherwise it breaks 568 * the default pin setup at the next load of the driver 569 */ 570 if (codec->bus->shutdown) 571 return; 572 573 snd_array_for_each(&codec->init_pins, i, pin) { 574 /* use read here for syncing after issuing each verb */ 575 if (pin->nid != mic_pin) 576 snd_hda_codec_read(codec, pin->nid, 0, 577 AC_VERB_SET_PIN_WIDGET_CONTROL, 0); 578 } 579 580 codec->pins_shutup = 1; 581 } 582 583 static void alc_shutup_pins(struct hda_codec *codec) 584 { 585 struct alc_spec *spec = codec->spec; 586 587 switch (codec->core.vendor_id) { 588 case 0x10ec0236: 589 case 0x10ec0256: 590 case 0x10ec0257: 591 case 0x19e58326: 592 case 0x10ec0283: 593 case 0x10ec0285: 594 case 0x10ec0286: 595 case 0x10ec0287: 596 case 0x10ec0288: 597 case 0x10ec0295: 598 case 0x10ec0298: 599 alc_headset_mic_no_shutup(codec); 600 break; 601 default: 602 if (!spec->no_shutup_pins) 603 snd_hda_shutup_pins(codec); 604 break; 605 } 606 } 607 608 /* generic shutup callback; 609 * just turning off EAPD and a little pause for avoiding pop-noise 610 */ 611 static void alc_eapd_shutup(struct hda_codec *codec) 612 { 613 struct alc_spec *spec = codec->spec; 614 615 alc_auto_setup_eapd(codec, false); 616 if (!spec->no_depop_delay) 617 msleep(200); 618 alc_shutup_pins(codec); 619 } 620 621 /* generic EAPD initialization */ 622 static void alc_auto_init_amp(struct hda_codec *codec, int type) 623 { 624 alc_auto_setup_eapd(codec, true); 625 alc_write_gpio(codec); 626 switch (type) { 627 case ALC_INIT_DEFAULT: 628 switch (codec->core.vendor_id) { 629 case 0x10ec0260: 630 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010); 631 break; 632 case 0x10ec0880: 633 case 0x10ec0882: 634 case 0x10ec0883: 635 case 0x10ec0885: 636 alc_update_coef_idx(codec, 7, 0, 0x2030); 637 break; 638 case 0x10ec0888: 639 alc888_coef_init(codec); 640 break; 641 } 642 break; 643 } 644 } 645 646 /* get a primary headphone pin if available */ 647 static hda_nid_t alc_get_hp_pin(struct alc_spec *spec) 648 { 649 if (spec->gen.autocfg.hp_pins[0]) 650 return spec->gen.autocfg.hp_pins[0]; 651 if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT) 652 return spec->gen.autocfg.line_out_pins[0]; 653 return 0; 654 } 655 656 /* 657 * Realtek SSID verification 658 */ 659 660 /* Could be any non-zero and even value. When used as fixup, tells 661 * the driver to ignore any present sku defines. 662 */ 663 #define ALC_FIXUP_SKU_IGNORE (2) 664 665 static void alc_fixup_sku_ignore(struct hda_codec *codec, 666 const struct hda_fixup *fix, int action) 667 { 668 struct alc_spec *spec = codec->spec; 669 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 670 spec->cdefine.fixup = 1; 671 spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE; 672 } 673 } 674 675 static void alc_fixup_no_depop_delay(struct hda_codec *codec, 676 const struct hda_fixup *fix, int action) 677 { 678 struct alc_spec *spec = codec->spec; 679 680 if (action == HDA_FIXUP_ACT_PROBE) { 681 spec->no_depop_delay = 1; 682 codec->depop_delay = 0; 683 } 684 } 685 686 static int alc_auto_parse_customize_define(struct hda_codec *codec) 687 { 688 unsigned int ass, tmp, i; 689 unsigned nid = 0; 690 struct alc_spec *spec = codec->spec; 691 692 spec->cdefine.enable_pcbeep = 1; /* assume always enabled */ 693 694 if (spec->cdefine.fixup) { 695 ass = spec->cdefine.sku_cfg; 696 if (ass == ALC_FIXUP_SKU_IGNORE) 697 return -1; 698 goto do_sku; 699 } 700 701 if (!codec->bus->pci) 702 return -1; 703 ass = codec->core.subsystem_id & 0xffff; 704 if (ass != codec->bus->pci->subsystem_device && (ass & 1)) 705 goto do_sku; 706 707 nid = 0x1d; 708 if (codec->core.vendor_id == 0x10ec0260) 709 nid = 0x17; 710 ass = snd_hda_codec_get_pincfg(codec, nid); 711 712 if (!(ass & 1)) { 713 codec_info(codec, "%s: SKU not ready 0x%08x\n", 714 codec->core.chip_name, ass); 715 return -1; 716 } 717 718 /* check sum */ 719 tmp = 0; 720 for (i = 1; i < 16; i++) { 721 if ((ass >> i) & 1) 722 tmp++; 723 } 724 if (((ass >> 16) & 0xf) != tmp) 725 return -1; 726 727 spec->cdefine.port_connectivity = ass >> 30; 728 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20; 729 spec->cdefine.check_sum = (ass >> 16) & 0xf; 730 spec->cdefine.customization = ass >> 8; 731 do_sku: 732 spec->cdefine.sku_cfg = ass; 733 spec->cdefine.external_amp = (ass & 0x38) >> 3; 734 spec->cdefine.platform_type = (ass & 0x4) >> 2; 735 spec->cdefine.swap = (ass & 0x2) >> 1; 736 spec->cdefine.override = ass & 0x1; 737 738 codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n", 739 nid, spec->cdefine.sku_cfg); 740 codec_dbg(codec, "SKU: port_connectivity=0x%x\n", 741 spec->cdefine.port_connectivity); 742 codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep); 743 codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum); 744 codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization); 745 codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp); 746 codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type); 747 codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap); 748 codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override); 749 750 return 0; 751 } 752 753 /* return the position of NID in the list, or -1 if not found */ 754 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums) 755 { 756 int i; 757 for (i = 0; i < nums; i++) 758 if (list[i] == nid) 759 return i; 760 return -1; 761 } 762 /* return true if the given NID is found in the list */ 763 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums) 764 { 765 return find_idx_in_nid_list(nid, list, nums) >= 0; 766 } 767 768 /* check subsystem ID and set up device-specific initialization; 769 * return 1 if initialized, 0 if invalid SSID 770 */ 771 /* 32-bit subsystem ID for BIOS loading in HD Audio codec. 772 * 31 ~ 16 : Manufacture ID 773 * 15 ~ 8 : SKU ID 774 * 7 ~ 0 : Assembly ID 775 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36 776 */ 777 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports) 778 { 779 unsigned int ass, tmp, i; 780 unsigned nid; 781 struct alc_spec *spec = codec->spec; 782 783 if (spec->cdefine.fixup) { 784 ass = spec->cdefine.sku_cfg; 785 if (ass == ALC_FIXUP_SKU_IGNORE) 786 return 0; 787 goto do_sku; 788 } 789 790 ass = codec->core.subsystem_id & 0xffff; 791 if (codec->bus->pci && 792 ass != codec->bus->pci->subsystem_device && (ass & 1)) 793 goto do_sku; 794 795 /* invalid SSID, check the special NID pin defcfg instead */ 796 /* 797 * 31~30 : port connectivity 798 * 29~21 : reserve 799 * 20 : PCBEEP input 800 * 19~16 : Check sum (15:1) 801 * 15~1 : Custom 802 * 0 : override 803 */ 804 nid = 0x1d; 805 if (codec->core.vendor_id == 0x10ec0260) 806 nid = 0x17; 807 ass = snd_hda_codec_get_pincfg(codec, nid); 808 codec_dbg(codec, 809 "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n", 810 ass, nid); 811 if (!(ass & 1)) 812 return 0; 813 if ((ass >> 30) != 1) /* no physical connection */ 814 return 0; 815 816 /* check sum */ 817 tmp = 0; 818 for (i = 1; i < 16; i++) { 819 if ((ass >> i) & 1) 820 tmp++; 821 } 822 if (((ass >> 16) & 0xf) != tmp) 823 return 0; 824 do_sku: 825 codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n", 826 ass & 0xffff, codec->core.vendor_id); 827 /* 828 * 0 : override 829 * 1 : Swap Jack 830 * 2 : 0 --> Desktop, 1 --> Laptop 831 * 3~5 : External Amplifier control 832 * 7~6 : Reserved 833 */ 834 tmp = (ass & 0x38) >> 3; /* external Amp control */ 835 if (spec->init_amp == ALC_INIT_UNDEFINED) { 836 switch (tmp) { 837 case 1: 838 alc_setup_gpio(codec, 0x01); 839 break; 840 case 3: 841 alc_setup_gpio(codec, 0x02); 842 break; 843 case 7: 844 alc_setup_gpio(codec, 0x04); 845 break; 846 case 5: 847 default: 848 spec->init_amp = ALC_INIT_DEFAULT; 849 break; 850 } 851 } 852 853 /* is laptop or Desktop and enable the function "Mute internal speaker 854 * when the external headphone out jack is plugged" 855 */ 856 if (!(ass & 0x8000)) 857 return 1; 858 /* 859 * 10~8 : Jack location 860 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered 861 * 14~13: Resvered 862 * 15 : 1 --> enable the function "Mute internal speaker 863 * when the external headphone out jack is plugged" 864 */ 865 if (!alc_get_hp_pin(spec)) { 866 hda_nid_t nid; 867 tmp = (ass >> 11) & 0x3; /* HP to chassis */ 868 nid = ports[tmp]; 869 if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins, 870 spec->gen.autocfg.line_outs)) 871 return 1; 872 spec->gen.autocfg.hp_pins[0] = nid; 873 } 874 return 1; 875 } 876 877 /* Check the validity of ALC subsystem-id 878 * ports contains an array of 4 pin NIDs for port-A, E, D and I */ 879 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports) 880 { 881 if (!alc_subsystem_id(codec, ports)) { 882 struct alc_spec *spec = codec->spec; 883 if (spec->init_amp == ALC_INIT_UNDEFINED) { 884 codec_dbg(codec, 885 "realtek: Enable default setup for auto mode as fallback\n"); 886 spec->init_amp = ALC_INIT_DEFAULT; 887 } 888 } 889 } 890 891 /* 892 */ 893 894 static void alc_fixup_inv_dmic(struct hda_codec *codec, 895 const struct hda_fixup *fix, int action) 896 { 897 struct alc_spec *spec = codec->spec; 898 899 spec->gen.inv_dmic_split = 1; 900 } 901 902 903 static int alc_build_controls(struct hda_codec *codec) 904 { 905 int err; 906 907 err = snd_hda_gen_build_controls(codec); 908 if (err < 0) 909 return err; 910 911 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD); 912 return 0; 913 } 914 915 916 /* 917 * Common callbacks 918 */ 919 920 static void alc_pre_init(struct hda_codec *codec) 921 { 922 alc_fill_eapd_coef(codec); 923 } 924 925 #define is_s3_resume(codec) \ 926 ((codec)->core.dev.power.power_state.event == PM_EVENT_RESUME) 927 #define is_s4_resume(codec) \ 928 ((codec)->core.dev.power.power_state.event == PM_EVENT_RESTORE) 929 #define is_s4_suspend(codec) \ 930 ((codec)->core.dev.power.power_state.event == PM_EVENT_FREEZE) 931 932 static int alc_init(struct hda_codec *codec) 933 { 934 struct alc_spec *spec = codec->spec; 935 936 /* hibernation resume needs the full chip initialization */ 937 if (is_s4_resume(codec)) 938 alc_pre_init(codec); 939 940 if (spec->init_hook) 941 spec->init_hook(codec); 942 943 spec->gen.skip_verbs = 1; /* applied in below */ 944 snd_hda_gen_init(codec); 945 alc_fix_pll(codec); 946 alc_auto_init_amp(codec, spec->init_amp); 947 snd_hda_apply_verbs(codec); /* apply verbs here after own init */ 948 949 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT); 950 951 return 0; 952 } 953 954 /* forward declaration */ 955 static const struct component_master_ops comp_master_ops; 956 957 static void alc_free(struct hda_codec *codec) 958 { 959 struct alc_spec *spec = codec->spec; 960 961 if (spec) 962 hda_component_manager_free(&spec->comps, &comp_master_ops); 963 964 snd_hda_gen_free(codec); 965 } 966 967 static inline void alc_shutup(struct hda_codec *codec) 968 { 969 struct alc_spec *spec = codec->spec; 970 971 if (!snd_hda_get_bool_hint(codec, "shutup")) 972 return; /* disabled explicitly by hints */ 973 974 if (spec && spec->shutup) 975 spec->shutup(codec); 976 else 977 alc_shutup_pins(codec); 978 } 979 980 static void alc_power_eapd(struct hda_codec *codec) 981 { 982 alc_auto_setup_eapd(codec, false); 983 } 984 985 static int alc_suspend(struct hda_codec *codec) 986 { 987 struct alc_spec *spec = codec->spec; 988 alc_shutup(codec); 989 if (spec && spec->power_hook) 990 spec->power_hook(codec); 991 return 0; 992 } 993 994 static int alc_resume(struct hda_codec *codec) 995 { 996 struct alc_spec *spec = codec->spec; 997 998 if (!spec->no_depop_delay) 999 msleep(150); /* to avoid pop noise */ 1000 codec->patch_ops.init(codec); 1001 snd_hda_regmap_sync(codec); 1002 hda_call_check_power_status(codec, 0x01); 1003 return 0; 1004 } 1005 1006 /* 1007 */ 1008 static const struct hda_codec_ops alc_patch_ops = { 1009 .build_controls = alc_build_controls, 1010 .build_pcms = snd_hda_gen_build_pcms, 1011 .init = alc_init, 1012 .free = alc_free, 1013 .unsol_event = snd_hda_jack_unsol_event, 1014 .resume = alc_resume, 1015 .suspend = alc_suspend, 1016 .check_power_status = snd_hda_gen_check_power_status, 1017 }; 1018 1019 1020 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name) 1021 1022 /* 1023 * Rename codecs appropriately from COEF value or subvendor id 1024 */ 1025 struct alc_codec_rename_table { 1026 unsigned int vendor_id; 1027 unsigned short coef_mask; 1028 unsigned short coef_bits; 1029 const char *name; 1030 }; 1031 1032 struct alc_codec_rename_pci_table { 1033 unsigned int codec_vendor_id; 1034 unsigned short pci_subvendor; 1035 unsigned short pci_subdevice; 1036 const char *name; 1037 }; 1038 1039 static const struct alc_codec_rename_table rename_tbl[] = { 1040 { 0x10ec0221, 0xf00f, 0x1003, "ALC231" }, 1041 { 0x10ec0269, 0xfff0, 0x3010, "ALC277" }, 1042 { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" }, 1043 { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" }, 1044 { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" }, 1045 { 0x10ec0269, 0xffff, 0xa023, "ALC259" }, 1046 { 0x10ec0269, 0xffff, 0x6023, "ALC281X" }, 1047 { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" }, 1048 { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" }, 1049 { 0x10ec0662, 0xffff, 0x4020, "ALC656" }, 1050 { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" }, 1051 { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" }, 1052 { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" }, 1053 { 0x10ec0899, 0x2000, 0x2000, "ALC899" }, 1054 { 0x10ec0892, 0xffff, 0x8020, "ALC661" }, 1055 { 0x10ec0892, 0xffff, 0x8011, "ALC661" }, 1056 { 0x10ec0892, 0xffff, 0x4011, "ALC656" }, 1057 { } /* terminator */ 1058 }; 1059 1060 static const struct alc_codec_rename_pci_table rename_pci_tbl[] = { 1061 { 0x10ec0280, 0x1028, 0, "ALC3220" }, 1062 { 0x10ec0282, 0x1028, 0, "ALC3221" }, 1063 { 0x10ec0283, 0x1028, 0, "ALC3223" }, 1064 { 0x10ec0288, 0x1028, 0, "ALC3263" }, 1065 { 0x10ec0292, 0x1028, 0, "ALC3226" }, 1066 { 0x10ec0293, 0x1028, 0, "ALC3235" }, 1067 { 0x10ec0255, 0x1028, 0, "ALC3234" }, 1068 { 0x10ec0668, 0x1028, 0, "ALC3661" }, 1069 { 0x10ec0275, 0x1028, 0, "ALC3260" }, 1070 { 0x10ec0899, 0x1028, 0, "ALC3861" }, 1071 { 0x10ec0298, 0x1028, 0, "ALC3266" }, 1072 { 0x10ec0236, 0x1028, 0, "ALC3204" }, 1073 { 0x10ec0256, 0x1028, 0, "ALC3246" }, 1074 { 0x10ec0225, 0x1028, 0, "ALC3253" }, 1075 { 0x10ec0295, 0x1028, 0, "ALC3254" }, 1076 { 0x10ec0299, 0x1028, 0, "ALC3271" }, 1077 { 0x10ec0670, 0x1025, 0, "ALC669X" }, 1078 { 0x10ec0676, 0x1025, 0, "ALC679X" }, 1079 { 0x10ec0282, 0x1043, 0, "ALC3229" }, 1080 { 0x10ec0233, 0x1043, 0, "ALC3236" }, 1081 { 0x10ec0280, 0x103c, 0, "ALC3228" }, 1082 { 0x10ec0282, 0x103c, 0, "ALC3227" }, 1083 { 0x10ec0286, 0x103c, 0, "ALC3242" }, 1084 { 0x10ec0290, 0x103c, 0, "ALC3241" }, 1085 { 0x10ec0668, 0x103c, 0, "ALC3662" }, 1086 { 0x10ec0283, 0x17aa, 0, "ALC3239" }, 1087 { 0x10ec0292, 0x17aa, 0, "ALC3232" }, 1088 { } /* terminator */ 1089 }; 1090 1091 static int alc_codec_rename_from_preset(struct hda_codec *codec) 1092 { 1093 const struct alc_codec_rename_table *p; 1094 const struct alc_codec_rename_pci_table *q; 1095 1096 for (p = rename_tbl; p->vendor_id; p++) { 1097 if (p->vendor_id != codec->core.vendor_id) 1098 continue; 1099 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits) 1100 return alc_codec_rename(codec, p->name); 1101 } 1102 1103 if (!codec->bus->pci) 1104 return 0; 1105 for (q = rename_pci_tbl; q->codec_vendor_id; q++) { 1106 if (q->codec_vendor_id != codec->core.vendor_id) 1107 continue; 1108 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor) 1109 continue; 1110 if (!q->pci_subdevice || 1111 q->pci_subdevice == codec->bus->pci->subsystem_device) 1112 return alc_codec_rename(codec, q->name); 1113 } 1114 1115 return 0; 1116 } 1117 1118 1119 /* 1120 * Digital-beep handlers 1121 */ 1122 #ifdef CONFIG_SND_HDA_INPUT_BEEP 1123 1124 /* additional beep mixers; private_value will be overwritten */ 1125 static const struct snd_kcontrol_new alc_beep_mixer[] = { 1126 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT), 1127 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT), 1128 }; 1129 1130 /* set up and create beep controls */ 1131 static int set_beep_amp(struct alc_spec *spec, hda_nid_t nid, 1132 int idx, int dir) 1133 { 1134 struct snd_kcontrol_new *knew; 1135 unsigned int beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir); 1136 int i; 1137 1138 for (i = 0; i < ARRAY_SIZE(alc_beep_mixer); i++) { 1139 knew = snd_hda_gen_add_kctl(&spec->gen, NULL, 1140 &alc_beep_mixer[i]); 1141 if (!knew) 1142 return -ENOMEM; 1143 knew->private_value = beep_amp; 1144 } 1145 return 0; 1146 } 1147 1148 static const struct snd_pci_quirk beep_allow_list[] = { 1149 SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1), 1150 SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1), 1151 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1), 1152 SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1), 1153 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1), 1154 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1), 1155 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1), 1156 SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1), 1157 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1), 1158 /* denylist -- no beep available */ 1159 SND_PCI_QUIRK(0x17aa, 0x309e, "Lenovo ThinkCentre M73", 0), 1160 SND_PCI_QUIRK(0x17aa, 0x30a3, "Lenovo ThinkCentre M93", 0), 1161 {} 1162 }; 1163 1164 static inline int has_cdefine_beep(struct hda_codec *codec) 1165 { 1166 struct alc_spec *spec = codec->spec; 1167 const struct snd_pci_quirk *q; 1168 q = snd_pci_quirk_lookup(codec->bus->pci, beep_allow_list); 1169 if (q) 1170 return q->value; 1171 return spec->cdefine.enable_pcbeep; 1172 } 1173 #else 1174 #define set_beep_amp(spec, nid, idx, dir) 0 1175 #define has_cdefine_beep(codec) 0 1176 #endif 1177 1178 /* parse the BIOS configuration and set up the alc_spec */ 1179 /* return 1 if successful, 0 if the proper config is not found, 1180 * or a negative error code 1181 */ 1182 static int alc_parse_auto_config(struct hda_codec *codec, 1183 const hda_nid_t *ignore_nids, 1184 const hda_nid_t *ssid_nids) 1185 { 1186 struct alc_spec *spec = codec->spec; 1187 struct auto_pin_cfg *cfg = &spec->gen.autocfg; 1188 int err; 1189 1190 err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids, 1191 spec->parse_flags); 1192 if (err < 0) 1193 return err; 1194 1195 if (ssid_nids) 1196 alc_ssid_check(codec, ssid_nids); 1197 1198 err = snd_hda_gen_parse_auto_config(codec, cfg); 1199 if (err < 0) 1200 return err; 1201 1202 return 1; 1203 } 1204 1205 /* common preparation job for alc_spec */ 1206 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid) 1207 { 1208 struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL); 1209 int err; 1210 1211 if (!spec) 1212 return -ENOMEM; 1213 codec->spec = spec; 1214 snd_hda_gen_spec_init(&spec->gen); 1215 spec->gen.mixer_nid = mixer_nid; 1216 spec->gen.own_eapd_ctl = 1; 1217 codec->single_adc_amp = 1; 1218 /* FIXME: do we need this for all Realtek codec models? */ 1219 codec->spdif_status_reset = 1; 1220 codec->forced_resume = 1; 1221 codec->patch_ops = alc_patch_ops; 1222 mutex_init(&spec->coef_mutex); 1223 1224 err = alc_codec_rename_from_preset(codec); 1225 if (err < 0) { 1226 kfree(spec); 1227 return err; 1228 } 1229 return 0; 1230 } 1231 1232 static int alc880_parse_auto_config(struct hda_codec *codec) 1233 { 1234 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 }; 1235 static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 1236 return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids); 1237 } 1238 1239 /* 1240 * ALC880 fix-ups 1241 */ 1242 enum { 1243 ALC880_FIXUP_GPIO1, 1244 ALC880_FIXUP_GPIO2, 1245 ALC880_FIXUP_MEDION_RIM, 1246 ALC880_FIXUP_LG, 1247 ALC880_FIXUP_LG_LW25, 1248 ALC880_FIXUP_W810, 1249 ALC880_FIXUP_EAPD_COEF, 1250 ALC880_FIXUP_TCL_S700, 1251 ALC880_FIXUP_VOL_KNOB, 1252 ALC880_FIXUP_FUJITSU, 1253 ALC880_FIXUP_F1734, 1254 ALC880_FIXUP_UNIWILL, 1255 ALC880_FIXUP_UNIWILL_DIG, 1256 ALC880_FIXUP_Z71V, 1257 ALC880_FIXUP_ASUS_W5A, 1258 ALC880_FIXUP_3ST_BASE, 1259 ALC880_FIXUP_3ST, 1260 ALC880_FIXUP_3ST_DIG, 1261 ALC880_FIXUP_5ST_BASE, 1262 ALC880_FIXUP_5ST, 1263 ALC880_FIXUP_5ST_DIG, 1264 ALC880_FIXUP_6ST_BASE, 1265 ALC880_FIXUP_6ST, 1266 ALC880_FIXUP_6ST_DIG, 1267 ALC880_FIXUP_6ST_AUTOMUTE, 1268 }; 1269 1270 /* enable the volume-knob widget support on NID 0x21 */ 1271 static void alc880_fixup_vol_knob(struct hda_codec *codec, 1272 const struct hda_fixup *fix, int action) 1273 { 1274 if (action == HDA_FIXUP_ACT_PROBE) 1275 snd_hda_jack_detect_enable_callback(codec, 0x21, 1276 alc_update_knob_master); 1277 } 1278 1279 static const struct hda_fixup alc880_fixups[] = { 1280 [ALC880_FIXUP_GPIO1] = { 1281 .type = HDA_FIXUP_FUNC, 1282 .v.func = alc_fixup_gpio1, 1283 }, 1284 [ALC880_FIXUP_GPIO2] = { 1285 .type = HDA_FIXUP_FUNC, 1286 .v.func = alc_fixup_gpio2, 1287 }, 1288 [ALC880_FIXUP_MEDION_RIM] = { 1289 .type = HDA_FIXUP_VERBS, 1290 .v.verbs = (const struct hda_verb[]) { 1291 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 1292 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 }, 1293 { } 1294 }, 1295 .chained = true, 1296 .chain_id = ALC880_FIXUP_GPIO2, 1297 }, 1298 [ALC880_FIXUP_LG] = { 1299 .type = HDA_FIXUP_PINS, 1300 .v.pins = (const struct hda_pintbl[]) { 1301 /* disable bogus unused pins */ 1302 { 0x16, 0x411111f0 }, 1303 { 0x18, 0x411111f0 }, 1304 { 0x1a, 0x411111f0 }, 1305 { } 1306 } 1307 }, 1308 [ALC880_FIXUP_LG_LW25] = { 1309 .type = HDA_FIXUP_PINS, 1310 .v.pins = (const struct hda_pintbl[]) { 1311 { 0x1a, 0x0181344f }, /* line-in */ 1312 { 0x1b, 0x0321403f }, /* headphone */ 1313 { } 1314 } 1315 }, 1316 [ALC880_FIXUP_W810] = { 1317 .type = HDA_FIXUP_PINS, 1318 .v.pins = (const struct hda_pintbl[]) { 1319 /* disable bogus unused pins */ 1320 { 0x17, 0x411111f0 }, 1321 { } 1322 }, 1323 .chained = true, 1324 .chain_id = ALC880_FIXUP_GPIO2, 1325 }, 1326 [ALC880_FIXUP_EAPD_COEF] = { 1327 .type = HDA_FIXUP_VERBS, 1328 .v.verbs = (const struct hda_verb[]) { 1329 /* change to EAPD mode */ 1330 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 1331 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 }, 1332 {} 1333 }, 1334 }, 1335 [ALC880_FIXUP_TCL_S700] = { 1336 .type = HDA_FIXUP_VERBS, 1337 .v.verbs = (const struct hda_verb[]) { 1338 /* change to EAPD mode */ 1339 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 1340 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 }, 1341 {} 1342 }, 1343 .chained = true, 1344 .chain_id = ALC880_FIXUP_GPIO2, 1345 }, 1346 [ALC880_FIXUP_VOL_KNOB] = { 1347 .type = HDA_FIXUP_FUNC, 1348 .v.func = alc880_fixup_vol_knob, 1349 }, 1350 [ALC880_FIXUP_FUJITSU] = { 1351 /* override all pins as BIOS on old Amilo is broken */ 1352 .type = HDA_FIXUP_PINS, 1353 .v.pins = (const struct hda_pintbl[]) { 1354 { 0x14, 0x0121401f }, /* HP */ 1355 { 0x15, 0x99030120 }, /* speaker */ 1356 { 0x16, 0x99030130 }, /* bass speaker */ 1357 { 0x17, 0x411111f0 }, /* N/A */ 1358 { 0x18, 0x411111f0 }, /* N/A */ 1359 { 0x19, 0x01a19950 }, /* mic-in */ 1360 { 0x1a, 0x411111f0 }, /* N/A */ 1361 { 0x1b, 0x411111f0 }, /* N/A */ 1362 { 0x1c, 0x411111f0 }, /* N/A */ 1363 { 0x1d, 0x411111f0 }, /* N/A */ 1364 { 0x1e, 0x01454140 }, /* SPDIF out */ 1365 { } 1366 }, 1367 .chained = true, 1368 .chain_id = ALC880_FIXUP_VOL_KNOB, 1369 }, 1370 [ALC880_FIXUP_F1734] = { 1371 /* almost compatible with FUJITSU, but no bass and SPDIF */ 1372 .type = HDA_FIXUP_PINS, 1373 .v.pins = (const struct hda_pintbl[]) { 1374 { 0x14, 0x0121401f }, /* HP */ 1375 { 0x15, 0x99030120 }, /* speaker */ 1376 { 0x16, 0x411111f0 }, /* N/A */ 1377 { 0x17, 0x411111f0 }, /* N/A */ 1378 { 0x18, 0x411111f0 }, /* N/A */ 1379 { 0x19, 0x01a19950 }, /* mic-in */ 1380 { 0x1a, 0x411111f0 }, /* N/A */ 1381 { 0x1b, 0x411111f0 }, /* N/A */ 1382 { 0x1c, 0x411111f0 }, /* N/A */ 1383 { 0x1d, 0x411111f0 }, /* N/A */ 1384 { 0x1e, 0x411111f0 }, /* N/A */ 1385 { } 1386 }, 1387 .chained = true, 1388 .chain_id = ALC880_FIXUP_VOL_KNOB, 1389 }, 1390 [ALC880_FIXUP_UNIWILL] = { 1391 /* need to fix HP and speaker pins to be parsed correctly */ 1392 .type = HDA_FIXUP_PINS, 1393 .v.pins = (const struct hda_pintbl[]) { 1394 { 0x14, 0x0121411f }, /* HP */ 1395 { 0x15, 0x99030120 }, /* speaker */ 1396 { 0x16, 0x99030130 }, /* bass speaker */ 1397 { } 1398 }, 1399 }, 1400 [ALC880_FIXUP_UNIWILL_DIG] = { 1401 .type = HDA_FIXUP_PINS, 1402 .v.pins = (const struct hda_pintbl[]) { 1403 /* disable bogus unused pins */ 1404 { 0x17, 0x411111f0 }, 1405 { 0x19, 0x411111f0 }, 1406 { 0x1b, 0x411111f0 }, 1407 { 0x1f, 0x411111f0 }, 1408 { } 1409 } 1410 }, 1411 [ALC880_FIXUP_Z71V] = { 1412 .type = HDA_FIXUP_PINS, 1413 .v.pins = (const struct hda_pintbl[]) { 1414 /* set up the whole pins as BIOS is utterly broken */ 1415 { 0x14, 0x99030120 }, /* speaker */ 1416 { 0x15, 0x0121411f }, /* HP */ 1417 { 0x16, 0x411111f0 }, /* N/A */ 1418 { 0x17, 0x411111f0 }, /* N/A */ 1419 { 0x18, 0x01a19950 }, /* mic-in */ 1420 { 0x19, 0x411111f0 }, /* N/A */ 1421 { 0x1a, 0x01813031 }, /* line-in */ 1422 { 0x1b, 0x411111f0 }, /* N/A */ 1423 { 0x1c, 0x411111f0 }, /* N/A */ 1424 { 0x1d, 0x411111f0 }, /* N/A */ 1425 { 0x1e, 0x0144111e }, /* SPDIF */ 1426 { } 1427 } 1428 }, 1429 [ALC880_FIXUP_ASUS_W5A] = { 1430 .type = HDA_FIXUP_PINS, 1431 .v.pins = (const struct hda_pintbl[]) { 1432 /* set up the whole pins as BIOS is utterly broken */ 1433 { 0x14, 0x0121411f }, /* HP */ 1434 { 0x15, 0x411111f0 }, /* N/A */ 1435 { 0x16, 0x411111f0 }, /* N/A */ 1436 { 0x17, 0x411111f0 }, /* N/A */ 1437 { 0x18, 0x90a60160 }, /* mic */ 1438 { 0x19, 0x411111f0 }, /* N/A */ 1439 { 0x1a, 0x411111f0 }, /* N/A */ 1440 { 0x1b, 0x411111f0 }, /* N/A */ 1441 { 0x1c, 0x411111f0 }, /* N/A */ 1442 { 0x1d, 0x411111f0 }, /* N/A */ 1443 { 0x1e, 0xb743111e }, /* SPDIF out */ 1444 { } 1445 }, 1446 .chained = true, 1447 .chain_id = ALC880_FIXUP_GPIO1, 1448 }, 1449 [ALC880_FIXUP_3ST_BASE] = { 1450 .type = HDA_FIXUP_PINS, 1451 .v.pins = (const struct hda_pintbl[]) { 1452 { 0x14, 0x01014010 }, /* line-out */ 1453 { 0x15, 0x411111f0 }, /* N/A */ 1454 { 0x16, 0x411111f0 }, /* N/A */ 1455 { 0x17, 0x411111f0 }, /* N/A */ 1456 { 0x18, 0x01a19c30 }, /* mic-in */ 1457 { 0x19, 0x0121411f }, /* HP */ 1458 { 0x1a, 0x01813031 }, /* line-in */ 1459 { 0x1b, 0x02a19c40 }, /* front-mic */ 1460 { 0x1c, 0x411111f0 }, /* N/A */ 1461 { 0x1d, 0x411111f0 }, /* N/A */ 1462 /* 0x1e is filled in below */ 1463 { 0x1f, 0x411111f0 }, /* N/A */ 1464 { } 1465 } 1466 }, 1467 [ALC880_FIXUP_3ST] = { 1468 .type = HDA_FIXUP_PINS, 1469 .v.pins = (const struct hda_pintbl[]) { 1470 { 0x1e, 0x411111f0 }, /* N/A */ 1471 { } 1472 }, 1473 .chained = true, 1474 .chain_id = ALC880_FIXUP_3ST_BASE, 1475 }, 1476 [ALC880_FIXUP_3ST_DIG] = { 1477 .type = HDA_FIXUP_PINS, 1478 .v.pins = (const struct hda_pintbl[]) { 1479 { 0x1e, 0x0144111e }, /* SPDIF */ 1480 { } 1481 }, 1482 .chained = true, 1483 .chain_id = ALC880_FIXUP_3ST_BASE, 1484 }, 1485 [ALC880_FIXUP_5ST_BASE] = { 1486 .type = HDA_FIXUP_PINS, 1487 .v.pins = (const struct hda_pintbl[]) { 1488 { 0x14, 0x01014010 }, /* front */ 1489 { 0x15, 0x411111f0 }, /* N/A */ 1490 { 0x16, 0x01011411 }, /* CLFE */ 1491 { 0x17, 0x01016412 }, /* surr */ 1492 { 0x18, 0x01a19c30 }, /* mic-in */ 1493 { 0x19, 0x0121411f }, /* HP */ 1494 { 0x1a, 0x01813031 }, /* line-in */ 1495 { 0x1b, 0x02a19c40 }, /* front-mic */ 1496 { 0x1c, 0x411111f0 }, /* N/A */ 1497 { 0x1d, 0x411111f0 }, /* N/A */ 1498 /* 0x1e is filled in below */ 1499 { 0x1f, 0x411111f0 }, /* N/A */ 1500 { } 1501 } 1502 }, 1503 [ALC880_FIXUP_5ST] = { 1504 .type = HDA_FIXUP_PINS, 1505 .v.pins = (const struct hda_pintbl[]) { 1506 { 0x1e, 0x411111f0 }, /* N/A */ 1507 { } 1508 }, 1509 .chained = true, 1510 .chain_id = ALC880_FIXUP_5ST_BASE, 1511 }, 1512 [ALC880_FIXUP_5ST_DIG] = { 1513 .type = HDA_FIXUP_PINS, 1514 .v.pins = (const struct hda_pintbl[]) { 1515 { 0x1e, 0x0144111e }, /* SPDIF */ 1516 { } 1517 }, 1518 .chained = true, 1519 .chain_id = ALC880_FIXUP_5ST_BASE, 1520 }, 1521 [ALC880_FIXUP_6ST_BASE] = { 1522 .type = HDA_FIXUP_PINS, 1523 .v.pins = (const struct hda_pintbl[]) { 1524 { 0x14, 0x01014010 }, /* front */ 1525 { 0x15, 0x01016412 }, /* surr */ 1526 { 0x16, 0x01011411 }, /* CLFE */ 1527 { 0x17, 0x01012414 }, /* side */ 1528 { 0x18, 0x01a19c30 }, /* mic-in */ 1529 { 0x19, 0x02a19c40 }, /* front-mic */ 1530 { 0x1a, 0x01813031 }, /* line-in */ 1531 { 0x1b, 0x0121411f }, /* HP */ 1532 { 0x1c, 0x411111f0 }, /* N/A */ 1533 { 0x1d, 0x411111f0 }, /* N/A */ 1534 /* 0x1e is filled in below */ 1535 { 0x1f, 0x411111f0 }, /* N/A */ 1536 { } 1537 } 1538 }, 1539 [ALC880_FIXUP_6ST] = { 1540 .type = HDA_FIXUP_PINS, 1541 .v.pins = (const struct hda_pintbl[]) { 1542 { 0x1e, 0x411111f0 }, /* N/A */ 1543 { } 1544 }, 1545 .chained = true, 1546 .chain_id = ALC880_FIXUP_6ST_BASE, 1547 }, 1548 [ALC880_FIXUP_6ST_DIG] = { 1549 .type = HDA_FIXUP_PINS, 1550 .v.pins = (const struct hda_pintbl[]) { 1551 { 0x1e, 0x0144111e }, /* SPDIF */ 1552 { } 1553 }, 1554 .chained = true, 1555 .chain_id = ALC880_FIXUP_6ST_BASE, 1556 }, 1557 [ALC880_FIXUP_6ST_AUTOMUTE] = { 1558 .type = HDA_FIXUP_PINS, 1559 .v.pins = (const struct hda_pintbl[]) { 1560 { 0x1b, 0x0121401f }, /* HP with jack detect */ 1561 { } 1562 }, 1563 .chained_before = true, 1564 .chain_id = ALC880_FIXUP_6ST_BASE, 1565 }, 1566 }; 1567 1568 static const struct snd_pci_quirk alc880_fixup_tbl[] = { 1569 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810), 1570 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A), 1571 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V), 1572 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1), 1573 SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE), 1574 SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2), 1575 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF), 1576 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG), 1577 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734), 1578 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL), 1579 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB), 1580 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810), 1581 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM), 1582 SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE), 1583 SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU), 1584 SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU), 1585 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734), 1586 SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU), 1587 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG), 1588 SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG), 1589 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG), 1590 SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25), 1591 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700), 1592 1593 /* Below is the copied entries from alc880_quirks.c. 1594 * It's not quite sure whether BIOS sets the correct pin-config table 1595 * on these machines, thus they are kept to be compatible with 1596 * the old static quirks. Once when it's confirmed to work without 1597 * these overrides, it'd be better to remove. 1598 */ 1599 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG), 1600 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST), 1601 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG), 1602 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG), 1603 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG), 1604 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG), 1605 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG), 1606 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST), 1607 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG), 1608 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST), 1609 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST), 1610 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST), 1611 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST), 1612 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST), 1613 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG), 1614 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG), 1615 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG), 1616 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG), 1617 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG), 1618 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG), 1619 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG), 1620 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */ 1621 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG), 1622 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1623 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1624 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1625 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG), 1626 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1627 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG), 1628 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG), 1629 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1630 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1631 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1632 /* default Intel */ 1633 SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST), 1634 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG), 1635 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG), 1636 {} 1637 }; 1638 1639 static const struct hda_model_fixup alc880_fixup_models[] = { 1640 {.id = ALC880_FIXUP_3ST, .name = "3stack"}, 1641 {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"}, 1642 {.id = ALC880_FIXUP_5ST, .name = "5stack"}, 1643 {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"}, 1644 {.id = ALC880_FIXUP_6ST, .name = "6stack"}, 1645 {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"}, 1646 {.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"}, 1647 {} 1648 }; 1649 1650 1651 /* 1652 * OK, here we have finally the patch for ALC880 1653 */ 1654 static int patch_alc880(struct hda_codec *codec) 1655 { 1656 struct alc_spec *spec; 1657 int err; 1658 1659 err = alc_alloc_spec(codec, 0x0b); 1660 if (err < 0) 1661 return err; 1662 1663 spec = codec->spec; 1664 spec->gen.need_dac_fix = 1; 1665 spec->gen.beep_nid = 0x01; 1666 1667 codec->patch_ops.unsol_event = alc880_unsol_event; 1668 1669 alc_pre_init(codec); 1670 1671 snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl, 1672 alc880_fixups); 1673 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 1674 1675 /* automatic parse from the BIOS config */ 1676 err = alc880_parse_auto_config(codec); 1677 if (err < 0) 1678 goto error; 1679 1680 if (!spec->gen.no_analog) { 1681 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 1682 if (err < 0) 1683 goto error; 1684 } 1685 1686 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 1687 1688 return 0; 1689 1690 error: 1691 alc_free(codec); 1692 return err; 1693 } 1694 1695 1696 /* 1697 * ALC260 support 1698 */ 1699 static int alc260_parse_auto_config(struct hda_codec *codec) 1700 { 1701 static const hda_nid_t alc260_ignore[] = { 0x17, 0 }; 1702 static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 }; 1703 return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids); 1704 } 1705 1706 /* 1707 * Pin config fixes 1708 */ 1709 enum { 1710 ALC260_FIXUP_HP_DC5750, 1711 ALC260_FIXUP_HP_PIN_0F, 1712 ALC260_FIXUP_COEF, 1713 ALC260_FIXUP_GPIO1, 1714 ALC260_FIXUP_GPIO1_TOGGLE, 1715 ALC260_FIXUP_REPLACER, 1716 ALC260_FIXUP_HP_B1900, 1717 ALC260_FIXUP_KN1, 1718 ALC260_FIXUP_FSC_S7020, 1719 ALC260_FIXUP_FSC_S7020_JWSE, 1720 ALC260_FIXUP_VAIO_PINS, 1721 }; 1722 1723 static void alc260_gpio1_automute(struct hda_codec *codec) 1724 { 1725 struct alc_spec *spec = codec->spec; 1726 1727 alc_update_gpio_data(codec, 0x01, spec->gen.hp_jack_present); 1728 } 1729 1730 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec, 1731 const struct hda_fixup *fix, int action) 1732 { 1733 struct alc_spec *spec = codec->spec; 1734 if (action == HDA_FIXUP_ACT_PROBE) { 1735 /* although the machine has only one output pin, we need to 1736 * toggle GPIO1 according to the jack state 1737 */ 1738 spec->gen.automute_hook = alc260_gpio1_automute; 1739 spec->gen.detect_hp = 1; 1740 spec->gen.automute_speaker = 1; 1741 spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */ 1742 snd_hda_jack_detect_enable_callback(codec, 0x0f, 1743 snd_hda_gen_hp_automute); 1744 alc_setup_gpio(codec, 0x01); 1745 } 1746 } 1747 1748 static void alc260_fixup_kn1(struct hda_codec *codec, 1749 const struct hda_fixup *fix, int action) 1750 { 1751 struct alc_spec *spec = codec->spec; 1752 static const struct hda_pintbl pincfgs[] = { 1753 { 0x0f, 0x02214000 }, /* HP/speaker */ 1754 { 0x12, 0x90a60160 }, /* int mic */ 1755 { 0x13, 0x02a19000 }, /* ext mic */ 1756 { 0x18, 0x01446000 }, /* SPDIF out */ 1757 /* disable bogus I/O pins */ 1758 { 0x10, 0x411111f0 }, 1759 { 0x11, 0x411111f0 }, 1760 { 0x14, 0x411111f0 }, 1761 { 0x15, 0x411111f0 }, 1762 { 0x16, 0x411111f0 }, 1763 { 0x17, 0x411111f0 }, 1764 { 0x19, 0x411111f0 }, 1765 { } 1766 }; 1767 1768 switch (action) { 1769 case HDA_FIXUP_ACT_PRE_PROBE: 1770 snd_hda_apply_pincfgs(codec, pincfgs); 1771 spec->init_amp = ALC_INIT_NONE; 1772 break; 1773 } 1774 } 1775 1776 static void alc260_fixup_fsc_s7020(struct hda_codec *codec, 1777 const struct hda_fixup *fix, int action) 1778 { 1779 struct alc_spec *spec = codec->spec; 1780 if (action == HDA_FIXUP_ACT_PRE_PROBE) 1781 spec->init_amp = ALC_INIT_NONE; 1782 } 1783 1784 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec, 1785 const struct hda_fixup *fix, int action) 1786 { 1787 struct alc_spec *spec = codec->spec; 1788 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1789 spec->gen.add_jack_modes = 1; 1790 spec->gen.hp_mic = 1; 1791 } 1792 } 1793 1794 static const struct hda_fixup alc260_fixups[] = { 1795 [ALC260_FIXUP_HP_DC5750] = { 1796 .type = HDA_FIXUP_PINS, 1797 .v.pins = (const struct hda_pintbl[]) { 1798 { 0x11, 0x90130110 }, /* speaker */ 1799 { } 1800 } 1801 }, 1802 [ALC260_FIXUP_HP_PIN_0F] = { 1803 .type = HDA_FIXUP_PINS, 1804 .v.pins = (const struct hda_pintbl[]) { 1805 { 0x0f, 0x01214000 }, /* HP */ 1806 { } 1807 } 1808 }, 1809 [ALC260_FIXUP_COEF] = { 1810 .type = HDA_FIXUP_VERBS, 1811 .v.verbs = (const struct hda_verb[]) { 1812 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 }, 1813 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3040 }, 1814 { } 1815 }, 1816 }, 1817 [ALC260_FIXUP_GPIO1] = { 1818 .type = HDA_FIXUP_FUNC, 1819 .v.func = alc_fixup_gpio1, 1820 }, 1821 [ALC260_FIXUP_GPIO1_TOGGLE] = { 1822 .type = HDA_FIXUP_FUNC, 1823 .v.func = alc260_fixup_gpio1_toggle, 1824 .chained = true, 1825 .chain_id = ALC260_FIXUP_HP_PIN_0F, 1826 }, 1827 [ALC260_FIXUP_REPLACER] = { 1828 .type = HDA_FIXUP_VERBS, 1829 .v.verbs = (const struct hda_verb[]) { 1830 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 }, 1831 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3050 }, 1832 { } 1833 }, 1834 .chained = true, 1835 .chain_id = ALC260_FIXUP_GPIO1_TOGGLE, 1836 }, 1837 [ALC260_FIXUP_HP_B1900] = { 1838 .type = HDA_FIXUP_FUNC, 1839 .v.func = alc260_fixup_gpio1_toggle, 1840 .chained = true, 1841 .chain_id = ALC260_FIXUP_COEF, 1842 }, 1843 [ALC260_FIXUP_KN1] = { 1844 .type = HDA_FIXUP_FUNC, 1845 .v.func = alc260_fixup_kn1, 1846 }, 1847 [ALC260_FIXUP_FSC_S7020] = { 1848 .type = HDA_FIXUP_FUNC, 1849 .v.func = alc260_fixup_fsc_s7020, 1850 }, 1851 [ALC260_FIXUP_FSC_S7020_JWSE] = { 1852 .type = HDA_FIXUP_FUNC, 1853 .v.func = alc260_fixup_fsc_s7020_jwse, 1854 .chained = true, 1855 .chain_id = ALC260_FIXUP_FSC_S7020, 1856 }, 1857 [ALC260_FIXUP_VAIO_PINS] = { 1858 .type = HDA_FIXUP_PINS, 1859 .v.pins = (const struct hda_pintbl[]) { 1860 /* Pin configs are missing completely on some VAIOs */ 1861 { 0x0f, 0x01211020 }, 1862 { 0x10, 0x0001003f }, 1863 { 0x11, 0x411111f0 }, 1864 { 0x12, 0x01a15930 }, 1865 { 0x13, 0x411111f0 }, 1866 { 0x14, 0x411111f0 }, 1867 { 0x15, 0x411111f0 }, 1868 { 0x16, 0x411111f0 }, 1869 { 0x17, 0x411111f0 }, 1870 { 0x18, 0x411111f0 }, 1871 { 0x19, 0x411111f0 }, 1872 { } 1873 } 1874 }, 1875 }; 1876 1877 static const struct snd_pci_quirk alc260_fixup_tbl[] = { 1878 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1), 1879 SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF), 1880 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1), 1881 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750), 1882 SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900), 1883 SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS), 1884 SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F), 1885 SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020), 1886 SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1), 1887 SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1), 1888 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER), 1889 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF), 1890 {} 1891 }; 1892 1893 static const struct hda_model_fixup alc260_fixup_models[] = { 1894 {.id = ALC260_FIXUP_GPIO1, .name = "gpio1"}, 1895 {.id = ALC260_FIXUP_COEF, .name = "coef"}, 1896 {.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"}, 1897 {.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"}, 1898 {} 1899 }; 1900 1901 /* 1902 */ 1903 static int patch_alc260(struct hda_codec *codec) 1904 { 1905 struct alc_spec *spec; 1906 int err; 1907 1908 err = alc_alloc_spec(codec, 0x07); 1909 if (err < 0) 1910 return err; 1911 1912 spec = codec->spec; 1913 /* as quite a few machines require HP amp for speaker outputs, 1914 * it's easier to enable it unconditionally; even if it's unneeded, 1915 * it's almost harmless. 1916 */ 1917 spec->gen.prefer_hp_amp = 1; 1918 spec->gen.beep_nid = 0x01; 1919 1920 spec->shutup = alc_eapd_shutup; 1921 1922 alc_pre_init(codec); 1923 1924 snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl, 1925 alc260_fixups); 1926 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 1927 1928 /* automatic parse from the BIOS config */ 1929 err = alc260_parse_auto_config(codec); 1930 if (err < 0) 1931 goto error; 1932 1933 if (!spec->gen.no_analog) { 1934 err = set_beep_amp(spec, 0x07, 0x05, HDA_INPUT); 1935 if (err < 0) 1936 goto error; 1937 } 1938 1939 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 1940 1941 return 0; 1942 1943 error: 1944 alc_free(codec); 1945 return err; 1946 } 1947 1948 1949 /* 1950 * ALC882/883/885/888/889 support 1951 * 1952 * ALC882 is almost identical with ALC880 but has cleaner and more flexible 1953 * configuration. Each pin widget can choose any input DACs and a mixer. 1954 * Each ADC is connected from a mixer of all inputs. This makes possible 1955 * 6-channel independent captures. 1956 * 1957 * In addition, an independent DAC for the multi-playback (not used in this 1958 * driver yet). 1959 */ 1960 1961 /* 1962 * Pin config fixes 1963 */ 1964 enum { 1965 ALC882_FIXUP_ABIT_AW9D_MAX, 1966 ALC882_FIXUP_LENOVO_Y530, 1967 ALC882_FIXUP_PB_M5210, 1968 ALC882_FIXUP_ACER_ASPIRE_7736, 1969 ALC882_FIXUP_ASUS_W90V, 1970 ALC889_FIXUP_CD, 1971 ALC889_FIXUP_FRONT_HP_NO_PRESENCE, 1972 ALC889_FIXUP_VAIO_TT, 1973 ALC888_FIXUP_EEE1601, 1974 ALC886_FIXUP_EAPD, 1975 ALC882_FIXUP_EAPD, 1976 ALC883_FIXUP_EAPD, 1977 ALC883_FIXUP_ACER_EAPD, 1978 ALC882_FIXUP_GPIO1, 1979 ALC882_FIXUP_GPIO2, 1980 ALC882_FIXUP_GPIO3, 1981 ALC889_FIXUP_COEF, 1982 ALC882_FIXUP_ASUS_W2JC, 1983 ALC882_FIXUP_ACER_ASPIRE_4930G, 1984 ALC882_FIXUP_ACER_ASPIRE_8930G, 1985 ALC882_FIXUP_ASPIRE_8930G_VERBS, 1986 ALC885_FIXUP_MACPRO_GPIO, 1987 ALC889_FIXUP_DAC_ROUTE, 1988 ALC889_FIXUP_MBP_VREF, 1989 ALC889_FIXUP_IMAC91_VREF, 1990 ALC889_FIXUP_MBA11_VREF, 1991 ALC889_FIXUP_MBA21_VREF, 1992 ALC889_FIXUP_MP11_VREF, 1993 ALC889_FIXUP_MP41_VREF, 1994 ALC882_FIXUP_INV_DMIC, 1995 ALC882_FIXUP_NO_PRIMARY_HP, 1996 ALC887_FIXUP_ASUS_BASS, 1997 ALC887_FIXUP_BASS_CHMAP, 1998 ALC1220_FIXUP_GB_DUAL_CODECS, 1999 ALC1220_FIXUP_GB_X570, 2000 ALC1220_FIXUP_CLEVO_P950, 2001 ALC1220_FIXUP_CLEVO_PB51ED, 2002 ALC1220_FIXUP_CLEVO_PB51ED_PINS, 2003 ALC887_FIXUP_ASUS_AUDIO, 2004 ALC887_FIXUP_ASUS_HMIC, 2005 ALCS1200A_FIXUP_MIC_VREF, 2006 ALC888VD_FIXUP_MIC_100VREF, 2007 }; 2008 2009 static void alc889_fixup_coef(struct hda_codec *codec, 2010 const struct hda_fixup *fix, int action) 2011 { 2012 if (action != HDA_FIXUP_ACT_INIT) 2013 return; 2014 alc_update_coef_idx(codec, 7, 0, 0x2030); 2015 } 2016 2017 /* set up GPIO at initialization */ 2018 static void alc885_fixup_macpro_gpio(struct hda_codec *codec, 2019 const struct hda_fixup *fix, int action) 2020 { 2021 struct alc_spec *spec = codec->spec; 2022 2023 spec->gpio_write_delay = true; 2024 alc_fixup_gpio3(codec, fix, action); 2025 } 2026 2027 /* Fix the connection of some pins for ALC889: 2028 * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't 2029 * work correctly (bko#42740) 2030 */ 2031 static void alc889_fixup_dac_route(struct hda_codec *codec, 2032 const struct hda_fixup *fix, int action) 2033 { 2034 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2035 /* fake the connections during parsing the tree */ 2036 static const hda_nid_t conn1[] = { 0x0c, 0x0d }; 2037 static const hda_nid_t conn2[] = { 0x0e, 0x0f }; 2038 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1); 2039 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1); 2040 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn2), conn2); 2041 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn2), conn2); 2042 } else if (action == HDA_FIXUP_ACT_PROBE) { 2043 /* restore the connections */ 2044 static const hda_nid_t conn[] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 }; 2045 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn); 2046 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn), conn); 2047 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn), conn); 2048 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn), conn); 2049 } 2050 } 2051 2052 /* Set VREF on HP pin */ 2053 static void alc889_fixup_mbp_vref(struct hda_codec *codec, 2054 const struct hda_fixup *fix, int action) 2055 { 2056 static const hda_nid_t nids[] = { 0x14, 0x15, 0x19 }; 2057 struct alc_spec *spec = codec->spec; 2058 int i; 2059 2060 if (action != HDA_FIXUP_ACT_INIT) 2061 return; 2062 for (i = 0; i < ARRAY_SIZE(nids); i++) { 2063 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]); 2064 if (get_defcfg_device(val) != AC_JACK_HP_OUT) 2065 continue; 2066 val = snd_hda_codec_get_pin_target(codec, nids[i]); 2067 val |= AC_PINCTL_VREF_80; 2068 snd_hda_set_pin_ctl(codec, nids[i], val); 2069 spec->gen.keep_vref_in_automute = 1; 2070 break; 2071 } 2072 } 2073 2074 static void alc889_fixup_mac_pins(struct hda_codec *codec, 2075 const hda_nid_t *nids, int num_nids) 2076 { 2077 struct alc_spec *spec = codec->spec; 2078 int i; 2079 2080 for (i = 0; i < num_nids; i++) { 2081 unsigned int val; 2082 val = snd_hda_codec_get_pin_target(codec, nids[i]); 2083 val |= AC_PINCTL_VREF_50; 2084 snd_hda_set_pin_ctl(codec, nids[i], val); 2085 } 2086 spec->gen.keep_vref_in_automute = 1; 2087 } 2088 2089 /* Set VREF on speaker pins on imac91 */ 2090 static void alc889_fixup_imac91_vref(struct hda_codec *codec, 2091 const struct hda_fixup *fix, int action) 2092 { 2093 static const hda_nid_t nids[] = { 0x18, 0x1a }; 2094 2095 if (action == HDA_FIXUP_ACT_INIT) 2096 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids)); 2097 } 2098 2099 /* Set VREF on speaker pins on mba11 */ 2100 static void alc889_fixup_mba11_vref(struct hda_codec *codec, 2101 const struct hda_fixup *fix, int action) 2102 { 2103 static const hda_nid_t nids[] = { 0x18 }; 2104 2105 if (action == HDA_FIXUP_ACT_INIT) 2106 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids)); 2107 } 2108 2109 /* Set VREF on speaker pins on mba21 */ 2110 static void alc889_fixup_mba21_vref(struct hda_codec *codec, 2111 const struct hda_fixup *fix, int action) 2112 { 2113 static const hda_nid_t nids[] = { 0x18, 0x19 }; 2114 2115 if (action == HDA_FIXUP_ACT_INIT) 2116 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids)); 2117 } 2118 2119 /* Don't take HP output as primary 2120 * Strangely, the speaker output doesn't work on Vaio Z and some Vaio 2121 * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05 2122 */ 2123 static void alc882_fixup_no_primary_hp(struct hda_codec *codec, 2124 const struct hda_fixup *fix, int action) 2125 { 2126 struct alc_spec *spec = codec->spec; 2127 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2128 spec->gen.no_primary_hp = 1; 2129 spec->gen.no_multi_io = 1; 2130 } 2131 } 2132 2133 static void alc_fixup_bass_chmap(struct hda_codec *codec, 2134 const struct hda_fixup *fix, int action); 2135 2136 /* For dual-codec configuration, we need to disable some features to avoid 2137 * conflicts of kctls and PCM streams 2138 */ 2139 static void alc_fixup_dual_codecs(struct hda_codec *codec, 2140 const struct hda_fixup *fix, int action) 2141 { 2142 struct alc_spec *spec = codec->spec; 2143 2144 if (action != HDA_FIXUP_ACT_PRE_PROBE) 2145 return; 2146 /* disable vmaster */ 2147 spec->gen.suppress_vmaster = 1; 2148 /* auto-mute and auto-mic switch don't work with multiple codecs */ 2149 spec->gen.suppress_auto_mute = 1; 2150 spec->gen.suppress_auto_mic = 1; 2151 /* disable aamix as well */ 2152 spec->gen.mixer_nid = 0; 2153 /* add location prefix to avoid conflicts */ 2154 codec->force_pin_prefix = 1; 2155 } 2156 2157 static void rename_ctl(struct hda_codec *codec, const char *oldname, 2158 const char *newname) 2159 { 2160 struct snd_kcontrol *kctl; 2161 2162 kctl = snd_hda_find_mixer_ctl(codec, oldname); 2163 if (kctl) 2164 snd_ctl_rename(codec->card, kctl, newname); 2165 } 2166 2167 static void alc1220_fixup_gb_dual_codecs(struct hda_codec *codec, 2168 const struct hda_fixup *fix, 2169 int action) 2170 { 2171 alc_fixup_dual_codecs(codec, fix, action); 2172 switch (action) { 2173 case HDA_FIXUP_ACT_PRE_PROBE: 2174 /* override card longname to provide a unique UCM profile */ 2175 strcpy(codec->card->longname, "HDAudio-Gigabyte-ALC1220DualCodecs"); 2176 break; 2177 case HDA_FIXUP_ACT_BUILD: 2178 /* rename Capture controls depending on the codec */ 2179 rename_ctl(codec, "Capture Volume", 2180 codec->addr == 0 ? 2181 "Rear-Panel Capture Volume" : 2182 "Front-Panel Capture Volume"); 2183 rename_ctl(codec, "Capture Switch", 2184 codec->addr == 0 ? 2185 "Rear-Panel Capture Switch" : 2186 "Front-Panel Capture Switch"); 2187 break; 2188 } 2189 } 2190 2191 static void alc1220_fixup_gb_x570(struct hda_codec *codec, 2192 const struct hda_fixup *fix, 2193 int action) 2194 { 2195 static const hda_nid_t conn1[] = { 0x0c }; 2196 static const struct coef_fw gb_x570_coefs[] = { 2197 WRITE_COEF(0x07, 0x03c0), 2198 WRITE_COEF(0x1a, 0x01c1), 2199 WRITE_COEF(0x1b, 0x0202), 2200 WRITE_COEF(0x43, 0x3005), 2201 {} 2202 }; 2203 2204 switch (action) { 2205 case HDA_FIXUP_ACT_PRE_PROBE: 2206 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1); 2207 snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1); 2208 break; 2209 case HDA_FIXUP_ACT_INIT: 2210 alc_process_coef_fw(codec, gb_x570_coefs); 2211 break; 2212 } 2213 } 2214 2215 static void alc1220_fixup_clevo_p950(struct hda_codec *codec, 2216 const struct hda_fixup *fix, 2217 int action) 2218 { 2219 static const hda_nid_t conn1[] = { 0x0c }; 2220 2221 if (action != HDA_FIXUP_ACT_PRE_PROBE) 2222 return; 2223 2224 alc_update_coef_idx(codec, 0x7, 0, 0x3c3); 2225 /* We therefore want to make sure 0x14 (front headphone) and 2226 * 0x1b (speakers) use the stereo DAC 0x02 2227 */ 2228 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1); 2229 snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1); 2230 } 2231 2232 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec, 2233 const struct hda_fixup *fix, int action); 2234 2235 static void alc1220_fixup_clevo_pb51ed(struct hda_codec *codec, 2236 const struct hda_fixup *fix, 2237 int action) 2238 { 2239 alc1220_fixup_clevo_p950(codec, fix, action); 2240 alc_fixup_headset_mode_no_hp_mic(codec, fix, action); 2241 } 2242 2243 static void alc887_asus_hp_automute_hook(struct hda_codec *codec, 2244 struct hda_jack_callback *jack) 2245 { 2246 struct alc_spec *spec = codec->spec; 2247 unsigned int vref; 2248 2249 snd_hda_gen_hp_automute(codec, jack); 2250 2251 if (spec->gen.hp_jack_present) 2252 vref = AC_PINCTL_VREF_80; 2253 else 2254 vref = AC_PINCTL_VREF_HIZ; 2255 snd_hda_set_pin_ctl(codec, 0x19, PIN_HP | vref); 2256 } 2257 2258 static void alc887_fixup_asus_jack(struct hda_codec *codec, 2259 const struct hda_fixup *fix, int action) 2260 { 2261 struct alc_spec *spec = codec->spec; 2262 if (action != HDA_FIXUP_ACT_PROBE) 2263 return; 2264 snd_hda_set_pin_ctl_cache(codec, 0x1b, PIN_HP); 2265 spec->gen.hp_automute_hook = alc887_asus_hp_automute_hook; 2266 } 2267 2268 static const struct hda_fixup alc882_fixups[] = { 2269 [ALC882_FIXUP_ABIT_AW9D_MAX] = { 2270 .type = HDA_FIXUP_PINS, 2271 .v.pins = (const struct hda_pintbl[]) { 2272 { 0x15, 0x01080104 }, /* side */ 2273 { 0x16, 0x01011012 }, /* rear */ 2274 { 0x17, 0x01016011 }, /* clfe */ 2275 { } 2276 } 2277 }, 2278 [ALC882_FIXUP_LENOVO_Y530] = { 2279 .type = HDA_FIXUP_PINS, 2280 .v.pins = (const struct hda_pintbl[]) { 2281 { 0x15, 0x99130112 }, /* rear int speakers */ 2282 { 0x16, 0x99130111 }, /* subwoofer */ 2283 { } 2284 } 2285 }, 2286 [ALC882_FIXUP_PB_M5210] = { 2287 .type = HDA_FIXUP_PINCTLS, 2288 .v.pins = (const struct hda_pintbl[]) { 2289 { 0x19, PIN_VREF50 }, 2290 {} 2291 } 2292 }, 2293 [ALC882_FIXUP_ACER_ASPIRE_7736] = { 2294 .type = HDA_FIXUP_FUNC, 2295 .v.func = alc_fixup_sku_ignore, 2296 }, 2297 [ALC882_FIXUP_ASUS_W90V] = { 2298 .type = HDA_FIXUP_PINS, 2299 .v.pins = (const struct hda_pintbl[]) { 2300 { 0x16, 0x99130110 }, /* fix sequence for CLFE */ 2301 { } 2302 } 2303 }, 2304 [ALC889_FIXUP_CD] = { 2305 .type = HDA_FIXUP_PINS, 2306 .v.pins = (const struct hda_pintbl[]) { 2307 { 0x1c, 0x993301f0 }, /* CD */ 2308 { } 2309 } 2310 }, 2311 [ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = { 2312 .type = HDA_FIXUP_PINS, 2313 .v.pins = (const struct hda_pintbl[]) { 2314 { 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */ 2315 { } 2316 }, 2317 .chained = true, 2318 .chain_id = ALC889_FIXUP_CD, 2319 }, 2320 [ALC889_FIXUP_VAIO_TT] = { 2321 .type = HDA_FIXUP_PINS, 2322 .v.pins = (const struct hda_pintbl[]) { 2323 { 0x17, 0x90170111 }, /* hidden surround speaker */ 2324 { } 2325 } 2326 }, 2327 [ALC888_FIXUP_EEE1601] = { 2328 .type = HDA_FIXUP_VERBS, 2329 .v.verbs = (const struct hda_verb[]) { 2330 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b }, 2331 { 0x20, AC_VERB_SET_PROC_COEF, 0x0838 }, 2332 { } 2333 } 2334 }, 2335 [ALC886_FIXUP_EAPD] = { 2336 .type = HDA_FIXUP_VERBS, 2337 .v.verbs = (const struct hda_verb[]) { 2338 /* change to EAPD mode */ 2339 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2340 { 0x20, AC_VERB_SET_PROC_COEF, 0x0068 }, 2341 { } 2342 } 2343 }, 2344 [ALC882_FIXUP_EAPD] = { 2345 .type = HDA_FIXUP_VERBS, 2346 .v.verbs = (const struct hda_verb[]) { 2347 /* change to EAPD mode */ 2348 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2349 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 }, 2350 { } 2351 } 2352 }, 2353 [ALC883_FIXUP_EAPD] = { 2354 .type = HDA_FIXUP_VERBS, 2355 .v.verbs = (const struct hda_verb[]) { 2356 /* change to EAPD mode */ 2357 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2358 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 }, 2359 { } 2360 } 2361 }, 2362 [ALC883_FIXUP_ACER_EAPD] = { 2363 .type = HDA_FIXUP_VERBS, 2364 .v.verbs = (const struct hda_verb[]) { 2365 /* eanable EAPD on Acer laptops */ 2366 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2367 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 }, 2368 { } 2369 } 2370 }, 2371 [ALC882_FIXUP_GPIO1] = { 2372 .type = HDA_FIXUP_FUNC, 2373 .v.func = alc_fixup_gpio1, 2374 }, 2375 [ALC882_FIXUP_GPIO2] = { 2376 .type = HDA_FIXUP_FUNC, 2377 .v.func = alc_fixup_gpio2, 2378 }, 2379 [ALC882_FIXUP_GPIO3] = { 2380 .type = HDA_FIXUP_FUNC, 2381 .v.func = alc_fixup_gpio3, 2382 }, 2383 [ALC882_FIXUP_ASUS_W2JC] = { 2384 .type = HDA_FIXUP_FUNC, 2385 .v.func = alc_fixup_gpio1, 2386 .chained = true, 2387 .chain_id = ALC882_FIXUP_EAPD, 2388 }, 2389 [ALC889_FIXUP_COEF] = { 2390 .type = HDA_FIXUP_FUNC, 2391 .v.func = alc889_fixup_coef, 2392 }, 2393 [ALC882_FIXUP_ACER_ASPIRE_4930G] = { 2394 .type = HDA_FIXUP_PINS, 2395 .v.pins = (const struct hda_pintbl[]) { 2396 { 0x16, 0x99130111 }, /* CLFE speaker */ 2397 { 0x17, 0x99130112 }, /* surround speaker */ 2398 { } 2399 }, 2400 .chained = true, 2401 .chain_id = ALC882_FIXUP_GPIO1, 2402 }, 2403 [ALC882_FIXUP_ACER_ASPIRE_8930G] = { 2404 .type = HDA_FIXUP_PINS, 2405 .v.pins = (const struct hda_pintbl[]) { 2406 { 0x16, 0x99130111 }, /* CLFE speaker */ 2407 { 0x1b, 0x99130112 }, /* surround speaker */ 2408 { } 2409 }, 2410 .chained = true, 2411 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS, 2412 }, 2413 [ALC882_FIXUP_ASPIRE_8930G_VERBS] = { 2414 /* additional init verbs for Acer Aspire 8930G */ 2415 .type = HDA_FIXUP_VERBS, 2416 .v.verbs = (const struct hda_verb[]) { 2417 /* Enable all DACs */ 2418 /* DAC DISABLE/MUTE 1? */ 2419 /* setting bits 1-5 disables DAC nids 0x02-0x06 2420 * apparently. Init=0x38 */ 2421 { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 }, 2422 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 }, 2423 /* DAC DISABLE/MUTE 2? */ 2424 /* some bit here disables the other DACs. 2425 * Init=0x4900 */ 2426 { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 }, 2427 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 }, 2428 /* DMIC fix 2429 * This laptop has a stereo digital microphone. 2430 * The mics are only 1cm apart which makes the stereo 2431 * useless. However, either the mic or the ALC889 2432 * makes the signal become a difference/sum signal 2433 * instead of standard stereo, which is annoying. 2434 * So instead we flip this bit which makes the 2435 * codec replicate the sum signal to both channels, 2436 * turning it into a normal mono mic. 2437 */ 2438 /* DMIC_CONTROL? Init value = 0x0001 */ 2439 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b }, 2440 { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 }, 2441 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2442 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 }, 2443 { } 2444 }, 2445 .chained = true, 2446 .chain_id = ALC882_FIXUP_GPIO1, 2447 }, 2448 [ALC885_FIXUP_MACPRO_GPIO] = { 2449 .type = HDA_FIXUP_FUNC, 2450 .v.func = alc885_fixup_macpro_gpio, 2451 }, 2452 [ALC889_FIXUP_DAC_ROUTE] = { 2453 .type = HDA_FIXUP_FUNC, 2454 .v.func = alc889_fixup_dac_route, 2455 }, 2456 [ALC889_FIXUP_MBP_VREF] = { 2457 .type = HDA_FIXUP_FUNC, 2458 .v.func = alc889_fixup_mbp_vref, 2459 .chained = true, 2460 .chain_id = ALC882_FIXUP_GPIO1, 2461 }, 2462 [ALC889_FIXUP_IMAC91_VREF] = { 2463 .type = HDA_FIXUP_FUNC, 2464 .v.func = alc889_fixup_imac91_vref, 2465 .chained = true, 2466 .chain_id = ALC882_FIXUP_GPIO1, 2467 }, 2468 [ALC889_FIXUP_MBA11_VREF] = { 2469 .type = HDA_FIXUP_FUNC, 2470 .v.func = alc889_fixup_mba11_vref, 2471 .chained = true, 2472 .chain_id = ALC889_FIXUP_MBP_VREF, 2473 }, 2474 [ALC889_FIXUP_MBA21_VREF] = { 2475 .type = HDA_FIXUP_FUNC, 2476 .v.func = alc889_fixup_mba21_vref, 2477 .chained = true, 2478 .chain_id = ALC889_FIXUP_MBP_VREF, 2479 }, 2480 [ALC889_FIXUP_MP11_VREF] = { 2481 .type = HDA_FIXUP_FUNC, 2482 .v.func = alc889_fixup_mba11_vref, 2483 .chained = true, 2484 .chain_id = ALC885_FIXUP_MACPRO_GPIO, 2485 }, 2486 [ALC889_FIXUP_MP41_VREF] = { 2487 .type = HDA_FIXUP_FUNC, 2488 .v.func = alc889_fixup_mbp_vref, 2489 .chained = true, 2490 .chain_id = ALC885_FIXUP_MACPRO_GPIO, 2491 }, 2492 [ALC882_FIXUP_INV_DMIC] = { 2493 .type = HDA_FIXUP_FUNC, 2494 .v.func = alc_fixup_inv_dmic, 2495 }, 2496 [ALC882_FIXUP_NO_PRIMARY_HP] = { 2497 .type = HDA_FIXUP_FUNC, 2498 .v.func = alc882_fixup_no_primary_hp, 2499 }, 2500 [ALC887_FIXUP_ASUS_BASS] = { 2501 .type = HDA_FIXUP_PINS, 2502 .v.pins = (const struct hda_pintbl[]) { 2503 {0x16, 0x99130130}, /* bass speaker */ 2504 {} 2505 }, 2506 .chained = true, 2507 .chain_id = ALC887_FIXUP_BASS_CHMAP, 2508 }, 2509 [ALC887_FIXUP_BASS_CHMAP] = { 2510 .type = HDA_FIXUP_FUNC, 2511 .v.func = alc_fixup_bass_chmap, 2512 }, 2513 [ALC1220_FIXUP_GB_DUAL_CODECS] = { 2514 .type = HDA_FIXUP_FUNC, 2515 .v.func = alc1220_fixup_gb_dual_codecs, 2516 }, 2517 [ALC1220_FIXUP_GB_X570] = { 2518 .type = HDA_FIXUP_FUNC, 2519 .v.func = alc1220_fixup_gb_x570, 2520 }, 2521 [ALC1220_FIXUP_CLEVO_P950] = { 2522 .type = HDA_FIXUP_FUNC, 2523 .v.func = alc1220_fixup_clevo_p950, 2524 }, 2525 [ALC1220_FIXUP_CLEVO_PB51ED] = { 2526 .type = HDA_FIXUP_FUNC, 2527 .v.func = alc1220_fixup_clevo_pb51ed, 2528 }, 2529 [ALC1220_FIXUP_CLEVO_PB51ED_PINS] = { 2530 .type = HDA_FIXUP_PINS, 2531 .v.pins = (const struct hda_pintbl[]) { 2532 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 2533 {} 2534 }, 2535 .chained = true, 2536 .chain_id = ALC1220_FIXUP_CLEVO_PB51ED, 2537 }, 2538 [ALC887_FIXUP_ASUS_AUDIO] = { 2539 .type = HDA_FIXUP_PINS, 2540 .v.pins = (const struct hda_pintbl[]) { 2541 { 0x15, 0x02a14150 }, /* use as headset mic, without its own jack detect */ 2542 { 0x19, 0x22219420 }, 2543 {} 2544 }, 2545 }, 2546 [ALC887_FIXUP_ASUS_HMIC] = { 2547 .type = HDA_FIXUP_FUNC, 2548 .v.func = alc887_fixup_asus_jack, 2549 .chained = true, 2550 .chain_id = ALC887_FIXUP_ASUS_AUDIO, 2551 }, 2552 [ALCS1200A_FIXUP_MIC_VREF] = { 2553 .type = HDA_FIXUP_PINCTLS, 2554 .v.pins = (const struct hda_pintbl[]) { 2555 { 0x18, PIN_VREF50 }, /* rear mic */ 2556 { 0x19, PIN_VREF50 }, /* front mic */ 2557 {} 2558 } 2559 }, 2560 [ALC888VD_FIXUP_MIC_100VREF] = { 2561 .type = HDA_FIXUP_PINCTLS, 2562 .v.pins = (const struct hda_pintbl[]) { 2563 { 0x18, PIN_VREF100 }, /* headset mic */ 2564 {} 2565 } 2566 }, 2567 }; 2568 2569 static const struct snd_pci_quirk alc882_fixup_tbl[] = { 2570 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD), 2571 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD), 2572 SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD), 2573 SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD), 2574 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD), 2575 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD), 2576 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD), 2577 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G", 2578 ALC882_FIXUP_ACER_ASPIRE_4930G), 2579 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G", 2580 ALC882_FIXUP_ACER_ASPIRE_4930G), 2581 SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G", 2582 ALC882_FIXUP_ACER_ASPIRE_8930G), 2583 SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G", 2584 ALC882_FIXUP_ACER_ASPIRE_8930G), 2585 SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G", 2586 ALC882_FIXUP_ACER_ASPIRE_4930G), 2587 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210), 2588 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G", 2589 ALC882_FIXUP_ACER_ASPIRE_4930G), 2590 SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G", 2591 ALC882_FIXUP_ACER_ASPIRE_4930G), 2592 SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G", 2593 ALC882_FIXUP_ACER_ASPIRE_4930G), 2594 SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE), 2595 SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G), 2596 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736), 2597 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD), 2598 SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V), 2599 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC), 2600 SND_PCI_QUIRK(0x1043, 0x2390, "Asus D700SA", ALC887_FIXUP_ASUS_HMIC), 2601 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601), 2602 SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS), 2603 SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3), 2604 SND_PCI_QUIRK(0x1043, 0x8797, "ASUS TUF B550M-PLUS", ALCS1200A_FIXUP_MIC_VREF), 2605 SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP), 2606 SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP), 2607 SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT), 2608 SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP), 2609 SND_PCI_QUIRK(0x104d, 0x9060, "Sony Vaio VPCL14M1R", ALC882_FIXUP_NO_PRIMARY_HP), 2610 2611 /* All Apple entries are in codec SSIDs */ 2612 SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF), 2613 SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF), 2614 SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF), 2615 SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF), 2616 SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO), 2617 SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO), 2618 SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF), 2619 SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF), 2620 SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD), 2621 SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF), 2622 SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF), 2623 SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF), 2624 SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF), 2625 SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO), 2626 SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF), 2627 SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF), 2628 SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF), 2629 SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF), 2630 SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF), 2631 SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF), 2632 SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF), 2633 SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF), 2634 2635 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD), 2636 SND_PCI_QUIRK(0x10ec, 0x12d8, "iBase Elo Touch", ALC888VD_FIXUP_MIC_100VREF), 2637 SND_PCI_QUIRK(0x13fe, 0x1009, "Advantech MIT-W101", ALC886_FIXUP_EAPD), 2638 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE), 2639 SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS), 2640 SND_PCI_QUIRK(0x1458, 0xa0cd, "Gigabyte X570 Aorus Master", ALC1220_FIXUP_GB_X570), 2641 SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_GB_X570), 2642 SND_PCI_QUIRK(0x1458, 0xa0d5, "Gigabyte X570S Aorus Master", ALC1220_FIXUP_GB_X570), 2643 SND_PCI_QUIRK(0x1462, 0x11f7, "MSI-GE63", ALC1220_FIXUP_CLEVO_P950), 2644 SND_PCI_QUIRK(0x1462, 0x1228, "MSI-GP63", ALC1220_FIXUP_CLEVO_P950), 2645 SND_PCI_QUIRK(0x1462, 0x1229, "MSI-GP73", ALC1220_FIXUP_CLEVO_P950), 2646 SND_PCI_QUIRK(0x1462, 0x1275, "MSI-GL63", ALC1220_FIXUP_CLEVO_P950), 2647 SND_PCI_QUIRK(0x1462, 0x1276, "MSI-GL73", ALC1220_FIXUP_CLEVO_P950), 2648 SND_PCI_QUIRK(0x1462, 0x1293, "MSI-GP65", ALC1220_FIXUP_CLEVO_P950), 2649 SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD), 2650 SND_PCI_QUIRK(0x1462, 0xcc34, "MSI Godlike X570", ALC1220_FIXUP_GB_DUAL_CODECS), 2651 SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS), 2652 SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3), 2653 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX), 2654 SND_PCI_QUIRK(0x1558, 0x3702, "Clevo X370SN[VW]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2655 SND_PCI_QUIRK(0x1558, 0x50d3, "Clevo PC50[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2656 SND_PCI_QUIRK(0x1558, 0x65d1, "Clevo PB51[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2657 SND_PCI_QUIRK(0x1558, 0x65d2, "Clevo PB51R[CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2658 SND_PCI_QUIRK(0x1558, 0x65e1, "Clevo PB51[ED][DF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2659 SND_PCI_QUIRK(0x1558, 0x65e5, "Clevo PC50D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2660 SND_PCI_QUIRK(0x1558, 0x65f1, "Clevo PC50HS", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2661 SND_PCI_QUIRK(0x1558, 0x65f5, "Clevo PD50PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2662 SND_PCI_QUIRK(0x1558, 0x66a2, "Clevo PE60RNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2663 SND_PCI_QUIRK(0x1558, 0x66a6, "Clevo PE60SN[CDE]-[GS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2664 SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2665 SND_PCI_QUIRK(0x1558, 0x67e1, "Clevo PB71[DE][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2666 SND_PCI_QUIRK(0x1558, 0x67e5, "Clevo PC70D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2667 SND_PCI_QUIRK(0x1558, 0x67f1, "Clevo PC70H[PRS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2668 SND_PCI_QUIRK(0x1558, 0x67f5, "Clevo PD70PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2669 SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2670 SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170SM", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2671 SND_PCI_QUIRK(0x1558, 0x7715, "Clevo X170KM-G", ALC1220_FIXUP_CLEVO_PB51ED), 2672 SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950), 2673 SND_PCI_QUIRK(0x1558, 0x9506, "Clevo P955HQ", ALC1220_FIXUP_CLEVO_P950), 2674 SND_PCI_QUIRK(0x1558, 0x950a, "Clevo P955H[PR]", ALC1220_FIXUP_CLEVO_P950), 2675 SND_PCI_QUIRK(0x1558, 0x95e1, "Clevo P95xER", ALC1220_FIXUP_CLEVO_P950), 2676 SND_PCI_QUIRK(0x1558, 0x95e2, "Clevo P950ER", ALC1220_FIXUP_CLEVO_P950), 2677 SND_PCI_QUIRK(0x1558, 0x95e3, "Clevo P955[ER]T", ALC1220_FIXUP_CLEVO_P950), 2678 SND_PCI_QUIRK(0x1558, 0x95e4, "Clevo P955ER", ALC1220_FIXUP_CLEVO_P950), 2679 SND_PCI_QUIRK(0x1558, 0x95e5, "Clevo P955EE6", ALC1220_FIXUP_CLEVO_P950), 2680 SND_PCI_QUIRK(0x1558, 0x95e6, "Clevo P950R[CDF]", ALC1220_FIXUP_CLEVO_P950), 2681 SND_PCI_QUIRK(0x1558, 0x96e1, "Clevo P960[ER][CDFN]-K", ALC1220_FIXUP_CLEVO_P950), 2682 SND_PCI_QUIRK(0x1558, 0x97e1, "Clevo P970[ER][CDFN]", ALC1220_FIXUP_CLEVO_P950), 2683 SND_PCI_QUIRK(0x1558, 0x97e2, "Clevo P970RC-M", ALC1220_FIXUP_CLEVO_P950), 2684 SND_PCI_QUIRK(0x1558, 0xd502, "Clevo PD50SNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2685 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD), 2686 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD), 2687 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530), 2688 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF), 2689 {} 2690 }; 2691 2692 static const struct hda_model_fixup alc882_fixup_models[] = { 2693 {.id = ALC882_FIXUP_ABIT_AW9D_MAX, .name = "abit-aw9d"}, 2694 {.id = ALC882_FIXUP_LENOVO_Y530, .name = "lenovo-y530"}, 2695 {.id = ALC882_FIXUP_ACER_ASPIRE_7736, .name = "acer-aspire-7736"}, 2696 {.id = ALC882_FIXUP_ASUS_W90V, .name = "asus-w90v"}, 2697 {.id = ALC889_FIXUP_CD, .name = "cd"}, 2698 {.id = ALC889_FIXUP_FRONT_HP_NO_PRESENCE, .name = "no-front-hp"}, 2699 {.id = ALC889_FIXUP_VAIO_TT, .name = "vaio-tt"}, 2700 {.id = ALC888_FIXUP_EEE1601, .name = "eee1601"}, 2701 {.id = ALC882_FIXUP_EAPD, .name = "alc882-eapd"}, 2702 {.id = ALC883_FIXUP_EAPD, .name = "alc883-eapd"}, 2703 {.id = ALC882_FIXUP_GPIO1, .name = "gpio1"}, 2704 {.id = ALC882_FIXUP_GPIO2, .name = "gpio2"}, 2705 {.id = ALC882_FIXUP_GPIO3, .name = "gpio3"}, 2706 {.id = ALC889_FIXUP_COEF, .name = "alc889-coef"}, 2707 {.id = ALC882_FIXUP_ASUS_W2JC, .name = "asus-w2jc"}, 2708 {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"}, 2709 {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"}, 2710 {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"}, 2711 {.id = ALC885_FIXUP_MACPRO_GPIO, .name = "macpro-gpio"}, 2712 {.id = ALC889_FIXUP_DAC_ROUTE, .name = "dac-route"}, 2713 {.id = ALC889_FIXUP_MBP_VREF, .name = "mbp-vref"}, 2714 {.id = ALC889_FIXUP_IMAC91_VREF, .name = "imac91-vref"}, 2715 {.id = ALC889_FIXUP_MBA11_VREF, .name = "mba11-vref"}, 2716 {.id = ALC889_FIXUP_MBA21_VREF, .name = "mba21-vref"}, 2717 {.id = ALC889_FIXUP_MP11_VREF, .name = "mp11-vref"}, 2718 {.id = ALC889_FIXUP_MP41_VREF, .name = "mp41-vref"}, 2719 {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"}, 2720 {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"}, 2721 {.id = ALC887_FIXUP_ASUS_BASS, .name = "asus-bass"}, 2722 {.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"}, 2723 {.id = ALC1220_FIXUP_GB_X570, .name = "gb-x570"}, 2724 {.id = ALC1220_FIXUP_CLEVO_P950, .name = "clevo-p950"}, 2725 {} 2726 }; 2727 2728 static const struct snd_hda_pin_quirk alc882_pin_fixup_tbl[] = { 2729 SND_HDA_PIN_QUIRK(0x10ec1220, 0x1043, "ASUS", ALC1220_FIXUP_CLEVO_P950, 2730 {0x14, 0x01014010}, 2731 {0x15, 0x01011012}, 2732 {0x16, 0x01016011}, 2733 {0x18, 0x01a19040}, 2734 {0x19, 0x02a19050}, 2735 {0x1a, 0x0181304f}, 2736 {0x1b, 0x0221401f}, 2737 {0x1e, 0x01456130}), 2738 SND_HDA_PIN_QUIRK(0x10ec1220, 0x1462, "MS-7C35", ALC1220_FIXUP_CLEVO_P950, 2739 {0x14, 0x01015010}, 2740 {0x15, 0x01011012}, 2741 {0x16, 0x01011011}, 2742 {0x18, 0x01a11040}, 2743 {0x19, 0x02a19050}, 2744 {0x1a, 0x0181104f}, 2745 {0x1b, 0x0221401f}, 2746 {0x1e, 0x01451130}), 2747 {} 2748 }; 2749 2750 /* 2751 * BIOS auto configuration 2752 */ 2753 /* almost identical with ALC880 parser... */ 2754 static int alc882_parse_auto_config(struct hda_codec *codec) 2755 { 2756 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 }; 2757 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 2758 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids); 2759 } 2760 2761 /* 2762 */ 2763 static int patch_alc882(struct hda_codec *codec) 2764 { 2765 struct alc_spec *spec; 2766 int err; 2767 2768 err = alc_alloc_spec(codec, 0x0b); 2769 if (err < 0) 2770 return err; 2771 2772 spec = codec->spec; 2773 2774 switch (codec->core.vendor_id) { 2775 case 0x10ec0882: 2776 case 0x10ec0885: 2777 case 0x10ec0900: 2778 case 0x10ec0b00: 2779 case 0x10ec1220: 2780 break; 2781 default: 2782 /* ALC883 and variants */ 2783 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 2784 break; 2785 } 2786 2787 alc_pre_init(codec); 2788 2789 snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl, 2790 alc882_fixups); 2791 snd_hda_pick_pin_fixup(codec, alc882_pin_fixup_tbl, alc882_fixups, true); 2792 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 2793 2794 alc_auto_parse_customize_define(codec); 2795 2796 if (has_cdefine_beep(codec)) 2797 spec->gen.beep_nid = 0x01; 2798 2799 /* automatic parse from the BIOS config */ 2800 err = alc882_parse_auto_config(codec); 2801 if (err < 0) 2802 goto error; 2803 2804 if (!spec->gen.no_analog && spec->gen.beep_nid) { 2805 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 2806 if (err < 0) 2807 goto error; 2808 } 2809 2810 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 2811 2812 return 0; 2813 2814 error: 2815 alc_free(codec); 2816 return err; 2817 } 2818 2819 2820 /* 2821 * ALC262 support 2822 */ 2823 static int alc262_parse_auto_config(struct hda_codec *codec) 2824 { 2825 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 }; 2826 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 2827 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids); 2828 } 2829 2830 /* 2831 * Pin config fixes 2832 */ 2833 enum { 2834 ALC262_FIXUP_FSC_H270, 2835 ALC262_FIXUP_FSC_S7110, 2836 ALC262_FIXUP_HP_Z200, 2837 ALC262_FIXUP_TYAN, 2838 ALC262_FIXUP_LENOVO_3000, 2839 ALC262_FIXUP_BENQ, 2840 ALC262_FIXUP_BENQ_T31, 2841 ALC262_FIXUP_INV_DMIC, 2842 ALC262_FIXUP_INTEL_BAYLEYBAY, 2843 }; 2844 2845 static const struct hda_fixup alc262_fixups[] = { 2846 [ALC262_FIXUP_FSC_H270] = { 2847 .type = HDA_FIXUP_PINS, 2848 .v.pins = (const struct hda_pintbl[]) { 2849 { 0x14, 0x99130110 }, /* speaker */ 2850 { 0x15, 0x0221142f }, /* front HP */ 2851 { 0x1b, 0x0121141f }, /* rear HP */ 2852 { } 2853 } 2854 }, 2855 [ALC262_FIXUP_FSC_S7110] = { 2856 .type = HDA_FIXUP_PINS, 2857 .v.pins = (const struct hda_pintbl[]) { 2858 { 0x15, 0x90170110 }, /* speaker */ 2859 { } 2860 }, 2861 .chained = true, 2862 .chain_id = ALC262_FIXUP_BENQ, 2863 }, 2864 [ALC262_FIXUP_HP_Z200] = { 2865 .type = HDA_FIXUP_PINS, 2866 .v.pins = (const struct hda_pintbl[]) { 2867 { 0x16, 0x99130120 }, /* internal speaker */ 2868 { } 2869 } 2870 }, 2871 [ALC262_FIXUP_TYAN] = { 2872 .type = HDA_FIXUP_PINS, 2873 .v.pins = (const struct hda_pintbl[]) { 2874 { 0x14, 0x1993e1f0 }, /* int AUX */ 2875 { } 2876 } 2877 }, 2878 [ALC262_FIXUP_LENOVO_3000] = { 2879 .type = HDA_FIXUP_PINCTLS, 2880 .v.pins = (const struct hda_pintbl[]) { 2881 { 0x19, PIN_VREF50 }, 2882 {} 2883 }, 2884 .chained = true, 2885 .chain_id = ALC262_FIXUP_BENQ, 2886 }, 2887 [ALC262_FIXUP_BENQ] = { 2888 .type = HDA_FIXUP_VERBS, 2889 .v.verbs = (const struct hda_verb[]) { 2890 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2891 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 }, 2892 {} 2893 } 2894 }, 2895 [ALC262_FIXUP_BENQ_T31] = { 2896 .type = HDA_FIXUP_VERBS, 2897 .v.verbs = (const struct hda_verb[]) { 2898 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2899 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 }, 2900 {} 2901 } 2902 }, 2903 [ALC262_FIXUP_INV_DMIC] = { 2904 .type = HDA_FIXUP_FUNC, 2905 .v.func = alc_fixup_inv_dmic, 2906 }, 2907 [ALC262_FIXUP_INTEL_BAYLEYBAY] = { 2908 .type = HDA_FIXUP_FUNC, 2909 .v.func = alc_fixup_no_depop_delay, 2910 }, 2911 }; 2912 2913 static const struct snd_pci_quirk alc262_fixup_tbl[] = { 2914 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200), 2915 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110), 2916 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ), 2917 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN), 2918 SND_PCI_QUIRK(0x1734, 0x1141, "FSC ESPRIMO U9210", ALC262_FIXUP_FSC_H270), 2919 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270), 2920 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000), 2921 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ), 2922 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31), 2923 SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY), 2924 {} 2925 }; 2926 2927 static const struct hda_model_fixup alc262_fixup_models[] = { 2928 {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"}, 2929 {.id = ALC262_FIXUP_FSC_H270, .name = "fsc-h270"}, 2930 {.id = ALC262_FIXUP_FSC_S7110, .name = "fsc-s7110"}, 2931 {.id = ALC262_FIXUP_HP_Z200, .name = "hp-z200"}, 2932 {.id = ALC262_FIXUP_TYAN, .name = "tyan"}, 2933 {.id = ALC262_FIXUP_LENOVO_3000, .name = "lenovo-3000"}, 2934 {.id = ALC262_FIXUP_BENQ, .name = "benq"}, 2935 {.id = ALC262_FIXUP_BENQ_T31, .name = "benq-t31"}, 2936 {.id = ALC262_FIXUP_INTEL_BAYLEYBAY, .name = "bayleybay"}, 2937 {} 2938 }; 2939 2940 /* 2941 */ 2942 static int patch_alc262(struct hda_codec *codec) 2943 { 2944 struct alc_spec *spec; 2945 int err; 2946 2947 err = alc_alloc_spec(codec, 0x0b); 2948 if (err < 0) 2949 return err; 2950 2951 spec = codec->spec; 2952 spec->gen.shared_mic_vref_pin = 0x18; 2953 2954 spec->shutup = alc_eapd_shutup; 2955 2956 #if 0 2957 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is 2958 * under-run 2959 */ 2960 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80); 2961 #endif 2962 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 2963 2964 alc_pre_init(codec); 2965 2966 snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl, 2967 alc262_fixups); 2968 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 2969 2970 alc_auto_parse_customize_define(codec); 2971 2972 if (has_cdefine_beep(codec)) 2973 spec->gen.beep_nid = 0x01; 2974 2975 /* automatic parse from the BIOS config */ 2976 err = alc262_parse_auto_config(codec); 2977 if (err < 0) 2978 goto error; 2979 2980 if (!spec->gen.no_analog && spec->gen.beep_nid) { 2981 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 2982 if (err < 0) 2983 goto error; 2984 } 2985 2986 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 2987 2988 return 0; 2989 2990 error: 2991 alc_free(codec); 2992 return err; 2993 } 2994 2995 /* 2996 * ALC268 2997 */ 2998 /* bind Beep switches of both NID 0x0f and 0x10 */ 2999 static int alc268_beep_switch_put(struct snd_kcontrol *kcontrol, 3000 struct snd_ctl_elem_value *ucontrol) 3001 { 3002 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3003 unsigned long pval; 3004 int err; 3005 3006 mutex_lock(&codec->control_mutex); 3007 pval = kcontrol->private_value; 3008 kcontrol->private_value = (pval & ~0xff) | 0x0f; 3009 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); 3010 if (err >= 0) { 3011 kcontrol->private_value = (pval & ~0xff) | 0x10; 3012 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); 3013 } 3014 kcontrol->private_value = pval; 3015 mutex_unlock(&codec->control_mutex); 3016 return err; 3017 } 3018 3019 static const struct snd_kcontrol_new alc268_beep_mixer[] = { 3020 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT), 3021 { 3022 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3023 .name = "Beep Playback Switch", 3024 .subdevice = HDA_SUBDEV_AMP_FLAG, 3025 .info = snd_hda_mixer_amp_switch_info, 3026 .get = snd_hda_mixer_amp_switch_get, 3027 .put = alc268_beep_switch_put, 3028 .private_value = HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT) 3029 }, 3030 }; 3031 3032 /* set PCBEEP vol = 0, mute connections */ 3033 static const struct hda_verb alc268_beep_init_verbs[] = { 3034 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3035 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 3036 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 3037 { } 3038 }; 3039 3040 enum { 3041 ALC268_FIXUP_INV_DMIC, 3042 ALC268_FIXUP_HP_EAPD, 3043 ALC268_FIXUP_SPDIF, 3044 }; 3045 3046 static const struct hda_fixup alc268_fixups[] = { 3047 [ALC268_FIXUP_INV_DMIC] = { 3048 .type = HDA_FIXUP_FUNC, 3049 .v.func = alc_fixup_inv_dmic, 3050 }, 3051 [ALC268_FIXUP_HP_EAPD] = { 3052 .type = HDA_FIXUP_VERBS, 3053 .v.verbs = (const struct hda_verb[]) { 3054 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0}, 3055 {} 3056 } 3057 }, 3058 [ALC268_FIXUP_SPDIF] = { 3059 .type = HDA_FIXUP_PINS, 3060 .v.pins = (const struct hda_pintbl[]) { 3061 { 0x1e, 0x014b1180 }, /* enable SPDIF out */ 3062 {} 3063 } 3064 }, 3065 }; 3066 3067 static const struct hda_model_fixup alc268_fixup_models[] = { 3068 {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"}, 3069 {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"}, 3070 {.id = ALC268_FIXUP_SPDIF, .name = "spdif"}, 3071 {} 3072 }; 3073 3074 static const struct snd_pci_quirk alc268_fixup_tbl[] = { 3075 SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF), 3076 SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC), 3077 /* below is codec SSID since multiple Toshiba laptops have the 3078 * same PCI SSID 1179:ff00 3079 */ 3080 SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD), 3081 {} 3082 }; 3083 3084 /* 3085 * BIOS auto configuration 3086 */ 3087 static int alc268_parse_auto_config(struct hda_codec *codec) 3088 { 3089 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 3090 return alc_parse_auto_config(codec, NULL, alc268_ssids); 3091 } 3092 3093 /* 3094 */ 3095 static int patch_alc268(struct hda_codec *codec) 3096 { 3097 struct alc_spec *spec; 3098 int i, err; 3099 3100 /* ALC268 has no aa-loopback mixer */ 3101 err = alc_alloc_spec(codec, 0); 3102 if (err < 0) 3103 return err; 3104 3105 spec = codec->spec; 3106 if (has_cdefine_beep(codec)) 3107 spec->gen.beep_nid = 0x01; 3108 3109 spec->shutup = alc_eapd_shutup; 3110 3111 alc_pre_init(codec); 3112 3113 snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups); 3114 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 3115 3116 /* automatic parse from the BIOS config */ 3117 err = alc268_parse_auto_config(codec); 3118 if (err < 0) 3119 goto error; 3120 3121 if (err > 0 && !spec->gen.no_analog && 3122 spec->gen.autocfg.speaker_pins[0] != 0x1d) { 3123 for (i = 0; i < ARRAY_SIZE(alc268_beep_mixer); i++) { 3124 if (!snd_hda_gen_add_kctl(&spec->gen, NULL, 3125 &alc268_beep_mixer[i])) { 3126 err = -ENOMEM; 3127 goto error; 3128 } 3129 } 3130 snd_hda_add_verbs(codec, alc268_beep_init_verbs); 3131 if (!query_amp_caps(codec, 0x1d, HDA_INPUT)) 3132 /* override the amp caps for beep generator */ 3133 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT, 3134 (0x0c << AC_AMPCAP_OFFSET_SHIFT) | 3135 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) | 3136 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) | 3137 (0 << AC_AMPCAP_MUTE_SHIFT)); 3138 } 3139 3140 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 3141 3142 return 0; 3143 3144 error: 3145 alc_free(codec); 3146 return err; 3147 } 3148 3149 /* 3150 * ALC269 3151 */ 3152 3153 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = { 3154 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */ 3155 }; 3156 3157 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = { 3158 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */ 3159 }; 3160 3161 /* different alc269-variants */ 3162 enum { 3163 ALC269_TYPE_ALC269VA, 3164 ALC269_TYPE_ALC269VB, 3165 ALC269_TYPE_ALC269VC, 3166 ALC269_TYPE_ALC269VD, 3167 ALC269_TYPE_ALC280, 3168 ALC269_TYPE_ALC282, 3169 ALC269_TYPE_ALC283, 3170 ALC269_TYPE_ALC284, 3171 ALC269_TYPE_ALC293, 3172 ALC269_TYPE_ALC286, 3173 ALC269_TYPE_ALC298, 3174 ALC269_TYPE_ALC255, 3175 ALC269_TYPE_ALC256, 3176 ALC269_TYPE_ALC257, 3177 ALC269_TYPE_ALC215, 3178 ALC269_TYPE_ALC225, 3179 ALC269_TYPE_ALC245, 3180 ALC269_TYPE_ALC287, 3181 ALC269_TYPE_ALC294, 3182 ALC269_TYPE_ALC300, 3183 ALC269_TYPE_ALC623, 3184 ALC269_TYPE_ALC700, 3185 }; 3186 3187 /* 3188 * BIOS auto configuration 3189 */ 3190 static int alc269_parse_auto_config(struct hda_codec *codec) 3191 { 3192 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 }; 3193 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 }; 3194 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 3195 struct alc_spec *spec = codec->spec; 3196 const hda_nid_t *ssids; 3197 3198 switch (spec->codec_variant) { 3199 case ALC269_TYPE_ALC269VA: 3200 case ALC269_TYPE_ALC269VC: 3201 case ALC269_TYPE_ALC280: 3202 case ALC269_TYPE_ALC284: 3203 case ALC269_TYPE_ALC293: 3204 ssids = alc269va_ssids; 3205 break; 3206 case ALC269_TYPE_ALC269VB: 3207 case ALC269_TYPE_ALC269VD: 3208 case ALC269_TYPE_ALC282: 3209 case ALC269_TYPE_ALC283: 3210 case ALC269_TYPE_ALC286: 3211 case ALC269_TYPE_ALC298: 3212 case ALC269_TYPE_ALC255: 3213 case ALC269_TYPE_ALC256: 3214 case ALC269_TYPE_ALC257: 3215 case ALC269_TYPE_ALC215: 3216 case ALC269_TYPE_ALC225: 3217 case ALC269_TYPE_ALC245: 3218 case ALC269_TYPE_ALC287: 3219 case ALC269_TYPE_ALC294: 3220 case ALC269_TYPE_ALC300: 3221 case ALC269_TYPE_ALC623: 3222 case ALC269_TYPE_ALC700: 3223 ssids = alc269_ssids; 3224 break; 3225 default: 3226 ssids = alc269_ssids; 3227 break; 3228 } 3229 3230 return alc_parse_auto_config(codec, alc269_ignore, ssids); 3231 } 3232 3233 static const struct hda_jack_keymap alc_headset_btn_keymap[] = { 3234 { SND_JACK_BTN_0, KEY_PLAYPAUSE }, 3235 { SND_JACK_BTN_1, KEY_VOICECOMMAND }, 3236 { SND_JACK_BTN_2, KEY_VOLUMEUP }, 3237 { SND_JACK_BTN_3, KEY_VOLUMEDOWN }, 3238 {} 3239 }; 3240 3241 static void alc_headset_btn_callback(struct hda_codec *codec, 3242 struct hda_jack_callback *jack) 3243 { 3244 int report = 0; 3245 3246 if (jack->unsol_res & (7 << 13)) 3247 report |= SND_JACK_BTN_0; 3248 3249 if (jack->unsol_res & (1 << 16 | 3 << 8)) 3250 report |= SND_JACK_BTN_1; 3251 3252 /* Volume up key */ 3253 if (jack->unsol_res & (7 << 23)) 3254 report |= SND_JACK_BTN_2; 3255 3256 /* Volume down key */ 3257 if (jack->unsol_res & (7 << 10)) 3258 report |= SND_JACK_BTN_3; 3259 3260 snd_hda_jack_set_button_state(codec, jack->nid, report); 3261 } 3262 3263 static void alc_disable_headset_jack_key(struct hda_codec *codec) 3264 { 3265 struct alc_spec *spec = codec->spec; 3266 3267 if (!spec->has_hs_key) 3268 return; 3269 3270 switch (codec->core.vendor_id) { 3271 case 0x10ec0215: 3272 case 0x10ec0225: 3273 case 0x10ec0285: 3274 case 0x10ec0287: 3275 case 0x10ec0295: 3276 case 0x10ec0289: 3277 case 0x10ec0299: 3278 alc_write_coef_idx(codec, 0x48, 0x0); 3279 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0); 3280 alc_update_coef_idx(codec, 0x44, 0x0045 << 8, 0x0); 3281 break; 3282 case 0x10ec0230: 3283 case 0x10ec0236: 3284 case 0x10ec0256: 3285 case 0x10ec0257: 3286 case 0x19e58326: 3287 alc_write_coef_idx(codec, 0x48, 0x0); 3288 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0); 3289 break; 3290 } 3291 } 3292 3293 static void alc_enable_headset_jack_key(struct hda_codec *codec) 3294 { 3295 struct alc_spec *spec = codec->spec; 3296 3297 if (!spec->has_hs_key) 3298 return; 3299 3300 switch (codec->core.vendor_id) { 3301 case 0x10ec0215: 3302 case 0x10ec0225: 3303 case 0x10ec0285: 3304 case 0x10ec0287: 3305 case 0x10ec0295: 3306 case 0x10ec0289: 3307 case 0x10ec0299: 3308 alc_write_coef_idx(codec, 0x48, 0xd011); 3309 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045); 3310 alc_update_coef_idx(codec, 0x44, 0x007f << 8, 0x0045 << 8); 3311 break; 3312 case 0x10ec0230: 3313 case 0x10ec0236: 3314 case 0x10ec0256: 3315 case 0x10ec0257: 3316 case 0x19e58326: 3317 alc_write_coef_idx(codec, 0x48, 0xd011); 3318 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045); 3319 break; 3320 } 3321 } 3322 3323 static void alc_fixup_headset_jack(struct hda_codec *codec, 3324 const struct hda_fixup *fix, int action) 3325 { 3326 struct alc_spec *spec = codec->spec; 3327 hda_nid_t hp_pin; 3328 3329 switch (action) { 3330 case HDA_FIXUP_ACT_PRE_PROBE: 3331 spec->has_hs_key = 1; 3332 snd_hda_jack_detect_enable_callback(codec, 0x55, 3333 alc_headset_btn_callback); 3334 break; 3335 case HDA_FIXUP_ACT_BUILD: 3336 hp_pin = alc_get_hp_pin(spec); 3337 if (!hp_pin || snd_hda_jack_bind_keymap(codec, 0x55, 3338 alc_headset_btn_keymap, 3339 hp_pin)) 3340 snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack", 3341 false, SND_JACK_HEADSET, 3342 alc_headset_btn_keymap); 3343 3344 alc_enable_headset_jack_key(codec); 3345 break; 3346 } 3347 } 3348 3349 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up) 3350 { 3351 alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0); 3352 } 3353 3354 static void alc269_shutup(struct hda_codec *codec) 3355 { 3356 struct alc_spec *spec = codec->spec; 3357 3358 if (spec->codec_variant == ALC269_TYPE_ALC269VB) 3359 alc269vb_toggle_power_output(codec, 0); 3360 if (spec->codec_variant == ALC269_TYPE_ALC269VB && 3361 (alc_get_coef0(codec) & 0x00ff) == 0x018) { 3362 msleep(150); 3363 } 3364 alc_shutup_pins(codec); 3365 } 3366 3367 static const struct coef_fw alc282_coefs[] = { 3368 WRITE_COEF(0x03, 0x0002), /* Power Down Control */ 3369 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */ 3370 WRITE_COEF(0x07, 0x0200), /* DMIC control */ 3371 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */ 3372 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */ 3373 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */ 3374 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */ 3375 WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */ 3376 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */ 3377 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */ 3378 WRITE_COEF(0x6f, 0x0), /* Class D test 4 */ 3379 UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */ 3380 WRITE_COEF(0x34, 0xa0c0), /* ANC */ 3381 UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */ 3382 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */ 3383 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */ 3384 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */ 3385 WRITE_COEF(0x63, 0x2902), /* PLL */ 3386 WRITE_COEF(0x68, 0xa080), /* capless control 2 */ 3387 WRITE_COEF(0x69, 0x3400), /* capless control 3 */ 3388 WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */ 3389 WRITE_COEF(0x6b, 0x0), /* capless control 5 */ 3390 UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */ 3391 WRITE_COEF(0x6e, 0x110a), /* class D test 3 */ 3392 UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */ 3393 WRITE_COEF(0x71, 0x0014), /* class D test 6 */ 3394 WRITE_COEF(0x72, 0xc2ba), /* classD OCP */ 3395 UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */ 3396 WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */ 3397 {} 3398 }; 3399 3400 static void alc282_restore_default_value(struct hda_codec *codec) 3401 { 3402 alc_process_coef_fw(codec, alc282_coefs); 3403 } 3404 3405 static void alc282_init(struct hda_codec *codec) 3406 { 3407 struct alc_spec *spec = codec->spec; 3408 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3409 bool hp_pin_sense; 3410 int coef78; 3411 3412 alc282_restore_default_value(codec); 3413 3414 if (!hp_pin) 3415 return; 3416 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3417 coef78 = alc_read_coef_idx(codec, 0x78); 3418 3419 /* Index 0x78 Direct Drive HP AMP LPM Control 1 */ 3420 /* Headphone capless set to high power mode */ 3421 alc_write_coef_idx(codec, 0x78, 0x9004); 3422 3423 if (hp_pin_sense) 3424 msleep(2); 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) 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) 3436 msleep(100); 3437 3438 /* Headphone capless set to normal mode */ 3439 alc_write_coef_idx(codec, 0x78, coef78); 3440 } 3441 3442 static void alc282_shutup(struct hda_codec *codec) 3443 { 3444 struct alc_spec *spec = codec->spec; 3445 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3446 bool hp_pin_sense; 3447 int coef78; 3448 3449 if (!hp_pin) { 3450 alc269_shutup(codec); 3451 return; 3452 } 3453 3454 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3455 coef78 = alc_read_coef_idx(codec, 0x78); 3456 alc_write_coef_idx(codec, 0x78, 0x9004); 3457 3458 if (hp_pin_sense) 3459 msleep(2); 3460 3461 snd_hda_codec_write(codec, hp_pin, 0, 3462 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3463 3464 if (hp_pin_sense) 3465 msleep(85); 3466 3467 if (!spec->no_shutup_pins) 3468 snd_hda_codec_write(codec, hp_pin, 0, 3469 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3470 3471 if (hp_pin_sense) 3472 msleep(100); 3473 3474 alc_auto_setup_eapd(codec, false); 3475 alc_shutup_pins(codec); 3476 alc_write_coef_idx(codec, 0x78, coef78); 3477 } 3478 3479 static const struct coef_fw alc283_coefs[] = { 3480 WRITE_COEF(0x03, 0x0002), /* Power Down Control */ 3481 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */ 3482 WRITE_COEF(0x07, 0x0200), /* DMIC control */ 3483 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */ 3484 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */ 3485 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */ 3486 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */ 3487 WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */ 3488 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */ 3489 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */ 3490 WRITE_COEF(0x3a, 0x0), /* Class D test 4 */ 3491 UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */ 3492 WRITE_COEF(0x22, 0xa0c0), /* ANC */ 3493 UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */ 3494 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */ 3495 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */ 3496 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */ 3497 WRITE_COEF(0x2e, 0x2902), /* PLL */ 3498 WRITE_COEF(0x33, 0xa080), /* capless control 2 */ 3499 WRITE_COEF(0x34, 0x3400), /* capless control 3 */ 3500 WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */ 3501 WRITE_COEF(0x36, 0x0), /* capless control 5 */ 3502 UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */ 3503 WRITE_COEF(0x39, 0x110a), /* class D test 3 */ 3504 UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */ 3505 WRITE_COEF(0x3c, 0x0014), /* class D test 6 */ 3506 WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */ 3507 UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */ 3508 WRITE_COEF(0x49, 0x0), /* test mode */ 3509 UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */ 3510 UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */ 3511 WRITE_COEF(0x37, 0xfc06), /* Class D amp control */ 3512 UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */ 3513 {} 3514 }; 3515 3516 static void alc283_restore_default_value(struct hda_codec *codec) 3517 { 3518 alc_process_coef_fw(codec, alc283_coefs); 3519 } 3520 3521 static void alc283_init(struct hda_codec *codec) 3522 { 3523 struct alc_spec *spec = codec->spec; 3524 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3525 bool hp_pin_sense; 3526 3527 alc283_restore_default_value(codec); 3528 3529 if (!hp_pin) 3530 return; 3531 3532 msleep(30); 3533 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3534 3535 /* Index 0x43 Direct Drive HP AMP LPM Control 1 */ 3536 /* Headphone capless set to high power mode */ 3537 alc_write_coef_idx(codec, 0x43, 0x9004); 3538 3539 snd_hda_codec_write(codec, hp_pin, 0, 3540 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3541 3542 if (hp_pin_sense) 3543 msleep(85); 3544 3545 snd_hda_codec_write(codec, hp_pin, 0, 3546 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3547 3548 if (hp_pin_sense) 3549 msleep(85); 3550 /* Index 0x46 Combo jack auto switch control 2 */ 3551 /* 3k pull low control for Headset jack. */ 3552 alc_update_coef_idx(codec, 0x46, 3 << 12, 0); 3553 /* Headphone capless set to normal mode */ 3554 alc_write_coef_idx(codec, 0x43, 0x9614); 3555 } 3556 3557 static void alc283_shutup(struct hda_codec *codec) 3558 { 3559 struct alc_spec *spec = codec->spec; 3560 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3561 bool hp_pin_sense; 3562 3563 if (!hp_pin) { 3564 alc269_shutup(codec); 3565 return; 3566 } 3567 3568 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3569 3570 alc_write_coef_idx(codec, 0x43, 0x9004); 3571 3572 /*depop hp during suspend*/ 3573 alc_write_coef_idx(codec, 0x06, 0x2100); 3574 3575 snd_hda_codec_write(codec, hp_pin, 0, 3576 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3577 3578 if (hp_pin_sense) 3579 msleep(100); 3580 3581 if (!spec->no_shutup_pins) 3582 snd_hda_codec_write(codec, hp_pin, 0, 3583 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3584 3585 alc_update_coef_idx(codec, 0x46, 0, 3 << 12); 3586 3587 if (hp_pin_sense) 3588 msleep(100); 3589 alc_auto_setup_eapd(codec, false); 3590 alc_shutup_pins(codec); 3591 alc_write_coef_idx(codec, 0x43, 0x9614); 3592 } 3593 3594 static void alc256_init(struct hda_codec *codec) 3595 { 3596 struct alc_spec *spec = codec->spec; 3597 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3598 bool hp_pin_sense; 3599 3600 if (spec->ultra_low_power) { 3601 alc_update_coef_idx(codec, 0x03, 1<<1, 1<<1); 3602 alc_update_coef_idx(codec, 0x08, 3<<2, 3<<2); 3603 alc_update_coef_idx(codec, 0x08, 7<<4, 0); 3604 alc_update_coef_idx(codec, 0x3b, 1<<15, 0); 3605 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6); 3606 msleep(30); 3607 } 3608 3609 if (!hp_pin) 3610 hp_pin = 0x21; 3611 3612 msleep(30); 3613 3614 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3615 3616 if (hp_pin_sense) 3617 msleep(2); 3618 3619 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */ 3620 3621 snd_hda_codec_write(codec, hp_pin, 0, 3622 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3623 3624 if (hp_pin_sense || spec->ultra_low_power) 3625 msleep(85); 3626 3627 snd_hda_codec_write(codec, hp_pin, 0, 3628 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3629 3630 if (hp_pin_sense || spec->ultra_low_power) 3631 msleep(100); 3632 3633 alc_update_coef_idx(codec, 0x46, 3 << 12, 0); 3634 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */ 3635 alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15); /* Clear bit */ 3636 alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15); 3637 /* 3638 * Expose headphone mic (or possibly Line In on some machines) instead 3639 * of PC Beep on 1Ah, and disable 1Ah loopback for all outputs. See 3640 * Documentation/sound/hd-audio/realtek-pc-beep.rst for details of 3641 * this register. 3642 */ 3643 alc_write_coef_idx(codec, 0x36, 0x5757); 3644 } 3645 3646 static void alc256_shutup(struct hda_codec *codec) 3647 { 3648 struct alc_spec *spec = codec->spec; 3649 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3650 bool hp_pin_sense; 3651 3652 if (!hp_pin) 3653 hp_pin = 0x21; 3654 3655 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */ 3656 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3657 3658 if (hp_pin_sense) 3659 msleep(2); 3660 3661 snd_hda_codec_write(codec, hp_pin, 0, 3662 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3663 3664 if (hp_pin_sense || spec->ultra_low_power) 3665 msleep(85); 3666 3667 /* 3k pull low control for Headset jack. */ 3668 /* NOTE: call this before clearing the pin, otherwise codec stalls */ 3669 /* If disable 3k pulldown control for alc257, the Mic detection will not work correctly 3670 * when booting with headset plugged. So skip setting it for the codec alc257 3671 */ 3672 if (spec->en_3kpull_low) 3673 alc_update_coef_idx(codec, 0x46, 0, 3 << 12); 3674 3675 if (!spec->no_shutup_pins) 3676 snd_hda_codec_write(codec, hp_pin, 0, 3677 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3678 3679 if (hp_pin_sense || spec->ultra_low_power) 3680 msleep(100); 3681 3682 alc_auto_setup_eapd(codec, false); 3683 alc_shutup_pins(codec); 3684 if (spec->ultra_low_power) { 3685 msleep(50); 3686 alc_update_coef_idx(codec, 0x03, 1<<1, 0); 3687 alc_update_coef_idx(codec, 0x08, 7<<4, 7<<4); 3688 alc_update_coef_idx(codec, 0x08, 3<<2, 0); 3689 alc_update_coef_idx(codec, 0x3b, 1<<15, 1<<15); 3690 alc_update_coef_idx(codec, 0x0e, 7<<6, 0); 3691 msleep(30); 3692 } 3693 } 3694 3695 static void alc285_hp_init(struct hda_codec *codec) 3696 { 3697 struct alc_spec *spec = codec->spec; 3698 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3699 int i, val; 3700 int coef38, coef0d, coef36; 3701 3702 alc_write_coefex_idx(codec, 0x58, 0x00, 0x1888); /* write default value */ 3703 alc_update_coef_idx(codec, 0x4a, 1<<15, 1<<15); /* Reset HP JD */ 3704 coef38 = alc_read_coef_idx(codec, 0x38); /* Amp control */ 3705 coef0d = alc_read_coef_idx(codec, 0x0d); /* Digital Misc control */ 3706 coef36 = alc_read_coef_idx(codec, 0x36); /* Passthrough Control */ 3707 alc_update_coef_idx(codec, 0x38, 1<<4, 0x0); 3708 alc_update_coef_idx(codec, 0x0d, 0x110, 0x0); 3709 3710 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000); 3711 3712 if (hp_pin) 3713 snd_hda_codec_write(codec, hp_pin, 0, 3714 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3715 3716 msleep(130); 3717 alc_update_coef_idx(codec, 0x36, 1<<14, 1<<14); 3718 alc_update_coef_idx(codec, 0x36, 1<<13, 0x0); 3719 3720 if (hp_pin) 3721 snd_hda_codec_write(codec, hp_pin, 0, 3722 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3723 msleep(10); 3724 alc_write_coef_idx(codec, 0x67, 0x0); /* Set HP depop to manual mode */ 3725 alc_write_coefex_idx(codec, 0x58, 0x00, 0x7880); 3726 alc_write_coefex_idx(codec, 0x58, 0x0f, 0xf049); 3727 alc_update_coefex_idx(codec, 0x58, 0x03, 0x00f0, 0x00c0); 3728 3729 alc_write_coefex_idx(codec, 0x58, 0x00, 0xf888); /* HP depop procedure start */ 3730 val = alc_read_coefex_idx(codec, 0x58, 0x00); 3731 for (i = 0; i < 20 && val & 0x8000; i++) { 3732 msleep(50); 3733 val = alc_read_coefex_idx(codec, 0x58, 0x00); 3734 } /* Wait for depop procedure finish */ 3735 3736 alc_write_coefex_idx(codec, 0x58, 0x00, val); /* write back the result */ 3737 alc_update_coef_idx(codec, 0x38, 1<<4, coef38); 3738 alc_update_coef_idx(codec, 0x0d, 0x110, coef0d); 3739 alc_update_coef_idx(codec, 0x36, 3<<13, coef36); 3740 3741 msleep(50); 3742 alc_update_coef_idx(codec, 0x4a, 1<<15, 0); 3743 } 3744 3745 static void alc225_init(struct hda_codec *codec) 3746 { 3747 struct alc_spec *spec = codec->spec; 3748 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3749 bool hp1_pin_sense, hp2_pin_sense; 3750 3751 if (spec->ultra_low_power) { 3752 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 3<<2); 3753 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6); 3754 alc_update_coef_idx(codec, 0x33, 1<<11, 0); 3755 msleep(30); 3756 } 3757 3758 if (spec->codec_variant != ALC269_TYPE_ALC287 && 3759 spec->codec_variant != ALC269_TYPE_ALC245) 3760 /* required only at boot or S3 and S4 resume time */ 3761 if (!spec->done_hp_init || 3762 is_s3_resume(codec) || 3763 is_s4_resume(codec)) { 3764 alc285_hp_init(codec); 3765 spec->done_hp_init = true; 3766 } 3767 3768 if (!hp_pin) 3769 hp_pin = 0x21; 3770 msleep(30); 3771 3772 hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3773 hp2_pin_sense = snd_hda_jack_detect(codec, 0x16); 3774 3775 if (hp1_pin_sense || hp2_pin_sense) 3776 msleep(2); 3777 3778 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */ 3779 3780 if (hp1_pin_sense || spec->ultra_low_power) 3781 snd_hda_codec_write(codec, hp_pin, 0, 3782 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3783 if (hp2_pin_sense) 3784 snd_hda_codec_write(codec, 0x16, 0, 3785 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3786 3787 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power) 3788 msleep(85); 3789 3790 if (hp1_pin_sense || spec->ultra_low_power) 3791 snd_hda_codec_write(codec, hp_pin, 0, 3792 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3793 if (hp2_pin_sense) 3794 snd_hda_codec_write(codec, 0x16, 0, 3795 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3796 3797 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power) 3798 msleep(100); 3799 3800 alc_update_coef_idx(codec, 0x4a, 3 << 10, 0); 3801 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */ 3802 } 3803 3804 static void alc225_shutup(struct hda_codec *codec) 3805 { 3806 struct alc_spec *spec = codec->spec; 3807 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3808 bool hp1_pin_sense, hp2_pin_sense; 3809 3810 if (!hp_pin) 3811 hp_pin = 0x21; 3812 3813 alc_disable_headset_jack_key(codec); 3814 /* 3k pull low control for Headset jack. */ 3815 alc_update_coef_idx(codec, 0x4a, 0, 3 << 10); 3816 3817 hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3818 hp2_pin_sense = snd_hda_jack_detect(codec, 0x16); 3819 3820 if (hp1_pin_sense || hp2_pin_sense) 3821 msleep(2); 3822 3823 if (hp1_pin_sense || spec->ultra_low_power) 3824 snd_hda_codec_write(codec, hp_pin, 0, 3825 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3826 if (hp2_pin_sense) 3827 snd_hda_codec_write(codec, 0x16, 0, 3828 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3829 3830 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power) 3831 msleep(85); 3832 3833 if (hp1_pin_sense || spec->ultra_low_power) 3834 snd_hda_codec_write(codec, hp_pin, 0, 3835 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3836 if (hp2_pin_sense) 3837 snd_hda_codec_write(codec, 0x16, 0, 3838 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3839 3840 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power) 3841 msleep(100); 3842 3843 alc_auto_setup_eapd(codec, false); 3844 alc_shutup_pins(codec); 3845 if (spec->ultra_low_power) { 3846 msleep(50); 3847 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 0x0c << 2); 3848 alc_update_coef_idx(codec, 0x0e, 7<<6, 0); 3849 alc_update_coef_idx(codec, 0x33, 1<<11, 1<<11); 3850 alc_update_coef_idx(codec, 0x4a, 3<<4, 2<<4); 3851 msleep(30); 3852 } 3853 3854 alc_update_coef_idx(codec, 0x4a, 3 << 10, 0); 3855 alc_enable_headset_jack_key(codec); 3856 } 3857 3858 static void alc_default_init(struct hda_codec *codec) 3859 { 3860 struct alc_spec *spec = codec->spec; 3861 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3862 bool hp_pin_sense; 3863 3864 if (!hp_pin) 3865 return; 3866 3867 msleep(30); 3868 3869 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3870 3871 if (hp_pin_sense) 3872 msleep(2); 3873 3874 snd_hda_codec_write(codec, hp_pin, 0, 3875 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3876 3877 if (hp_pin_sense) 3878 msleep(85); 3879 3880 snd_hda_codec_write(codec, hp_pin, 0, 3881 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3882 3883 if (hp_pin_sense) 3884 msleep(100); 3885 } 3886 3887 static void alc_default_shutup(struct hda_codec *codec) 3888 { 3889 struct alc_spec *spec = codec->spec; 3890 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3891 bool hp_pin_sense; 3892 3893 if (!hp_pin) { 3894 alc269_shutup(codec); 3895 return; 3896 } 3897 3898 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3899 3900 if (hp_pin_sense) 3901 msleep(2); 3902 3903 snd_hda_codec_write(codec, hp_pin, 0, 3904 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3905 3906 if (hp_pin_sense) 3907 msleep(85); 3908 3909 if (!spec->no_shutup_pins) 3910 snd_hda_codec_write(codec, hp_pin, 0, 3911 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3912 3913 if (hp_pin_sense) 3914 msleep(100); 3915 3916 alc_auto_setup_eapd(codec, false); 3917 alc_shutup_pins(codec); 3918 } 3919 3920 static void alc294_hp_init(struct hda_codec *codec) 3921 { 3922 struct alc_spec *spec = codec->spec; 3923 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3924 int i, val; 3925 3926 if (!hp_pin) 3927 return; 3928 3929 snd_hda_codec_write(codec, hp_pin, 0, 3930 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3931 3932 msleep(100); 3933 3934 if (!spec->no_shutup_pins) 3935 snd_hda_codec_write(codec, hp_pin, 0, 3936 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3937 3938 alc_update_coef_idx(codec, 0x6f, 0x000f, 0);/* Set HP depop to manual mode */ 3939 alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000); /* HP depop procedure start */ 3940 3941 /* Wait for depop procedure finish */ 3942 val = alc_read_coefex_idx(codec, 0x58, 0x01); 3943 for (i = 0; i < 20 && val & 0x0080; i++) { 3944 msleep(50); 3945 val = alc_read_coefex_idx(codec, 0x58, 0x01); 3946 } 3947 /* Set HP depop to auto mode */ 3948 alc_update_coef_idx(codec, 0x6f, 0x000f, 0x000b); 3949 msleep(50); 3950 } 3951 3952 static void alc294_init(struct hda_codec *codec) 3953 { 3954 struct alc_spec *spec = codec->spec; 3955 3956 /* required only at boot or S4 resume time */ 3957 if (!spec->done_hp_init || 3958 codec->core.dev.power.power_state.event == PM_EVENT_RESTORE) { 3959 alc294_hp_init(codec); 3960 spec->done_hp_init = true; 3961 } 3962 alc_default_init(codec); 3963 } 3964 3965 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg, 3966 unsigned int val) 3967 { 3968 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1); 3969 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */ 3970 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */ 3971 } 3972 3973 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg) 3974 { 3975 unsigned int val; 3976 3977 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1); 3978 val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0) 3979 & 0xffff; 3980 val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0) 3981 << 16; 3982 return val; 3983 } 3984 3985 static void alc5505_dsp_halt(struct hda_codec *codec) 3986 { 3987 unsigned int val; 3988 3989 alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */ 3990 alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */ 3991 alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */ 3992 alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */ 3993 alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */ 3994 alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */ 3995 alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */ 3996 val = alc5505_coef_get(codec, 0x6220); 3997 alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */ 3998 } 3999 4000 static void alc5505_dsp_back_from_halt(struct hda_codec *codec) 4001 { 4002 alc5505_coef_set(codec, 0x61b8, 0x04133302); 4003 alc5505_coef_set(codec, 0x61b0, 0x00005b16); 4004 alc5505_coef_set(codec, 0x61b4, 0x040a2b02); 4005 alc5505_coef_set(codec, 0x6230, 0xf80d4011); 4006 alc5505_coef_set(codec, 0x6220, 0x2002010f); 4007 alc5505_coef_set(codec, 0x880c, 0x00000004); 4008 } 4009 4010 static void alc5505_dsp_init(struct hda_codec *codec) 4011 { 4012 unsigned int val; 4013 4014 alc5505_dsp_halt(codec); 4015 alc5505_dsp_back_from_halt(codec); 4016 alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */ 4017 alc5505_coef_set(codec, 0x61b0, 0x5b16); 4018 alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */ 4019 alc5505_coef_set(codec, 0x61b4, 0x04132b02); 4020 alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/ 4021 alc5505_coef_set(codec, 0x61b8, 0x041f3302); 4022 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */ 4023 alc5505_coef_set(codec, 0x61b8, 0x041b3302); 4024 alc5505_coef_set(codec, 0x61b8, 0x04173302); 4025 alc5505_coef_set(codec, 0x61b8, 0x04163302); 4026 alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */ 4027 alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */ 4028 alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */ 4029 4030 val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */ 4031 if (val <= 3) 4032 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */ 4033 else 4034 alc5505_coef_set(codec, 0x6220, 0x6002018f); 4035 4036 alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/ 4037 alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */ 4038 alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */ 4039 alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */ 4040 alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */ 4041 alc5505_coef_set(codec, 0x880c, 0x00000003); 4042 alc5505_coef_set(codec, 0x880c, 0x00000010); 4043 4044 #ifdef HALT_REALTEK_ALC5505 4045 alc5505_dsp_halt(codec); 4046 #endif 4047 } 4048 4049 #ifdef HALT_REALTEK_ALC5505 4050 #define alc5505_dsp_suspend(codec) do { } while (0) /* NOP */ 4051 #define alc5505_dsp_resume(codec) do { } while (0) /* NOP */ 4052 #else 4053 #define alc5505_dsp_suspend(codec) alc5505_dsp_halt(codec) 4054 #define alc5505_dsp_resume(codec) alc5505_dsp_back_from_halt(codec) 4055 #endif 4056 4057 static int alc269_suspend(struct hda_codec *codec) 4058 { 4059 struct alc_spec *spec = codec->spec; 4060 4061 if (spec->has_alc5505_dsp) 4062 alc5505_dsp_suspend(codec); 4063 4064 return alc_suspend(codec); 4065 } 4066 4067 static int alc269_resume(struct hda_codec *codec) 4068 { 4069 struct alc_spec *spec = codec->spec; 4070 4071 if (spec->codec_variant == ALC269_TYPE_ALC269VB) 4072 alc269vb_toggle_power_output(codec, 0); 4073 if (spec->codec_variant == ALC269_TYPE_ALC269VB && 4074 (alc_get_coef0(codec) & 0x00ff) == 0x018) { 4075 msleep(150); 4076 } 4077 4078 codec->patch_ops.init(codec); 4079 4080 if (spec->codec_variant == ALC269_TYPE_ALC269VB) 4081 alc269vb_toggle_power_output(codec, 1); 4082 if (spec->codec_variant == ALC269_TYPE_ALC269VB && 4083 (alc_get_coef0(codec) & 0x00ff) == 0x017) { 4084 msleep(200); 4085 } 4086 4087 snd_hda_regmap_sync(codec); 4088 hda_call_check_power_status(codec, 0x01); 4089 4090 /* on some machine, the BIOS will clear the codec gpio data when enter 4091 * suspend, and won't restore the data after resume, so we restore it 4092 * in the driver. 4093 */ 4094 if (spec->gpio_data) 4095 alc_write_gpio_data(codec); 4096 4097 if (spec->has_alc5505_dsp) 4098 alc5505_dsp_resume(codec); 4099 4100 return 0; 4101 } 4102 4103 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec, 4104 const struct hda_fixup *fix, int action) 4105 { 4106 struct alc_spec *spec = codec->spec; 4107 4108 if (action == HDA_FIXUP_ACT_PRE_PROBE) 4109 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 4110 } 4111 4112 static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec, 4113 const struct hda_fixup *fix, 4114 int action) 4115 { 4116 unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21); 4117 unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19); 4118 4119 if (cfg_headphone && cfg_headset_mic == 0x411111f0) 4120 snd_hda_codec_set_pincfg(codec, 0x19, 4121 (cfg_headphone & ~AC_DEFCFG_DEVICE) | 4122 (AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT)); 4123 } 4124 4125 static void alc269_fixup_hweq(struct hda_codec *codec, 4126 const struct hda_fixup *fix, int action) 4127 { 4128 if (action == HDA_FIXUP_ACT_INIT) 4129 alc_update_coef_idx(codec, 0x1e, 0, 0x80); 4130 } 4131 4132 static void alc269_fixup_headset_mic(struct hda_codec *codec, 4133 const struct hda_fixup *fix, int action) 4134 { 4135 struct alc_spec *spec = codec->spec; 4136 4137 if (action == HDA_FIXUP_ACT_PRE_PROBE) 4138 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 4139 } 4140 4141 static void alc271_fixup_dmic(struct hda_codec *codec, 4142 const struct hda_fixup *fix, int action) 4143 { 4144 static const struct hda_verb verbs[] = { 4145 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d}, 4146 {0x20, AC_VERB_SET_PROC_COEF, 0x4000}, 4147 {} 4148 }; 4149 unsigned int cfg; 4150 4151 if (strcmp(codec->core.chip_name, "ALC271X") && 4152 strcmp(codec->core.chip_name, "ALC269VB")) 4153 return; 4154 cfg = snd_hda_codec_get_pincfg(codec, 0x12); 4155 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED) 4156 snd_hda_sequence_write(codec, verbs); 4157 } 4158 4159 /* Fix the speaker amp after resume, etc */ 4160 static void alc269vb_fixup_aspire_e1_coef(struct hda_codec *codec, 4161 const struct hda_fixup *fix, 4162 int action) 4163 { 4164 if (action == HDA_FIXUP_ACT_INIT) 4165 alc_update_coef_idx(codec, 0x0d, 0x6000, 0x6000); 4166 } 4167 4168 static void alc269_fixup_pcm_44k(struct hda_codec *codec, 4169 const struct hda_fixup *fix, int action) 4170 { 4171 struct alc_spec *spec = codec->spec; 4172 4173 if (action != HDA_FIXUP_ACT_PROBE) 4174 return; 4175 4176 /* Due to a hardware problem on Lenovo Ideadpad, we need to 4177 * fix the sample rate of analog I/O to 44.1kHz 4178 */ 4179 spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback; 4180 spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture; 4181 } 4182 4183 static void alc269_fixup_stereo_dmic(struct hda_codec *codec, 4184 const struct hda_fixup *fix, int action) 4185 { 4186 /* The digital-mic unit sends PDM (differential signal) instead of 4187 * the standard PCM, thus you can't record a valid mono stream as is. 4188 * Below is a workaround specific to ALC269 to control the dmic 4189 * signal source as mono. 4190 */ 4191 if (action == HDA_FIXUP_ACT_INIT) 4192 alc_update_coef_idx(codec, 0x07, 0, 0x80); 4193 } 4194 4195 static void alc269_quanta_automute(struct hda_codec *codec) 4196 { 4197 snd_hda_gen_update_outputs(codec); 4198 4199 alc_write_coef_idx(codec, 0x0c, 0x680); 4200 alc_write_coef_idx(codec, 0x0c, 0x480); 4201 } 4202 4203 static void alc269_fixup_quanta_mute(struct hda_codec *codec, 4204 const struct hda_fixup *fix, int action) 4205 { 4206 struct alc_spec *spec = codec->spec; 4207 if (action != HDA_FIXUP_ACT_PROBE) 4208 return; 4209 spec->gen.automute_hook = alc269_quanta_automute; 4210 } 4211 4212 static void alc269_x101_hp_automute_hook(struct hda_codec *codec, 4213 struct hda_jack_callback *jack) 4214 { 4215 struct alc_spec *spec = codec->spec; 4216 int vref; 4217 msleep(200); 4218 snd_hda_gen_hp_automute(codec, jack); 4219 4220 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0; 4221 msleep(100); 4222 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4223 vref); 4224 msleep(500); 4225 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4226 vref); 4227 } 4228 4229 /* 4230 * Magic sequence to make Huawei Matebook X right speaker working (bko#197801) 4231 */ 4232 struct hda_alc298_mbxinit { 4233 unsigned char value_0x23; 4234 unsigned char value_0x25; 4235 }; 4236 4237 static void alc298_huawei_mbx_stereo_seq(struct hda_codec *codec, 4238 const struct hda_alc298_mbxinit *initval, 4239 bool first) 4240 { 4241 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x0); 4242 alc_write_coef_idx(codec, 0x26, 0xb000); 4243 4244 if (first) 4245 snd_hda_codec_write(codec, 0x21, 0, AC_VERB_GET_PIN_SENSE, 0x0); 4246 4247 snd_hda_codec_write(codec, 0x6, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80); 4248 alc_write_coef_idx(codec, 0x26, 0xf000); 4249 alc_write_coef_idx(codec, 0x23, initval->value_0x23); 4250 4251 if (initval->value_0x23 != 0x1e) 4252 alc_write_coef_idx(codec, 0x25, initval->value_0x25); 4253 4254 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26); 4255 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010); 4256 } 4257 4258 static void alc298_fixup_huawei_mbx_stereo(struct hda_codec *codec, 4259 const struct hda_fixup *fix, 4260 int action) 4261 { 4262 /* Initialization magic */ 4263 static const struct hda_alc298_mbxinit dac_init[] = { 4264 {0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00}, 4265 {0x10, 0x00}, {0x1a, 0x40}, {0x1b, 0x82}, {0x1c, 0x00}, 4266 {0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00}, 4267 {0x20, 0xc2}, {0x21, 0xc8}, {0x22, 0x26}, {0x23, 0x24}, 4268 {0x27, 0xff}, {0x28, 0xff}, {0x29, 0xff}, {0x2a, 0x8f}, 4269 {0x2b, 0x02}, {0x2c, 0x48}, {0x2d, 0x34}, {0x2e, 0x00}, 4270 {0x2f, 0x00}, 4271 {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00}, 4272 {0x34, 0x00}, {0x35, 0x01}, {0x36, 0x93}, {0x37, 0x0c}, 4273 {0x38, 0x00}, {0x39, 0x00}, {0x3a, 0xf8}, {0x38, 0x80}, 4274 {} 4275 }; 4276 const struct hda_alc298_mbxinit *seq; 4277 4278 if (action != HDA_FIXUP_ACT_INIT) 4279 return; 4280 4281 /* Start */ 4282 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x00); 4283 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80); 4284 alc_write_coef_idx(codec, 0x26, 0xf000); 4285 alc_write_coef_idx(codec, 0x22, 0x31); 4286 alc_write_coef_idx(codec, 0x23, 0x0b); 4287 alc_write_coef_idx(codec, 0x25, 0x00); 4288 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26); 4289 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010); 4290 4291 for (seq = dac_init; seq->value_0x23; seq++) 4292 alc298_huawei_mbx_stereo_seq(codec, seq, seq == dac_init); 4293 } 4294 4295 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec, 4296 const struct hda_fixup *fix, int action) 4297 { 4298 struct alc_spec *spec = codec->spec; 4299 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4300 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 4301 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook; 4302 } 4303 } 4304 4305 static void alc_update_vref_led(struct hda_codec *codec, hda_nid_t pin, 4306 bool polarity, bool on) 4307 { 4308 unsigned int pinval; 4309 4310 if (!pin) 4311 return; 4312 if (polarity) 4313 on = !on; 4314 pinval = snd_hda_codec_get_pin_target(codec, pin); 4315 pinval &= ~AC_PINCTL_VREFEN; 4316 pinval |= on ? AC_PINCTL_VREF_80 : AC_PINCTL_VREF_HIZ; 4317 /* temporarily power up/down for setting VREF */ 4318 snd_hda_power_up_pm(codec); 4319 snd_hda_set_pin_ctl_cache(codec, pin, pinval); 4320 snd_hda_power_down_pm(codec); 4321 } 4322 4323 /* update mute-LED according to the speaker mute state via mic VREF pin */ 4324 static int vref_mute_led_set(struct led_classdev *led_cdev, 4325 enum led_brightness brightness) 4326 { 4327 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4328 struct alc_spec *spec = codec->spec; 4329 4330 alc_update_vref_led(codec, spec->mute_led_nid, 4331 spec->mute_led_polarity, brightness); 4332 return 0; 4333 } 4334 4335 /* Make sure the led works even in runtime suspend */ 4336 static unsigned int led_power_filter(struct hda_codec *codec, 4337 hda_nid_t nid, 4338 unsigned int power_state) 4339 { 4340 struct alc_spec *spec = codec->spec; 4341 4342 if (power_state != AC_PWRST_D3 || nid == 0 || 4343 (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid)) 4344 return power_state; 4345 4346 /* Set pin ctl again, it might have just been set to 0 */ 4347 snd_hda_set_pin_ctl(codec, nid, 4348 snd_hda_codec_get_pin_target(codec, nid)); 4349 4350 return snd_hda_gen_path_power_filter(codec, nid, power_state); 4351 } 4352 4353 static void alc269_fixup_hp_mute_led(struct hda_codec *codec, 4354 const struct hda_fixup *fix, int action) 4355 { 4356 struct alc_spec *spec = codec->spec; 4357 const struct dmi_device *dev = NULL; 4358 4359 if (action != HDA_FIXUP_ACT_PRE_PROBE) 4360 return; 4361 4362 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) { 4363 int pol, pin; 4364 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2) 4365 continue; 4366 if (pin < 0x0a || pin >= 0x10) 4367 break; 4368 spec->mute_led_polarity = pol; 4369 spec->mute_led_nid = pin - 0x0a + 0x18; 4370 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set); 4371 codec->power_filter = led_power_filter; 4372 codec_dbg(codec, 4373 "Detected mute LED for %x:%d\n", spec->mute_led_nid, 4374 spec->mute_led_polarity); 4375 break; 4376 } 4377 } 4378 4379 static void alc269_fixup_hp_mute_led_micx(struct hda_codec *codec, 4380 const struct hda_fixup *fix, 4381 int action, hda_nid_t pin) 4382 { 4383 struct alc_spec *spec = codec->spec; 4384 4385 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4386 spec->mute_led_polarity = 0; 4387 spec->mute_led_nid = pin; 4388 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set); 4389 codec->power_filter = led_power_filter; 4390 } 4391 } 4392 4393 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec, 4394 const struct hda_fixup *fix, int action) 4395 { 4396 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x18); 4397 } 4398 4399 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec, 4400 const struct hda_fixup *fix, int action) 4401 { 4402 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x19); 4403 } 4404 4405 static void alc269_fixup_hp_mute_led_mic3(struct hda_codec *codec, 4406 const struct hda_fixup *fix, int action) 4407 { 4408 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1b); 4409 } 4410 4411 /* update LED status via GPIO */ 4412 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask, 4413 int polarity, bool enabled) 4414 { 4415 if (polarity) 4416 enabled = !enabled; 4417 alc_update_gpio_data(codec, mask, !enabled); /* muted -> LED on */ 4418 } 4419 4420 /* turn on/off mute LED via GPIO per vmaster hook */ 4421 static int gpio_mute_led_set(struct led_classdev *led_cdev, 4422 enum led_brightness brightness) 4423 { 4424 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4425 struct alc_spec *spec = codec->spec; 4426 4427 alc_update_gpio_led(codec, spec->gpio_mute_led_mask, 4428 spec->mute_led_polarity, !brightness); 4429 return 0; 4430 } 4431 4432 /* turn on/off mic-mute LED via GPIO per capture hook */ 4433 static int micmute_led_set(struct led_classdev *led_cdev, 4434 enum led_brightness brightness) 4435 { 4436 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4437 struct alc_spec *spec = codec->spec; 4438 4439 alc_update_gpio_led(codec, spec->gpio_mic_led_mask, 4440 spec->micmute_led_polarity, !brightness); 4441 return 0; 4442 } 4443 4444 /* setup mute and mic-mute GPIO bits, add hooks appropriately */ 4445 static void alc_fixup_hp_gpio_led(struct hda_codec *codec, 4446 int action, 4447 unsigned int mute_mask, 4448 unsigned int micmute_mask) 4449 { 4450 struct alc_spec *spec = codec->spec; 4451 4452 alc_fixup_gpio(codec, action, mute_mask | micmute_mask); 4453 4454 if (action != HDA_FIXUP_ACT_PRE_PROBE) 4455 return; 4456 if (mute_mask) { 4457 spec->gpio_mute_led_mask = mute_mask; 4458 snd_hda_gen_add_mute_led_cdev(codec, gpio_mute_led_set); 4459 } 4460 if (micmute_mask) { 4461 spec->gpio_mic_led_mask = micmute_mask; 4462 snd_hda_gen_add_micmute_led_cdev(codec, micmute_led_set); 4463 } 4464 } 4465 4466 static void alc236_fixup_hp_gpio_led(struct hda_codec *codec, 4467 const struct hda_fixup *fix, int action) 4468 { 4469 alc_fixup_hp_gpio_led(codec, action, 0x02, 0x01); 4470 } 4471 4472 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec, 4473 const struct hda_fixup *fix, int action) 4474 { 4475 alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10); 4476 } 4477 4478 static void alc285_fixup_hp_gpio_led(struct hda_codec *codec, 4479 const struct hda_fixup *fix, int action) 4480 { 4481 alc_fixup_hp_gpio_led(codec, action, 0x04, 0x01); 4482 } 4483 4484 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec, 4485 const struct hda_fixup *fix, int action) 4486 { 4487 alc_fixup_hp_gpio_led(codec, action, 0x02, 0x20); 4488 } 4489 4490 static void alc287_fixup_hp_gpio_led(struct hda_codec *codec, 4491 const struct hda_fixup *fix, int action) 4492 { 4493 alc_fixup_hp_gpio_led(codec, action, 0x10, 0); 4494 } 4495 4496 static void alc245_fixup_hp_gpio_led(struct hda_codec *codec, 4497 const struct hda_fixup *fix, int action) 4498 { 4499 struct alc_spec *spec = codec->spec; 4500 4501 if (action == HDA_FIXUP_ACT_PRE_PROBE) 4502 spec->micmute_led_polarity = 1; 4503 alc_fixup_hp_gpio_led(codec, action, 0, 0x04); 4504 } 4505 4506 /* turn on/off mic-mute LED per capture hook via VREF change */ 4507 static int vref_micmute_led_set(struct led_classdev *led_cdev, 4508 enum led_brightness brightness) 4509 { 4510 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4511 struct alc_spec *spec = codec->spec; 4512 4513 alc_update_vref_led(codec, spec->cap_mute_led_nid, 4514 spec->micmute_led_polarity, brightness); 4515 return 0; 4516 } 4517 4518 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec, 4519 const struct hda_fixup *fix, int action) 4520 { 4521 struct alc_spec *spec = codec->spec; 4522 4523 alc_fixup_hp_gpio_led(codec, action, 0x08, 0); 4524 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4525 /* Like hp_gpio_mic1_led, but also needs GPIO4 low to 4526 * enable headphone amp 4527 */ 4528 spec->gpio_mask |= 0x10; 4529 spec->gpio_dir |= 0x10; 4530 spec->cap_mute_led_nid = 0x18; 4531 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set); 4532 codec->power_filter = led_power_filter; 4533 } 4534 } 4535 4536 static void alc280_fixup_hp_gpio4(struct hda_codec *codec, 4537 const struct hda_fixup *fix, int action) 4538 { 4539 struct alc_spec *spec = codec->spec; 4540 4541 alc_fixup_hp_gpio_led(codec, action, 0x08, 0); 4542 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4543 spec->cap_mute_led_nid = 0x18; 4544 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set); 4545 codec->power_filter = led_power_filter; 4546 } 4547 } 4548 4549 /* HP Spectre x360 14 model needs a unique workaround for enabling the amp; 4550 * it needs to toggle the GPIO0 once on and off at each time (bko#210633) 4551 */ 4552 static void alc245_fixup_hp_x360_amp(struct hda_codec *codec, 4553 const struct hda_fixup *fix, int action) 4554 { 4555 struct alc_spec *spec = codec->spec; 4556 4557 switch (action) { 4558 case HDA_FIXUP_ACT_PRE_PROBE: 4559 spec->gpio_mask |= 0x01; 4560 spec->gpio_dir |= 0x01; 4561 break; 4562 case HDA_FIXUP_ACT_INIT: 4563 /* need to toggle GPIO to enable the amp */ 4564 alc_update_gpio_data(codec, 0x01, true); 4565 msleep(100); 4566 alc_update_gpio_data(codec, 0x01, false); 4567 break; 4568 } 4569 } 4570 4571 /* toggle GPIO2 at each time stream is started; we use PREPARE state instead */ 4572 static void alc274_hp_envy_pcm_hook(struct hda_pcm_stream *hinfo, 4573 struct hda_codec *codec, 4574 struct snd_pcm_substream *substream, 4575 int action) 4576 { 4577 switch (action) { 4578 case HDA_GEN_PCM_ACT_PREPARE: 4579 alc_update_gpio_data(codec, 0x04, true); 4580 break; 4581 case HDA_GEN_PCM_ACT_CLEANUP: 4582 alc_update_gpio_data(codec, 0x04, false); 4583 break; 4584 } 4585 } 4586 4587 static void alc274_fixup_hp_envy_gpio(struct hda_codec *codec, 4588 const struct hda_fixup *fix, 4589 int action) 4590 { 4591 struct alc_spec *spec = codec->spec; 4592 4593 if (action == HDA_FIXUP_ACT_PROBE) { 4594 spec->gpio_mask |= 0x04; 4595 spec->gpio_dir |= 0x04; 4596 spec->gen.pcm_playback_hook = alc274_hp_envy_pcm_hook; 4597 } 4598 } 4599 4600 static void alc_update_coef_led(struct hda_codec *codec, 4601 struct alc_coef_led *led, 4602 bool polarity, bool on) 4603 { 4604 if (polarity) 4605 on = !on; 4606 /* temporarily power up/down for setting COEF bit */ 4607 alc_update_coef_idx(codec, led->idx, led->mask, 4608 on ? led->on : led->off); 4609 } 4610 4611 /* update mute-LED according to the speaker mute state via COEF bit */ 4612 static int coef_mute_led_set(struct led_classdev *led_cdev, 4613 enum led_brightness brightness) 4614 { 4615 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4616 struct alc_spec *spec = codec->spec; 4617 4618 alc_update_coef_led(codec, &spec->mute_led_coef, 4619 spec->mute_led_polarity, brightness); 4620 return 0; 4621 } 4622 4623 static void alc285_fixup_hp_mute_led_coefbit(struct hda_codec *codec, 4624 const struct hda_fixup *fix, 4625 int action) 4626 { 4627 struct alc_spec *spec = codec->spec; 4628 4629 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4630 spec->mute_led_polarity = 0; 4631 spec->mute_led_coef.idx = 0x0b; 4632 spec->mute_led_coef.mask = 1 << 3; 4633 spec->mute_led_coef.on = 1 << 3; 4634 spec->mute_led_coef.off = 0; 4635 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set); 4636 } 4637 } 4638 4639 static void alc236_fixup_hp_mute_led_coefbit(struct hda_codec *codec, 4640 const struct hda_fixup *fix, 4641 int action) 4642 { 4643 struct alc_spec *spec = codec->spec; 4644 4645 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4646 spec->mute_led_polarity = 0; 4647 spec->mute_led_coef.idx = 0x34; 4648 spec->mute_led_coef.mask = 1 << 5; 4649 spec->mute_led_coef.on = 0; 4650 spec->mute_led_coef.off = 1 << 5; 4651 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set); 4652 } 4653 } 4654 4655 static void alc236_fixup_hp_mute_led_coefbit2(struct hda_codec *codec, 4656 const struct hda_fixup *fix, int action) 4657 { 4658 struct alc_spec *spec = codec->spec; 4659 4660 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4661 spec->mute_led_polarity = 0; 4662 spec->mute_led_coef.idx = 0x07; 4663 spec->mute_led_coef.mask = 1; 4664 spec->mute_led_coef.on = 1; 4665 spec->mute_led_coef.off = 0; 4666 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set); 4667 } 4668 } 4669 4670 static void alc245_fixup_hp_mute_led_coefbit(struct hda_codec *codec, 4671 const struct hda_fixup *fix, 4672 int action) 4673 { 4674 struct alc_spec *spec = codec->spec; 4675 4676 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4677 spec->mute_led_polarity = 0; 4678 spec->mute_led_coef.idx = 0x0b; 4679 spec->mute_led_coef.mask = 3 << 2; 4680 spec->mute_led_coef.on = 2 << 2; 4681 spec->mute_led_coef.off = 1 << 2; 4682 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set); 4683 } 4684 } 4685 4686 /* turn on/off mic-mute LED per capture hook by coef bit */ 4687 static int coef_micmute_led_set(struct led_classdev *led_cdev, 4688 enum led_brightness brightness) 4689 { 4690 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4691 struct alc_spec *spec = codec->spec; 4692 4693 alc_update_coef_led(codec, &spec->mic_led_coef, 4694 spec->micmute_led_polarity, brightness); 4695 return 0; 4696 } 4697 4698 static void alc285_fixup_hp_coef_micmute_led(struct hda_codec *codec, 4699 const struct hda_fixup *fix, int action) 4700 { 4701 struct alc_spec *spec = codec->spec; 4702 4703 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4704 spec->mic_led_coef.idx = 0x19; 4705 spec->mic_led_coef.mask = 1 << 13; 4706 spec->mic_led_coef.on = 1 << 13; 4707 spec->mic_led_coef.off = 0; 4708 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set); 4709 } 4710 } 4711 4712 static void alc285_fixup_hp_gpio_micmute_led(struct hda_codec *codec, 4713 const struct hda_fixup *fix, int action) 4714 { 4715 struct alc_spec *spec = codec->spec; 4716 4717 if (action == HDA_FIXUP_ACT_PRE_PROBE) 4718 spec->micmute_led_polarity = 1; 4719 alc_fixup_hp_gpio_led(codec, action, 0, 0x04); 4720 } 4721 4722 static void alc236_fixup_hp_coef_micmute_led(struct hda_codec *codec, 4723 const struct hda_fixup *fix, int action) 4724 { 4725 struct alc_spec *spec = codec->spec; 4726 4727 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4728 spec->mic_led_coef.idx = 0x35; 4729 spec->mic_led_coef.mask = 3 << 2; 4730 spec->mic_led_coef.on = 2 << 2; 4731 spec->mic_led_coef.off = 1 << 2; 4732 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set); 4733 } 4734 } 4735 4736 static void alc285_fixup_hp_mute_led(struct hda_codec *codec, 4737 const struct hda_fixup *fix, int action) 4738 { 4739 alc285_fixup_hp_mute_led_coefbit(codec, fix, action); 4740 alc285_fixup_hp_coef_micmute_led(codec, fix, action); 4741 } 4742 4743 static void alc285_fixup_hp_spectre_x360_mute_led(struct hda_codec *codec, 4744 const struct hda_fixup *fix, int action) 4745 { 4746 alc285_fixup_hp_mute_led_coefbit(codec, fix, action); 4747 alc285_fixup_hp_gpio_micmute_led(codec, fix, action); 4748 } 4749 4750 static void alc236_fixup_hp_mute_led(struct hda_codec *codec, 4751 const struct hda_fixup *fix, int action) 4752 { 4753 alc236_fixup_hp_mute_led_coefbit(codec, fix, action); 4754 alc236_fixup_hp_coef_micmute_led(codec, fix, action); 4755 } 4756 4757 static void alc236_fixup_hp_micmute_led_vref(struct hda_codec *codec, 4758 const struct hda_fixup *fix, int action) 4759 { 4760 struct alc_spec *spec = codec->spec; 4761 4762 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4763 spec->cap_mute_led_nid = 0x1a; 4764 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set); 4765 codec->power_filter = led_power_filter; 4766 } 4767 } 4768 4769 static void alc236_fixup_hp_mute_led_micmute_vref(struct hda_codec *codec, 4770 const struct hda_fixup *fix, int action) 4771 { 4772 alc236_fixup_hp_mute_led_coefbit(codec, fix, action); 4773 alc236_fixup_hp_micmute_led_vref(codec, fix, action); 4774 } 4775 4776 static inline void alc298_samsung_write_coef_pack(struct hda_codec *codec, 4777 const unsigned short coefs[2]) 4778 { 4779 alc_write_coef_idx(codec, 0x23, coefs[0]); 4780 alc_write_coef_idx(codec, 0x25, coefs[1]); 4781 alc_write_coef_idx(codec, 0x26, 0xb011); 4782 } 4783 4784 struct alc298_samsung_amp_desc { 4785 unsigned char nid; 4786 unsigned short init_seq[2][2]; 4787 }; 4788 4789 static void alc298_fixup_samsung_amp(struct hda_codec *codec, 4790 const struct hda_fixup *fix, int action) 4791 { 4792 int i, j; 4793 static const unsigned short init_seq[][2] = { 4794 { 0x19, 0x00 }, { 0x20, 0xc0 }, { 0x22, 0x44 }, { 0x23, 0x08 }, 4795 { 0x24, 0x85 }, { 0x25, 0x41 }, { 0x35, 0x40 }, { 0x36, 0x01 }, 4796 { 0x38, 0x81 }, { 0x3a, 0x03 }, { 0x3b, 0x81 }, { 0x40, 0x3e }, 4797 { 0x41, 0x07 }, { 0x400, 0x1 } 4798 }; 4799 static const struct alc298_samsung_amp_desc amps[] = { 4800 { 0x3a, { { 0x18, 0x1 }, { 0x26, 0x0 } } }, 4801 { 0x39, { { 0x18, 0x2 }, { 0x26, 0x1 } } } 4802 }; 4803 4804 if (action != HDA_FIXUP_ACT_INIT) 4805 return; 4806 4807 for (i = 0; i < ARRAY_SIZE(amps); i++) { 4808 alc_write_coef_idx(codec, 0x22, amps[i].nid); 4809 4810 for (j = 0; j < ARRAY_SIZE(amps[i].init_seq); j++) 4811 alc298_samsung_write_coef_pack(codec, amps[i].init_seq[j]); 4812 4813 for (j = 0; j < ARRAY_SIZE(init_seq); j++) 4814 alc298_samsung_write_coef_pack(codec, init_seq[j]); 4815 } 4816 } 4817 4818 struct alc298_samsung_v2_amp_desc { 4819 unsigned short nid; 4820 int init_seq_size; 4821 unsigned short init_seq[18][2]; 4822 }; 4823 4824 static const struct alc298_samsung_v2_amp_desc 4825 alc298_samsung_v2_amp_desc_tbl[] = { 4826 { 0x38, 18, { 4827 { 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 }, 4828 { 0x201b, 0x0001 }, { 0x201d, 0x0001 }, { 0x201f, 0x00fe }, 4829 { 0x2021, 0x0000 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 }, 4830 { 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e }, 4831 { 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x2399, 0x0003 }, 4832 { 0x23a4, 0x00b5 }, { 0x23a5, 0x0001 }, { 0x23ba, 0x0094 } 4833 }}, 4834 { 0x39, 18, { 4835 { 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 }, 4836 { 0x201b, 0x0002 }, { 0x201d, 0x0002 }, { 0x201f, 0x00fd }, 4837 { 0x2021, 0x0001 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 }, 4838 { 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e }, 4839 { 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x2399, 0x0003 }, 4840 { 0x23a4, 0x00b5 }, { 0x23a5, 0x0001 }, { 0x23ba, 0x0094 } 4841 }}, 4842 { 0x3c, 15, { 4843 { 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 }, 4844 { 0x201b, 0x0001 }, { 0x201d, 0x0001 }, { 0x201f, 0x00fe }, 4845 { 0x2021, 0x0000 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 }, 4846 { 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e }, 4847 { 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x23ba, 0x008d } 4848 }}, 4849 { 0x3d, 15, { 4850 { 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 }, 4851 { 0x201b, 0x0002 }, { 0x201d, 0x0002 }, { 0x201f, 0x00fd }, 4852 { 0x2021, 0x0001 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 }, 4853 { 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e }, 4854 { 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x23ba, 0x008d } 4855 }} 4856 }; 4857 4858 static void alc298_samsung_v2_enable_amps(struct hda_codec *codec) 4859 { 4860 struct alc_spec *spec = codec->spec; 4861 static const unsigned short enable_seq[][2] = { 4862 { 0x203a, 0x0081 }, { 0x23ff, 0x0001 }, 4863 }; 4864 int i, j; 4865 4866 for (i = 0; i < spec->num_speaker_amps; i++) { 4867 alc_write_coef_idx(codec, 0x22, alc298_samsung_v2_amp_desc_tbl[i].nid); 4868 for (j = 0; j < ARRAY_SIZE(enable_seq); j++) 4869 alc298_samsung_write_coef_pack(codec, enable_seq[j]); 4870 codec_dbg(codec, "alc298_samsung_v2: Enabled speaker amp 0x%02x\n", 4871 alc298_samsung_v2_amp_desc_tbl[i].nid); 4872 } 4873 } 4874 4875 static void alc298_samsung_v2_disable_amps(struct hda_codec *codec) 4876 { 4877 struct alc_spec *spec = codec->spec; 4878 static const unsigned short disable_seq[][2] = { 4879 { 0x23ff, 0x0000 }, { 0x203a, 0x0080 }, 4880 }; 4881 int i, j; 4882 4883 for (i = 0; i < spec->num_speaker_amps; i++) { 4884 alc_write_coef_idx(codec, 0x22, alc298_samsung_v2_amp_desc_tbl[i].nid); 4885 for (j = 0; j < ARRAY_SIZE(disable_seq); j++) 4886 alc298_samsung_write_coef_pack(codec, disable_seq[j]); 4887 codec_dbg(codec, "alc298_samsung_v2: Disabled speaker amp 0x%02x\n", 4888 alc298_samsung_v2_amp_desc_tbl[i].nid); 4889 } 4890 } 4891 4892 static void alc298_samsung_v2_playback_hook(struct hda_pcm_stream *hinfo, 4893 struct hda_codec *codec, 4894 struct snd_pcm_substream *substream, 4895 int action) 4896 { 4897 /* Dynamically enable/disable speaker amps before and after playback */ 4898 if (action == HDA_GEN_PCM_ACT_OPEN) 4899 alc298_samsung_v2_enable_amps(codec); 4900 if (action == HDA_GEN_PCM_ACT_CLOSE) 4901 alc298_samsung_v2_disable_amps(codec); 4902 } 4903 4904 static void alc298_samsung_v2_init_amps(struct hda_codec *codec, 4905 int num_speaker_amps) 4906 { 4907 struct alc_spec *spec = codec->spec; 4908 int i, j; 4909 4910 /* Set spec's num_speaker_amps before doing anything else */ 4911 spec->num_speaker_amps = num_speaker_amps; 4912 4913 /* Disable speaker amps before init to prevent any physical damage */ 4914 alc298_samsung_v2_disable_amps(codec); 4915 4916 /* Initialize the speaker amps */ 4917 for (i = 0; i < spec->num_speaker_amps; i++) { 4918 alc_write_coef_idx(codec, 0x22, alc298_samsung_v2_amp_desc_tbl[i].nid); 4919 for (j = 0; j < alc298_samsung_v2_amp_desc_tbl[i].init_seq_size; j++) { 4920 alc298_samsung_write_coef_pack(codec, 4921 alc298_samsung_v2_amp_desc_tbl[i].init_seq[j]); 4922 } 4923 alc_write_coef_idx(codec, 0x89, 0x0); 4924 codec_dbg(codec, "alc298_samsung_v2: Initialized speaker amp 0x%02x\n", 4925 alc298_samsung_v2_amp_desc_tbl[i].nid); 4926 } 4927 4928 /* register hook to enable speaker amps only when they are needed */ 4929 spec->gen.pcm_playback_hook = alc298_samsung_v2_playback_hook; 4930 } 4931 4932 static void alc298_fixup_samsung_amp_v2_2_amps(struct hda_codec *codec, 4933 const struct hda_fixup *fix, int action) 4934 { 4935 if (action == HDA_FIXUP_ACT_PROBE) 4936 alc298_samsung_v2_init_amps(codec, 2); 4937 } 4938 4939 static void alc298_fixup_samsung_amp_v2_4_amps(struct hda_codec *codec, 4940 const struct hda_fixup *fix, int action) 4941 { 4942 if (action == HDA_FIXUP_ACT_PROBE) 4943 alc298_samsung_v2_init_amps(codec, 4); 4944 } 4945 4946 #if IS_REACHABLE(CONFIG_INPUT) 4947 static void gpio2_mic_hotkey_event(struct hda_codec *codec, 4948 struct hda_jack_callback *event) 4949 { 4950 struct alc_spec *spec = codec->spec; 4951 4952 /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore 4953 send both key on and key off event for every interrupt. */ 4954 input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1); 4955 input_sync(spec->kb_dev); 4956 input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0); 4957 input_sync(spec->kb_dev); 4958 } 4959 4960 static int alc_register_micmute_input_device(struct hda_codec *codec) 4961 { 4962 struct alc_spec *spec = codec->spec; 4963 int i; 4964 4965 spec->kb_dev = input_allocate_device(); 4966 if (!spec->kb_dev) { 4967 codec_err(codec, "Out of memory (input_allocate_device)\n"); 4968 return -ENOMEM; 4969 } 4970 4971 spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE; 4972 4973 spec->kb_dev->name = "Microphone Mute Button"; 4974 spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY); 4975 spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]); 4976 spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map); 4977 spec->kb_dev->keycode = spec->alc_mute_keycode_map; 4978 for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++) 4979 set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit); 4980 4981 if (input_register_device(spec->kb_dev)) { 4982 codec_err(codec, "input_register_device failed\n"); 4983 input_free_device(spec->kb_dev); 4984 spec->kb_dev = NULL; 4985 return -ENOMEM; 4986 } 4987 4988 return 0; 4989 } 4990 4991 /* GPIO1 = set according to SKU external amp 4992 * GPIO2 = mic mute hotkey 4993 * GPIO3 = mute LED 4994 * GPIO4 = mic mute LED 4995 */ 4996 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec, 4997 const struct hda_fixup *fix, int action) 4998 { 4999 struct alc_spec *spec = codec->spec; 5000 5001 alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10); 5002 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5003 spec->init_amp = ALC_INIT_DEFAULT; 5004 if (alc_register_micmute_input_device(codec) != 0) 5005 return; 5006 5007 spec->gpio_mask |= 0x06; 5008 spec->gpio_dir |= 0x02; 5009 spec->gpio_data |= 0x02; 5010 snd_hda_codec_write_cache(codec, codec->core.afg, 0, 5011 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04); 5012 snd_hda_jack_detect_enable_callback(codec, codec->core.afg, 5013 gpio2_mic_hotkey_event); 5014 return; 5015 } 5016 5017 if (!spec->kb_dev) 5018 return; 5019 5020 switch (action) { 5021 case HDA_FIXUP_ACT_FREE: 5022 input_unregister_device(spec->kb_dev); 5023 spec->kb_dev = NULL; 5024 } 5025 } 5026 5027 /* Line2 = mic mute hotkey 5028 * GPIO2 = mic mute LED 5029 */ 5030 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec, 5031 const struct hda_fixup *fix, int action) 5032 { 5033 struct alc_spec *spec = codec->spec; 5034 5035 alc_fixup_hp_gpio_led(codec, action, 0, 0x04); 5036 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5037 spec->init_amp = ALC_INIT_DEFAULT; 5038 if (alc_register_micmute_input_device(codec) != 0) 5039 return; 5040 5041 snd_hda_jack_detect_enable_callback(codec, 0x1b, 5042 gpio2_mic_hotkey_event); 5043 return; 5044 } 5045 5046 if (!spec->kb_dev) 5047 return; 5048 5049 switch (action) { 5050 case HDA_FIXUP_ACT_FREE: 5051 input_unregister_device(spec->kb_dev); 5052 spec->kb_dev = NULL; 5053 } 5054 } 5055 #else /* INPUT */ 5056 #define alc280_fixup_hp_gpio2_mic_hotkey NULL 5057 #define alc233_fixup_lenovo_line2_mic_hotkey NULL 5058 #endif /* INPUT */ 5059 5060 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec, 5061 const struct hda_fixup *fix, int action) 5062 { 5063 struct alc_spec *spec = codec->spec; 5064 5065 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1a); 5066 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5067 spec->cap_mute_led_nid = 0x18; 5068 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set); 5069 } 5070 } 5071 5072 static void alc_hp_mute_disable(struct hda_codec *codec, unsigned int delay) 5073 { 5074 if (delay <= 0) 5075 delay = 75; 5076 snd_hda_codec_write(codec, 0x21, 0, 5077 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 5078 msleep(delay); 5079 snd_hda_codec_write(codec, 0x21, 0, 5080 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 5081 msleep(delay); 5082 } 5083 5084 static void alc_hp_enable_unmute(struct hda_codec *codec, unsigned int delay) 5085 { 5086 if (delay <= 0) 5087 delay = 75; 5088 snd_hda_codec_write(codec, 0x21, 0, 5089 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 5090 msleep(delay); 5091 snd_hda_codec_write(codec, 0x21, 0, 5092 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 5093 msleep(delay); 5094 } 5095 5096 static const struct coef_fw alc225_pre_hsmode[] = { 5097 UPDATE_COEF(0x4a, 1<<8, 0), 5098 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), 5099 UPDATE_COEF(0x63, 3<<14, 3<<14), 5100 UPDATE_COEF(0x4a, 3<<4, 2<<4), 5101 UPDATE_COEF(0x4a, 3<<10, 3<<10), 5102 UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10), 5103 UPDATE_COEF(0x4a, 3<<10, 0), 5104 {} 5105 }; 5106 5107 static void alc_headset_mode_unplugged(struct hda_codec *codec) 5108 { 5109 struct alc_spec *spec = codec->spec; 5110 static const struct coef_fw coef0255[] = { 5111 WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */ 5112 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */ 5113 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/ 5114 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */ 5115 WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */ 5116 {} 5117 }; 5118 static const struct coef_fw coef0256[] = { 5119 WRITE_COEF(0x1b, 0x0c4b), /* LDO and MISC control */ 5120 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */ 5121 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */ 5122 WRITE_COEFEX(0x57, 0x03, 0x09a3), /* Direct Drive HP Amp control */ 5123 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/ 5124 {} 5125 }; 5126 static const struct coef_fw coef0233[] = { 5127 WRITE_COEF(0x1b, 0x0c0b), 5128 WRITE_COEF(0x45, 0xc429), 5129 UPDATE_COEF(0x35, 0x4000, 0), 5130 WRITE_COEF(0x06, 0x2104), 5131 WRITE_COEF(0x1a, 0x0001), 5132 WRITE_COEF(0x26, 0x0004), 5133 WRITE_COEF(0x32, 0x42a3), 5134 {} 5135 }; 5136 static const struct coef_fw coef0288[] = { 5137 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), 5138 UPDATE_COEF(0x50, 0x2000, 0x2000), 5139 UPDATE_COEF(0x56, 0x0006, 0x0006), 5140 UPDATE_COEF(0x66, 0x0008, 0), 5141 UPDATE_COEF(0x67, 0x2000, 0), 5142 {} 5143 }; 5144 static const struct coef_fw coef0298[] = { 5145 UPDATE_COEF(0x19, 0x1300, 0x0300), 5146 {} 5147 }; 5148 static const struct coef_fw coef0292[] = { 5149 WRITE_COEF(0x76, 0x000e), 5150 WRITE_COEF(0x6c, 0x2400), 5151 WRITE_COEF(0x18, 0x7308), 5152 WRITE_COEF(0x6b, 0xc429), 5153 {} 5154 }; 5155 static const struct coef_fw coef0293[] = { 5156 UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */ 5157 UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */ 5158 UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */ 5159 UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */ 5160 WRITE_COEF(0x45, 0xc429), /* Set to TRS type */ 5161 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */ 5162 {} 5163 }; 5164 static const struct coef_fw coef0668[] = { 5165 WRITE_COEF(0x15, 0x0d40), 5166 WRITE_COEF(0xb7, 0x802b), 5167 {} 5168 }; 5169 static const struct coef_fw coef0225[] = { 5170 UPDATE_COEF(0x63, 3<<14, 0), 5171 {} 5172 }; 5173 static const struct coef_fw coef0274[] = { 5174 UPDATE_COEF(0x4a, 0x0100, 0), 5175 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0), 5176 UPDATE_COEF(0x6b, 0xf000, 0x5000), 5177 UPDATE_COEF(0x4a, 0x0010, 0), 5178 UPDATE_COEF(0x4a, 0x0c00, 0x0c00), 5179 WRITE_COEF(0x45, 0x5289), 5180 UPDATE_COEF(0x4a, 0x0c00, 0), 5181 {} 5182 }; 5183 5184 if (spec->no_internal_mic_pin) { 5185 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12); 5186 return; 5187 } 5188 5189 switch (codec->core.vendor_id) { 5190 case 0x10ec0255: 5191 alc_process_coef_fw(codec, coef0255); 5192 break; 5193 case 0x10ec0230: 5194 case 0x10ec0236: 5195 case 0x10ec0256: 5196 case 0x19e58326: 5197 alc_hp_mute_disable(codec, 75); 5198 alc_process_coef_fw(codec, coef0256); 5199 break; 5200 case 0x10ec0234: 5201 case 0x10ec0274: 5202 case 0x10ec0294: 5203 alc_process_coef_fw(codec, coef0274); 5204 break; 5205 case 0x10ec0233: 5206 case 0x10ec0283: 5207 alc_process_coef_fw(codec, coef0233); 5208 break; 5209 case 0x10ec0286: 5210 case 0x10ec0288: 5211 alc_process_coef_fw(codec, coef0288); 5212 break; 5213 case 0x10ec0298: 5214 alc_process_coef_fw(codec, coef0298); 5215 alc_process_coef_fw(codec, coef0288); 5216 break; 5217 case 0x10ec0292: 5218 alc_process_coef_fw(codec, coef0292); 5219 break; 5220 case 0x10ec0293: 5221 alc_process_coef_fw(codec, coef0293); 5222 break; 5223 case 0x10ec0668: 5224 alc_process_coef_fw(codec, coef0668); 5225 break; 5226 case 0x10ec0215: 5227 case 0x10ec0225: 5228 case 0x10ec0285: 5229 case 0x10ec0295: 5230 case 0x10ec0289: 5231 case 0x10ec0299: 5232 alc_hp_mute_disable(codec, 75); 5233 alc_process_coef_fw(codec, alc225_pre_hsmode); 5234 alc_process_coef_fw(codec, coef0225); 5235 break; 5236 case 0x10ec0867: 5237 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0); 5238 break; 5239 } 5240 codec_dbg(codec, "Headset jack set to unplugged mode.\n"); 5241 } 5242 5243 5244 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin, 5245 hda_nid_t mic_pin) 5246 { 5247 static const struct coef_fw coef0255[] = { 5248 WRITE_COEFEX(0x57, 0x03, 0x8aa6), 5249 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */ 5250 {} 5251 }; 5252 static const struct coef_fw coef0256[] = { 5253 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), /* Direct Drive HP Amp control(Set to verb control)*/ 5254 WRITE_COEFEX(0x57, 0x03, 0x09a3), 5255 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */ 5256 {} 5257 }; 5258 static const struct coef_fw coef0233[] = { 5259 UPDATE_COEF(0x35, 0, 1<<14), 5260 WRITE_COEF(0x06, 0x2100), 5261 WRITE_COEF(0x1a, 0x0021), 5262 WRITE_COEF(0x26, 0x008c), 5263 {} 5264 }; 5265 static const struct coef_fw coef0288[] = { 5266 UPDATE_COEF(0x4f, 0x00c0, 0), 5267 UPDATE_COEF(0x50, 0x2000, 0), 5268 UPDATE_COEF(0x56, 0x0006, 0), 5269 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), 5270 UPDATE_COEF(0x66, 0x0008, 0x0008), 5271 UPDATE_COEF(0x67, 0x2000, 0x2000), 5272 {} 5273 }; 5274 static const struct coef_fw coef0292[] = { 5275 WRITE_COEF(0x19, 0xa208), 5276 WRITE_COEF(0x2e, 0xacf0), 5277 {} 5278 }; 5279 static const struct coef_fw coef0293[] = { 5280 UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */ 5281 UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */ 5282 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */ 5283 {} 5284 }; 5285 static const struct coef_fw coef0688[] = { 5286 WRITE_COEF(0xb7, 0x802b), 5287 WRITE_COEF(0xb5, 0x1040), 5288 UPDATE_COEF(0xc3, 0, 1<<12), 5289 {} 5290 }; 5291 static const struct coef_fw coef0225[] = { 5292 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), 5293 UPDATE_COEF(0x4a, 3<<4, 2<<4), 5294 UPDATE_COEF(0x63, 3<<14, 0), 5295 {} 5296 }; 5297 static const struct coef_fw coef0274[] = { 5298 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0x4000), 5299 UPDATE_COEF(0x4a, 0x0010, 0), 5300 UPDATE_COEF(0x6b, 0xf000, 0), 5301 {} 5302 }; 5303 5304 switch (codec->core.vendor_id) { 5305 case 0x10ec0255: 5306 alc_write_coef_idx(codec, 0x45, 0xc489); 5307 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5308 alc_process_coef_fw(codec, coef0255); 5309 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 5310 break; 5311 case 0x10ec0230: 5312 case 0x10ec0236: 5313 case 0x10ec0256: 5314 case 0x19e58326: 5315 alc_write_coef_idx(codec, 0x45, 0xc489); 5316 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5317 alc_process_coef_fw(codec, coef0256); 5318 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 5319 break; 5320 case 0x10ec0234: 5321 case 0x10ec0274: 5322 case 0x10ec0294: 5323 alc_write_coef_idx(codec, 0x45, 0x4689); 5324 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5325 alc_process_coef_fw(codec, coef0274); 5326 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 5327 break; 5328 case 0x10ec0233: 5329 case 0x10ec0283: 5330 alc_write_coef_idx(codec, 0x45, 0xc429); 5331 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5332 alc_process_coef_fw(codec, coef0233); 5333 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 5334 break; 5335 case 0x10ec0286: 5336 case 0x10ec0288: 5337 case 0x10ec0298: 5338 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5339 alc_process_coef_fw(codec, coef0288); 5340 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 5341 break; 5342 case 0x10ec0292: 5343 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5344 alc_process_coef_fw(codec, coef0292); 5345 break; 5346 case 0x10ec0293: 5347 /* Set to TRS mode */ 5348 alc_write_coef_idx(codec, 0x45, 0xc429); 5349 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5350 alc_process_coef_fw(codec, coef0293); 5351 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 5352 break; 5353 case 0x10ec0867: 5354 alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14); 5355 fallthrough; 5356 case 0x10ec0221: 5357 case 0x10ec0662: 5358 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5359 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 5360 break; 5361 case 0x10ec0668: 5362 alc_write_coef_idx(codec, 0x11, 0x0001); 5363 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5364 alc_process_coef_fw(codec, coef0688); 5365 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 5366 break; 5367 case 0x10ec0215: 5368 case 0x10ec0225: 5369 case 0x10ec0285: 5370 case 0x10ec0295: 5371 case 0x10ec0289: 5372 case 0x10ec0299: 5373 alc_process_coef_fw(codec, alc225_pre_hsmode); 5374 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10); 5375 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5376 alc_process_coef_fw(codec, coef0225); 5377 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 5378 break; 5379 } 5380 codec_dbg(codec, "Headset jack set to mic-in mode.\n"); 5381 } 5382 5383 static void alc_headset_mode_default(struct hda_codec *codec) 5384 { 5385 static const struct coef_fw coef0225[] = { 5386 UPDATE_COEF(0x45, 0x3f<<10, 0x30<<10), 5387 UPDATE_COEF(0x45, 0x3f<<10, 0x31<<10), 5388 UPDATE_COEF(0x49, 3<<8, 0<<8), 5389 UPDATE_COEF(0x4a, 3<<4, 3<<4), 5390 UPDATE_COEF(0x63, 3<<14, 0), 5391 UPDATE_COEF(0x67, 0xf000, 0x3000), 5392 {} 5393 }; 5394 static const struct coef_fw coef0255[] = { 5395 WRITE_COEF(0x45, 0xc089), 5396 WRITE_COEF(0x45, 0xc489), 5397 WRITE_COEFEX(0x57, 0x03, 0x8ea6), 5398 WRITE_COEF(0x49, 0x0049), 5399 {} 5400 }; 5401 static const struct coef_fw coef0256[] = { 5402 WRITE_COEF(0x45, 0xc489), 5403 WRITE_COEFEX(0x57, 0x03, 0x0da3), 5404 WRITE_COEF(0x49, 0x0049), 5405 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/ 5406 WRITE_COEF(0x06, 0x6100), 5407 {} 5408 }; 5409 static const struct coef_fw coef0233[] = { 5410 WRITE_COEF(0x06, 0x2100), 5411 WRITE_COEF(0x32, 0x4ea3), 5412 {} 5413 }; 5414 static const struct coef_fw coef0288[] = { 5415 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */ 5416 UPDATE_COEF(0x50, 0x2000, 0x2000), 5417 UPDATE_COEF(0x56, 0x0006, 0x0006), 5418 UPDATE_COEF(0x66, 0x0008, 0), 5419 UPDATE_COEF(0x67, 0x2000, 0), 5420 {} 5421 }; 5422 static const struct coef_fw coef0292[] = { 5423 WRITE_COEF(0x76, 0x000e), 5424 WRITE_COEF(0x6c, 0x2400), 5425 WRITE_COEF(0x6b, 0xc429), 5426 WRITE_COEF(0x18, 0x7308), 5427 {} 5428 }; 5429 static const struct coef_fw coef0293[] = { 5430 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */ 5431 WRITE_COEF(0x45, 0xC429), /* Set to TRS type */ 5432 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */ 5433 {} 5434 }; 5435 static const struct coef_fw coef0688[] = { 5436 WRITE_COEF(0x11, 0x0041), 5437 WRITE_COEF(0x15, 0x0d40), 5438 WRITE_COEF(0xb7, 0x802b), 5439 {} 5440 }; 5441 static const struct coef_fw coef0274[] = { 5442 WRITE_COEF(0x45, 0x4289), 5443 UPDATE_COEF(0x4a, 0x0010, 0x0010), 5444 UPDATE_COEF(0x6b, 0x0f00, 0), 5445 UPDATE_COEF(0x49, 0x0300, 0x0300), 5446 {} 5447 }; 5448 5449 switch (codec->core.vendor_id) { 5450 case 0x10ec0215: 5451 case 0x10ec0225: 5452 case 0x10ec0285: 5453 case 0x10ec0295: 5454 case 0x10ec0289: 5455 case 0x10ec0299: 5456 alc_process_coef_fw(codec, alc225_pre_hsmode); 5457 alc_process_coef_fw(codec, coef0225); 5458 alc_hp_enable_unmute(codec, 75); 5459 break; 5460 case 0x10ec0255: 5461 alc_process_coef_fw(codec, coef0255); 5462 break; 5463 case 0x10ec0230: 5464 case 0x10ec0236: 5465 case 0x10ec0256: 5466 case 0x19e58326: 5467 alc_write_coef_idx(codec, 0x1b, 0x0e4b); 5468 alc_write_coef_idx(codec, 0x45, 0xc089); 5469 msleep(50); 5470 alc_process_coef_fw(codec, coef0256); 5471 alc_hp_enable_unmute(codec, 75); 5472 break; 5473 case 0x10ec0234: 5474 case 0x10ec0274: 5475 case 0x10ec0294: 5476 alc_process_coef_fw(codec, coef0274); 5477 break; 5478 case 0x10ec0233: 5479 case 0x10ec0283: 5480 alc_process_coef_fw(codec, coef0233); 5481 break; 5482 case 0x10ec0286: 5483 case 0x10ec0288: 5484 case 0x10ec0298: 5485 alc_process_coef_fw(codec, coef0288); 5486 break; 5487 case 0x10ec0292: 5488 alc_process_coef_fw(codec, coef0292); 5489 break; 5490 case 0x10ec0293: 5491 alc_process_coef_fw(codec, coef0293); 5492 break; 5493 case 0x10ec0668: 5494 alc_process_coef_fw(codec, coef0688); 5495 break; 5496 case 0x10ec0867: 5497 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0); 5498 break; 5499 } 5500 codec_dbg(codec, "Headset jack set to headphone (default) mode.\n"); 5501 } 5502 5503 /* Iphone type */ 5504 static void alc_headset_mode_ctia(struct hda_codec *codec) 5505 { 5506 int val; 5507 5508 static const struct coef_fw coef0255[] = { 5509 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */ 5510 WRITE_COEF(0x1b, 0x0c2b), 5511 WRITE_COEFEX(0x57, 0x03, 0x8ea6), 5512 {} 5513 }; 5514 static const struct coef_fw coef0256[] = { 5515 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */ 5516 WRITE_COEF(0x1b, 0x0e6b), 5517 {} 5518 }; 5519 static const struct coef_fw coef0233[] = { 5520 WRITE_COEF(0x45, 0xd429), 5521 WRITE_COEF(0x1b, 0x0c2b), 5522 WRITE_COEF(0x32, 0x4ea3), 5523 {} 5524 }; 5525 static const struct coef_fw coef0288[] = { 5526 UPDATE_COEF(0x50, 0x2000, 0x2000), 5527 UPDATE_COEF(0x56, 0x0006, 0x0006), 5528 UPDATE_COEF(0x66, 0x0008, 0), 5529 UPDATE_COEF(0x67, 0x2000, 0), 5530 {} 5531 }; 5532 static const struct coef_fw coef0292[] = { 5533 WRITE_COEF(0x6b, 0xd429), 5534 WRITE_COEF(0x76, 0x0008), 5535 WRITE_COEF(0x18, 0x7388), 5536 {} 5537 }; 5538 static const struct coef_fw coef0293[] = { 5539 WRITE_COEF(0x45, 0xd429), /* Set to ctia type */ 5540 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */ 5541 {} 5542 }; 5543 static const struct coef_fw coef0688[] = { 5544 WRITE_COEF(0x11, 0x0001), 5545 WRITE_COEF(0x15, 0x0d60), 5546 WRITE_COEF(0xc3, 0x0000), 5547 {} 5548 }; 5549 static const struct coef_fw coef0225_1[] = { 5550 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10), 5551 UPDATE_COEF(0x63, 3<<14, 2<<14), 5552 {} 5553 }; 5554 static const struct coef_fw coef0225_2[] = { 5555 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10), 5556 UPDATE_COEF(0x63, 3<<14, 1<<14), 5557 {} 5558 }; 5559 5560 switch (codec->core.vendor_id) { 5561 case 0x10ec0255: 5562 alc_process_coef_fw(codec, coef0255); 5563 break; 5564 case 0x10ec0230: 5565 case 0x10ec0236: 5566 case 0x10ec0256: 5567 case 0x19e58326: 5568 alc_process_coef_fw(codec, coef0256); 5569 alc_hp_enable_unmute(codec, 75); 5570 break; 5571 case 0x10ec0234: 5572 case 0x10ec0274: 5573 case 0x10ec0294: 5574 alc_write_coef_idx(codec, 0x45, 0xd689); 5575 break; 5576 case 0x10ec0233: 5577 case 0x10ec0283: 5578 alc_process_coef_fw(codec, coef0233); 5579 break; 5580 case 0x10ec0298: 5581 val = alc_read_coef_idx(codec, 0x50); 5582 if (val & (1 << 12)) { 5583 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020); 5584 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400); 5585 msleep(300); 5586 } else { 5587 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010); 5588 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400); 5589 msleep(300); 5590 } 5591 break; 5592 case 0x10ec0286: 5593 case 0x10ec0288: 5594 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400); 5595 msleep(300); 5596 alc_process_coef_fw(codec, coef0288); 5597 break; 5598 case 0x10ec0292: 5599 alc_process_coef_fw(codec, coef0292); 5600 break; 5601 case 0x10ec0293: 5602 alc_process_coef_fw(codec, coef0293); 5603 break; 5604 case 0x10ec0668: 5605 alc_process_coef_fw(codec, coef0688); 5606 break; 5607 case 0x10ec0215: 5608 case 0x10ec0225: 5609 case 0x10ec0285: 5610 case 0x10ec0295: 5611 case 0x10ec0289: 5612 case 0x10ec0299: 5613 val = alc_read_coef_idx(codec, 0x45); 5614 if (val & (1 << 9)) 5615 alc_process_coef_fw(codec, coef0225_2); 5616 else 5617 alc_process_coef_fw(codec, coef0225_1); 5618 alc_hp_enable_unmute(codec, 75); 5619 break; 5620 case 0x10ec0867: 5621 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0); 5622 break; 5623 } 5624 codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n"); 5625 } 5626 5627 /* Nokia type */ 5628 static void alc_headset_mode_omtp(struct hda_codec *codec) 5629 { 5630 static const struct coef_fw coef0255[] = { 5631 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */ 5632 WRITE_COEF(0x1b, 0x0c2b), 5633 WRITE_COEFEX(0x57, 0x03, 0x8ea6), 5634 {} 5635 }; 5636 static const struct coef_fw coef0256[] = { 5637 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */ 5638 WRITE_COEF(0x1b, 0x0e6b), 5639 {} 5640 }; 5641 static const struct coef_fw coef0233[] = { 5642 WRITE_COEF(0x45, 0xe429), 5643 WRITE_COEF(0x1b, 0x0c2b), 5644 WRITE_COEF(0x32, 0x4ea3), 5645 {} 5646 }; 5647 static const struct coef_fw coef0288[] = { 5648 UPDATE_COEF(0x50, 0x2000, 0x2000), 5649 UPDATE_COEF(0x56, 0x0006, 0x0006), 5650 UPDATE_COEF(0x66, 0x0008, 0), 5651 UPDATE_COEF(0x67, 0x2000, 0), 5652 {} 5653 }; 5654 static const struct coef_fw coef0292[] = { 5655 WRITE_COEF(0x6b, 0xe429), 5656 WRITE_COEF(0x76, 0x0008), 5657 WRITE_COEF(0x18, 0x7388), 5658 {} 5659 }; 5660 static const struct coef_fw coef0293[] = { 5661 WRITE_COEF(0x45, 0xe429), /* Set to omtp type */ 5662 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */ 5663 {} 5664 }; 5665 static const struct coef_fw coef0688[] = { 5666 WRITE_COEF(0x11, 0x0001), 5667 WRITE_COEF(0x15, 0x0d50), 5668 WRITE_COEF(0xc3, 0x0000), 5669 {} 5670 }; 5671 static const struct coef_fw coef0225[] = { 5672 UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10), 5673 UPDATE_COEF(0x63, 3<<14, 2<<14), 5674 {} 5675 }; 5676 5677 switch (codec->core.vendor_id) { 5678 case 0x10ec0255: 5679 alc_process_coef_fw(codec, coef0255); 5680 break; 5681 case 0x10ec0230: 5682 case 0x10ec0236: 5683 case 0x10ec0256: 5684 case 0x19e58326: 5685 alc_process_coef_fw(codec, coef0256); 5686 alc_hp_enable_unmute(codec, 75); 5687 break; 5688 case 0x10ec0234: 5689 case 0x10ec0274: 5690 case 0x10ec0294: 5691 alc_write_coef_idx(codec, 0x45, 0xe689); 5692 break; 5693 case 0x10ec0233: 5694 case 0x10ec0283: 5695 alc_process_coef_fw(codec, coef0233); 5696 break; 5697 case 0x10ec0298: 5698 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */ 5699 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400); 5700 msleep(300); 5701 break; 5702 case 0x10ec0286: 5703 case 0x10ec0288: 5704 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400); 5705 msleep(300); 5706 alc_process_coef_fw(codec, coef0288); 5707 break; 5708 case 0x10ec0292: 5709 alc_process_coef_fw(codec, coef0292); 5710 break; 5711 case 0x10ec0293: 5712 alc_process_coef_fw(codec, coef0293); 5713 break; 5714 case 0x10ec0668: 5715 alc_process_coef_fw(codec, coef0688); 5716 break; 5717 case 0x10ec0215: 5718 case 0x10ec0225: 5719 case 0x10ec0285: 5720 case 0x10ec0295: 5721 case 0x10ec0289: 5722 case 0x10ec0299: 5723 alc_process_coef_fw(codec, coef0225); 5724 alc_hp_enable_unmute(codec, 75); 5725 break; 5726 } 5727 codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n"); 5728 } 5729 5730 static void alc_determine_headset_type(struct hda_codec *codec) 5731 { 5732 int val; 5733 bool is_ctia = false; 5734 struct alc_spec *spec = codec->spec; 5735 static const struct coef_fw coef0255[] = { 5736 WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/ 5737 WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref 5738 conteol) */ 5739 {} 5740 }; 5741 static const struct coef_fw coef0288[] = { 5742 UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */ 5743 {} 5744 }; 5745 static const struct coef_fw coef0298[] = { 5746 UPDATE_COEF(0x50, 0x2000, 0x2000), 5747 UPDATE_COEF(0x56, 0x0006, 0x0006), 5748 UPDATE_COEF(0x66, 0x0008, 0), 5749 UPDATE_COEF(0x67, 0x2000, 0), 5750 UPDATE_COEF(0x19, 0x1300, 0x1300), 5751 {} 5752 }; 5753 static const struct coef_fw coef0293[] = { 5754 UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */ 5755 WRITE_COEF(0x45, 0xD429), /* Set to ctia type */ 5756 {} 5757 }; 5758 static const struct coef_fw coef0688[] = { 5759 WRITE_COEF(0x11, 0x0001), 5760 WRITE_COEF(0xb7, 0x802b), 5761 WRITE_COEF(0x15, 0x0d60), 5762 WRITE_COEF(0xc3, 0x0c00), 5763 {} 5764 }; 5765 static const struct coef_fw coef0274[] = { 5766 UPDATE_COEF(0x4a, 0x0010, 0), 5767 UPDATE_COEF(0x4a, 0x8000, 0), 5768 WRITE_COEF(0x45, 0xd289), 5769 UPDATE_COEF(0x49, 0x0300, 0x0300), 5770 {} 5771 }; 5772 5773 if (spec->no_internal_mic_pin) { 5774 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12); 5775 return; 5776 } 5777 5778 switch (codec->core.vendor_id) { 5779 case 0x10ec0255: 5780 alc_process_coef_fw(codec, coef0255); 5781 msleep(300); 5782 val = alc_read_coef_idx(codec, 0x46); 5783 is_ctia = (val & 0x0070) == 0x0070; 5784 break; 5785 case 0x10ec0230: 5786 case 0x10ec0236: 5787 case 0x10ec0256: 5788 case 0x19e58326: 5789 alc_write_coef_idx(codec, 0x1b, 0x0e4b); 5790 alc_write_coef_idx(codec, 0x06, 0x6104); 5791 alc_write_coefex_idx(codec, 0x57, 0x3, 0x09a3); 5792 5793 alc_process_coef_fw(codec, coef0255); 5794 msleep(300); 5795 val = alc_read_coef_idx(codec, 0x46); 5796 is_ctia = (val & 0x0070) == 0x0070; 5797 if (!is_ctia) { 5798 alc_write_coef_idx(codec, 0x45, 0xe089); 5799 msleep(100); 5800 val = alc_read_coef_idx(codec, 0x46); 5801 if ((val & 0x0070) == 0x0070) 5802 is_ctia = false; 5803 else 5804 is_ctia = true; 5805 } 5806 alc_write_coefex_idx(codec, 0x57, 0x3, 0x0da3); 5807 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0); 5808 break; 5809 case 0x10ec0234: 5810 case 0x10ec0274: 5811 case 0x10ec0294: 5812 alc_process_coef_fw(codec, coef0274); 5813 msleep(850); 5814 val = alc_read_coef_idx(codec, 0x46); 5815 is_ctia = (val & 0x00f0) == 0x00f0; 5816 break; 5817 case 0x10ec0233: 5818 case 0x10ec0283: 5819 alc_write_coef_idx(codec, 0x45, 0xd029); 5820 msleep(300); 5821 val = alc_read_coef_idx(codec, 0x46); 5822 is_ctia = (val & 0x0070) == 0x0070; 5823 break; 5824 case 0x10ec0298: 5825 snd_hda_codec_write(codec, 0x21, 0, 5826 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 5827 msleep(100); 5828 snd_hda_codec_write(codec, 0x21, 0, 5829 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 5830 msleep(200); 5831 5832 val = alc_read_coef_idx(codec, 0x50); 5833 if (val & (1 << 12)) { 5834 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020); 5835 alc_process_coef_fw(codec, coef0288); 5836 msleep(350); 5837 val = alc_read_coef_idx(codec, 0x50); 5838 is_ctia = (val & 0x0070) == 0x0070; 5839 } else { 5840 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010); 5841 alc_process_coef_fw(codec, coef0288); 5842 msleep(350); 5843 val = alc_read_coef_idx(codec, 0x50); 5844 is_ctia = (val & 0x0070) == 0x0070; 5845 } 5846 alc_process_coef_fw(codec, coef0298); 5847 snd_hda_codec_write(codec, 0x21, 0, 5848 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP); 5849 msleep(75); 5850 snd_hda_codec_write(codec, 0x21, 0, 5851 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 5852 break; 5853 case 0x10ec0286: 5854 case 0x10ec0288: 5855 alc_process_coef_fw(codec, coef0288); 5856 msleep(350); 5857 val = alc_read_coef_idx(codec, 0x50); 5858 is_ctia = (val & 0x0070) == 0x0070; 5859 break; 5860 case 0x10ec0292: 5861 alc_write_coef_idx(codec, 0x6b, 0xd429); 5862 msleep(300); 5863 val = alc_read_coef_idx(codec, 0x6c); 5864 is_ctia = (val & 0x001c) == 0x001c; 5865 break; 5866 case 0x10ec0293: 5867 alc_process_coef_fw(codec, coef0293); 5868 msleep(300); 5869 val = alc_read_coef_idx(codec, 0x46); 5870 is_ctia = (val & 0x0070) == 0x0070; 5871 break; 5872 case 0x10ec0668: 5873 alc_process_coef_fw(codec, coef0688); 5874 msleep(300); 5875 val = alc_read_coef_idx(codec, 0xbe); 5876 is_ctia = (val & 0x1c02) == 0x1c02; 5877 break; 5878 case 0x10ec0215: 5879 case 0x10ec0225: 5880 case 0x10ec0285: 5881 case 0x10ec0295: 5882 case 0x10ec0289: 5883 case 0x10ec0299: 5884 alc_process_coef_fw(codec, alc225_pre_hsmode); 5885 alc_update_coef_idx(codec, 0x67, 0xf000, 0x1000); 5886 val = alc_read_coef_idx(codec, 0x45); 5887 if (val & (1 << 9)) { 5888 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10); 5889 alc_update_coef_idx(codec, 0x49, 3<<8, 2<<8); 5890 msleep(800); 5891 val = alc_read_coef_idx(codec, 0x46); 5892 is_ctia = (val & 0x00f0) == 0x00f0; 5893 } else { 5894 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10); 5895 alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8); 5896 msleep(800); 5897 val = alc_read_coef_idx(codec, 0x46); 5898 is_ctia = (val & 0x00f0) == 0x00f0; 5899 } 5900 if (!is_ctia) { 5901 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x38<<10); 5902 alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8); 5903 msleep(100); 5904 val = alc_read_coef_idx(codec, 0x46); 5905 if ((val & 0x00f0) == 0x00f0) 5906 is_ctia = false; 5907 else 5908 is_ctia = true; 5909 } 5910 alc_update_coef_idx(codec, 0x4a, 7<<6, 7<<6); 5911 alc_update_coef_idx(codec, 0x4a, 3<<4, 3<<4); 5912 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000); 5913 break; 5914 case 0x10ec0867: 5915 is_ctia = true; 5916 break; 5917 } 5918 5919 codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n", 5920 is_ctia ? "yes" : "no"); 5921 spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP; 5922 } 5923 5924 static void alc_update_headset_mode(struct hda_codec *codec) 5925 { 5926 struct alc_spec *spec = codec->spec; 5927 5928 hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]]; 5929 hda_nid_t hp_pin = alc_get_hp_pin(spec); 5930 5931 int new_headset_mode; 5932 5933 if (!snd_hda_jack_detect(codec, hp_pin)) 5934 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED; 5935 else if (mux_pin == spec->headset_mic_pin) 5936 new_headset_mode = ALC_HEADSET_MODE_HEADSET; 5937 else if (mux_pin == spec->headphone_mic_pin) 5938 new_headset_mode = ALC_HEADSET_MODE_MIC; 5939 else 5940 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE; 5941 5942 if (new_headset_mode == spec->current_headset_mode) { 5943 snd_hda_gen_update_outputs(codec); 5944 return; 5945 } 5946 5947 switch (new_headset_mode) { 5948 case ALC_HEADSET_MODE_UNPLUGGED: 5949 alc_headset_mode_unplugged(codec); 5950 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN; 5951 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN; 5952 spec->gen.hp_jack_present = false; 5953 break; 5954 case ALC_HEADSET_MODE_HEADSET: 5955 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN) 5956 alc_determine_headset_type(codec); 5957 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA) 5958 alc_headset_mode_ctia(codec); 5959 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP) 5960 alc_headset_mode_omtp(codec); 5961 spec->gen.hp_jack_present = true; 5962 break; 5963 case ALC_HEADSET_MODE_MIC: 5964 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin); 5965 spec->gen.hp_jack_present = false; 5966 break; 5967 case ALC_HEADSET_MODE_HEADPHONE: 5968 alc_headset_mode_default(codec); 5969 spec->gen.hp_jack_present = true; 5970 break; 5971 } 5972 if (new_headset_mode != ALC_HEADSET_MODE_MIC) { 5973 snd_hda_set_pin_ctl_cache(codec, hp_pin, 5974 AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN); 5975 if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin) 5976 snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin, 5977 PIN_VREFHIZ); 5978 } 5979 spec->current_headset_mode = new_headset_mode; 5980 5981 snd_hda_gen_update_outputs(codec); 5982 } 5983 5984 static void alc_update_headset_mode_hook(struct hda_codec *codec, 5985 struct snd_kcontrol *kcontrol, 5986 struct snd_ctl_elem_value *ucontrol) 5987 { 5988 alc_update_headset_mode(codec); 5989 } 5990 5991 static void alc_update_headset_jack_cb(struct hda_codec *codec, 5992 struct hda_jack_callback *jack) 5993 { 5994 snd_hda_gen_hp_automute(codec, jack); 5995 alc_update_headset_mode(codec); 5996 } 5997 5998 static void alc_probe_headset_mode(struct hda_codec *codec) 5999 { 6000 int i; 6001 struct alc_spec *spec = codec->spec; 6002 struct auto_pin_cfg *cfg = &spec->gen.autocfg; 6003 6004 /* Find mic pins */ 6005 for (i = 0; i < cfg->num_inputs; i++) { 6006 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin) 6007 spec->headset_mic_pin = cfg->inputs[i].pin; 6008 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin) 6009 spec->headphone_mic_pin = cfg->inputs[i].pin; 6010 } 6011 6012 WARN_ON(spec->gen.cap_sync_hook); 6013 spec->gen.cap_sync_hook = alc_update_headset_mode_hook; 6014 spec->gen.automute_hook = alc_update_headset_mode; 6015 spec->gen.hp_automute_hook = alc_update_headset_jack_cb; 6016 } 6017 6018 static void alc_fixup_headset_mode(struct hda_codec *codec, 6019 const struct hda_fixup *fix, int action) 6020 { 6021 struct alc_spec *spec = codec->spec; 6022 6023 switch (action) { 6024 case HDA_FIXUP_ACT_PRE_PROBE: 6025 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC; 6026 break; 6027 case HDA_FIXUP_ACT_PROBE: 6028 alc_probe_headset_mode(codec); 6029 break; 6030 case HDA_FIXUP_ACT_INIT: 6031 if (is_s3_resume(codec) || is_s4_resume(codec)) { 6032 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN; 6033 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN; 6034 } 6035 alc_update_headset_mode(codec); 6036 break; 6037 } 6038 } 6039 6040 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec, 6041 const struct hda_fixup *fix, int action) 6042 { 6043 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6044 struct alc_spec *spec = codec->spec; 6045 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 6046 } 6047 else 6048 alc_fixup_headset_mode(codec, fix, action); 6049 } 6050 6051 static void alc255_set_default_jack_type(struct hda_codec *codec) 6052 { 6053 /* Set to iphone type */ 6054 static const struct coef_fw alc255fw[] = { 6055 WRITE_COEF(0x1b, 0x880b), 6056 WRITE_COEF(0x45, 0xd089), 6057 WRITE_COEF(0x1b, 0x080b), 6058 WRITE_COEF(0x46, 0x0004), 6059 WRITE_COEF(0x1b, 0x0c0b), 6060 {} 6061 }; 6062 static const struct coef_fw alc256fw[] = { 6063 WRITE_COEF(0x1b, 0x884b), 6064 WRITE_COEF(0x45, 0xd089), 6065 WRITE_COEF(0x1b, 0x084b), 6066 WRITE_COEF(0x46, 0x0004), 6067 WRITE_COEF(0x1b, 0x0c4b), 6068 {} 6069 }; 6070 switch (codec->core.vendor_id) { 6071 case 0x10ec0255: 6072 alc_process_coef_fw(codec, alc255fw); 6073 break; 6074 case 0x10ec0230: 6075 case 0x10ec0236: 6076 case 0x10ec0256: 6077 case 0x19e58326: 6078 alc_process_coef_fw(codec, alc256fw); 6079 break; 6080 } 6081 msleep(30); 6082 } 6083 6084 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec, 6085 const struct hda_fixup *fix, int action) 6086 { 6087 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6088 alc255_set_default_jack_type(codec); 6089 } 6090 alc_fixup_headset_mode(codec, fix, action); 6091 } 6092 6093 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec, 6094 const struct hda_fixup *fix, int action) 6095 { 6096 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6097 struct alc_spec *spec = codec->spec; 6098 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 6099 alc255_set_default_jack_type(codec); 6100 } 6101 else 6102 alc_fixup_headset_mode(codec, fix, action); 6103 } 6104 6105 static void alc288_update_headset_jack_cb(struct hda_codec *codec, 6106 struct hda_jack_callback *jack) 6107 { 6108 struct alc_spec *spec = codec->spec; 6109 6110 alc_update_headset_jack_cb(codec, jack); 6111 /* Headset Mic enable or disable, only for Dell Dino */ 6112 alc_update_gpio_data(codec, 0x40, spec->gen.hp_jack_present); 6113 } 6114 6115 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec, 6116 const struct hda_fixup *fix, int action) 6117 { 6118 alc_fixup_headset_mode(codec, fix, action); 6119 if (action == HDA_FIXUP_ACT_PROBE) { 6120 struct alc_spec *spec = codec->spec; 6121 /* toggled via hp_automute_hook */ 6122 spec->gpio_mask |= 0x40; 6123 spec->gpio_dir |= 0x40; 6124 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb; 6125 } 6126 } 6127 6128 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec, 6129 const struct hda_fixup *fix, int action) 6130 { 6131 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6132 struct alc_spec *spec = codec->spec; 6133 spec->gen.auto_mute_via_amp = 1; 6134 } 6135 } 6136 6137 static void alc_fixup_no_shutup(struct hda_codec *codec, 6138 const struct hda_fixup *fix, int action) 6139 { 6140 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6141 struct alc_spec *spec = codec->spec; 6142 spec->no_shutup_pins = 1; 6143 } 6144 } 6145 6146 static void alc_fixup_disable_aamix(struct hda_codec *codec, 6147 const struct hda_fixup *fix, int action) 6148 { 6149 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6150 struct alc_spec *spec = codec->spec; 6151 /* Disable AA-loopback as it causes white noise */ 6152 spec->gen.mixer_nid = 0; 6153 } 6154 } 6155 6156 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */ 6157 static void alc_fixup_tpt440_dock(struct hda_codec *codec, 6158 const struct hda_fixup *fix, int action) 6159 { 6160 static const struct hda_pintbl pincfgs[] = { 6161 { 0x16, 0x21211010 }, /* dock headphone */ 6162 { 0x19, 0x21a11010 }, /* dock mic */ 6163 { } 6164 }; 6165 struct alc_spec *spec = codec->spec; 6166 6167 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6168 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 6169 codec->power_save_node = 0; /* avoid click noises */ 6170 snd_hda_apply_pincfgs(codec, pincfgs); 6171 } 6172 } 6173 6174 static void alc_fixup_tpt470_dock(struct hda_codec *codec, 6175 const struct hda_fixup *fix, int action) 6176 { 6177 static const struct hda_pintbl pincfgs[] = { 6178 { 0x17, 0x21211010 }, /* dock headphone */ 6179 { 0x19, 0x21a11010 }, /* dock mic */ 6180 { } 6181 }; 6182 struct alc_spec *spec = codec->spec; 6183 6184 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6185 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 6186 snd_hda_apply_pincfgs(codec, pincfgs); 6187 } else if (action == HDA_FIXUP_ACT_INIT) { 6188 /* Enable DOCK device */ 6189 snd_hda_codec_write(codec, 0x17, 0, 6190 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0); 6191 /* Enable DOCK device */ 6192 snd_hda_codec_write(codec, 0x19, 0, 6193 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0); 6194 } 6195 } 6196 6197 static void alc_fixup_tpt470_dacs(struct hda_codec *codec, 6198 const struct hda_fixup *fix, int action) 6199 { 6200 /* Assure the speaker pin to be coupled with DAC NID 0x03; otherwise 6201 * the speaker output becomes too low by some reason on Thinkpads with 6202 * ALC298 codec 6203 */ 6204 static const hda_nid_t preferred_pairs[] = { 6205 0x14, 0x03, 0x17, 0x02, 0x21, 0x02, 6206 0 6207 }; 6208 struct alc_spec *spec = codec->spec; 6209 6210 if (action == HDA_FIXUP_ACT_PRE_PROBE) 6211 spec->gen.preferred_dacs = preferred_pairs; 6212 } 6213 6214 static void alc295_fixup_asus_dacs(struct hda_codec *codec, 6215 const struct hda_fixup *fix, int action) 6216 { 6217 static const hda_nid_t preferred_pairs[] = { 6218 0x17, 0x02, 0x21, 0x03, 0 6219 }; 6220 struct alc_spec *spec = codec->spec; 6221 6222 if (action == HDA_FIXUP_ACT_PRE_PROBE) 6223 spec->gen.preferred_dacs = preferred_pairs; 6224 } 6225 6226 static void alc_shutup_dell_xps13(struct hda_codec *codec) 6227 { 6228 struct alc_spec *spec = codec->spec; 6229 int hp_pin = alc_get_hp_pin(spec); 6230 6231 /* Prevent pop noises when headphones are plugged in */ 6232 snd_hda_codec_write(codec, hp_pin, 0, 6233 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 6234 msleep(20); 6235 } 6236 6237 static void alc_fixup_dell_xps13(struct hda_codec *codec, 6238 const struct hda_fixup *fix, int action) 6239 { 6240 struct alc_spec *spec = codec->spec; 6241 struct hda_input_mux *imux = &spec->gen.input_mux; 6242 int i; 6243 6244 switch (action) { 6245 case HDA_FIXUP_ACT_PRE_PROBE: 6246 /* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise 6247 * it causes a click noise at start up 6248 */ 6249 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ); 6250 spec->shutup = alc_shutup_dell_xps13; 6251 break; 6252 case HDA_FIXUP_ACT_PROBE: 6253 /* Make the internal mic the default input source. */ 6254 for (i = 0; i < imux->num_items; i++) { 6255 if (spec->gen.imux_pins[i] == 0x12) { 6256 spec->gen.cur_mux[0] = i; 6257 break; 6258 } 6259 } 6260 break; 6261 } 6262 } 6263 6264 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec, 6265 const struct hda_fixup *fix, int action) 6266 { 6267 struct alc_spec *spec = codec->spec; 6268 6269 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6270 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 6271 spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */ 6272 6273 /* Disable boost for mic-in permanently. (This code is only called 6274 from quirks that guarantee that the headphone is at NID 0x1b.) */ 6275 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000); 6276 snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP); 6277 } else 6278 alc_fixup_headset_mode(codec, fix, action); 6279 } 6280 6281 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec, 6282 const struct hda_fixup *fix, int action) 6283 { 6284 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6285 alc_write_coef_idx(codec, 0xc4, 0x8000); 6286 alc_update_coef_idx(codec, 0xc2, ~0xfe, 0); 6287 snd_hda_set_pin_ctl_cache(codec, 0x18, 0); 6288 } 6289 alc_fixup_headset_mode(codec, fix, action); 6290 } 6291 6292 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */ 6293 static int find_ext_mic_pin(struct hda_codec *codec) 6294 { 6295 struct alc_spec *spec = codec->spec; 6296 struct auto_pin_cfg *cfg = &spec->gen.autocfg; 6297 hda_nid_t nid; 6298 unsigned int defcfg; 6299 int i; 6300 6301 for (i = 0; i < cfg->num_inputs; i++) { 6302 if (cfg->inputs[i].type != AUTO_PIN_MIC) 6303 continue; 6304 nid = cfg->inputs[i].pin; 6305 defcfg = snd_hda_codec_get_pincfg(codec, nid); 6306 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT) 6307 continue; 6308 return nid; 6309 } 6310 6311 return 0; 6312 } 6313 6314 static void alc271_hp_gate_mic_jack(struct hda_codec *codec, 6315 const struct hda_fixup *fix, 6316 int action) 6317 { 6318 struct alc_spec *spec = codec->spec; 6319 6320 if (action == HDA_FIXUP_ACT_PROBE) { 6321 int mic_pin = find_ext_mic_pin(codec); 6322 int hp_pin = alc_get_hp_pin(spec); 6323 6324 if (snd_BUG_ON(!mic_pin || !hp_pin)) 6325 return; 6326 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin); 6327 } 6328 } 6329 6330 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec, 6331 const struct hda_fixup *fix, 6332 int action) 6333 { 6334 struct alc_spec *spec = codec->spec; 6335 struct auto_pin_cfg *cfg = &spec->gen.autocfg; 6336 int i; 6337 6338 /* The mic boosts on level 2 and 3 are too noisy 6339 on the internal mic input. 6340 Therefore limit the boost to 0 or 1. */ 6341 6342 if (action != HDA_FIXUP_ACT_PROBE) 6343 return; 6344 6345 for (i = 0; i < cfg->num_inputs; i++) { 6346 hda_nid_t nid = cfg->inputs[i].pin; 6347 unsigned int defcfg; 6348 if (cfg->inputs[i].type != AUTO_PIN_MIC) 6349 continue; 6350 defcfg = snd_hda_codec_get_pincfg(codec, nid); 6351 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT) 6352 continue; 6353 6354 snd_hda_override_amp_caps(codec, nid, HDA_INPUT, 6355 (0x00 << AC_AMPCAP_OFFSET_SHIFT) | 6356 (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) | 6357 (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) | 6358 (0 << AC_AMPCAP_MUTE_SHIFT)); 6359 } 6360 } 6361 6362 static void alc283_hp_automute_hook(struct hda_codec *codec, 6363 struct hda_jack_callback *jack) 6364 { 6365 struct alc_spec *spec = codec->spec; 6366 int vref; 6367 6368 msleep(200); 6369 snd_hda_gen_hp_automute(codec, jack); 6370 6371 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0; 6372 6373 msleep(600); 6374 snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 6375 vref); 6376 } 6377 6378 static void alc283_fixup_chromebook(struct hda_codec *codec, 6379 const struct hda_fixup *fix, int action) 6380 { 6381 struct alc_spec *spec = codec->spec; 6382 6383 switch (action) { 6384 case HDA_FIXUP_ACT_PRE_PROBE: 6385 snd_hda_override_wcaps(codec, 0x03, 0); 6386 /* Disable AA-loopback as it causes white noise */ 6387 spec->gen.mixer_nid = 0; 6388 break; 6389 case HDA_FIXUP_ACT_INIT: 6390 /* MIC2-VREF control */ 6391 /* Set to manual mode */ 6392 alc_update_coef_idx(codec, 0x06, 0x000c, 0); 6393 /* Enable Line1 input control by verb */ 6394 alc_update_coef_idx(codec, 0x1a, 0, 1 << 4); 6395 break; 6396 } 6397 } 6398 6399 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec, 6400 const struct hda_fixup *fix, int action) 6401 { 6402 struct alc_spec *spec = codec->spec; 6403 6404 switch (action) { 6405 case HDA_FIXUP_ACT_PRE_PROBE: 6406 spec->gen.hp_automute_hook = alc283_hp_automute_hook; 6407 break; 6408 case HDA_FIXUP_ACT_INIT: 6409 /* MIC2-VREF control */ 6410 /* Set to manual mode */ 6411 alc_update_coef_idx(codec, 0x06, 0x000c, 0); 6412 break; 6413 } 6414 } 6415 6416 /* mute tablet speaker pin (0x14) via dock plugging in addition */ 6417 static void asus_tx300_automute(struct hda_codec *codec) 6418 { 6419 struct alc_spec *spec = codec->spec; 6420 snd_hda_gen_update_outputs(codec); 6421 if (snd_hda_jack_detect(codec, 0x1b)) 6422 spec->gen.mute_bits |= (1ULL << 0x14); 6423 } 6424 6425 static void alc282_fixup_asus_tx300(struct hda_codec *codec, 6426 const struct hda_fixup *fix, int action) 6427 { 6428 struct alc_spec *spec = codec->spec; 6429 static const struct hda_pintbl dock_pins[] = { 6430 { 0x1b, 0x21114000 }, /* dock speaker pin */ 6431 {} 6432 }; 6433 6434 switch (action) { 6435 case HDA_FIXUP_ACT_PRE_PROBE: 6436 spec->init_amp = ALC_INIT_DEFAULT; 6437 /* TX300 needs to set up GPIO2 for the speaker amp */ 6438 alc_setup_gpio(codec, 0x04); 6439 snd_hda_apply_pincfgs(codec, dock_pins); 6440 spec->gen.auto_mute_via_amp = 1; 6441 spec->gen.automute_hook = asus_tx300_automute; 6442 snd_hda_jack_detect_enable_callback(codec, 0x1b, 6443 snd_hda_gen_hp_automute); 6444 break; 6445 case HDA_FIXUP_ACT_PROBE: 6446 spec->init_amp = ALC_INIT_DEFAULT; 6447 break; 6448 case HDA_FIXUP_ACT_BUILD: 6449 /* this is a bit tricky; give more sane names for the main 6450 * (tablet) speaker and the dock speaker, respectively 6451 */ 6452 rename_ctl(codec, "Speaker Playback Switch", 6453 "Dock Speaker Playback Switch"); 6454 rename_ctl(codec, "Bass Speaker Playback Switch", 6455 "Speaker Playback Switch"); 6456 break; 6457 } 6458 } 6459 6460 static void alc290_fixup_mono_speakers(struct hda_codec *codec, 6461 const struct hda_fixup *fix, int action) 6462 { 6463 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6464 /* DAC node 0x03 is giving mono output. We therefore want to 6465 make sure 0x14 (front speaker) and 0x15 (headphones) use the 6466 stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */ 6467 static const hda_nid_t conn1[] = { 0x0c }; 6468 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1); 6469 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1); 6470 } 6471 } 6472 6473 static void alc298_fixup_speaker_volume(struct hda_codec *codec, 6474 const struct hda_fixup *fix, int action) 6475 { 6476 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6477 /* The speaker is routed to the Node 0x06 by a mistake, as a result 6478 we can't adjust the speaker's volume since this node does not has 6479 Amp-out capability. we change the speaker's route to: 6480 Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 ( 6481 Pin Complex), since Node 0x02 has Amp-out caps, we can adjust 6482 speaker's volume now. */ 6483 6484 static const hda_nid_t conn1[] = { 0x0c }; 6485 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn1), conn1); 6486 } 6487 } 6488 6489 /* disable DAC3 (0x06) selection on NID 0x17 as it has no volume amp control */ 6490 static void alc295_fixup_disable_dac3(struct hda_codec *codec, 6491 const struct hda_fixup *fix, int action) 6492 { 6493 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6494 static const hda_nid_t conn[] = { 0x02, 0x03 }; 6495 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 6496 } 6497 } 6498 6499 /* force NID 0x17 (Bass Speaker) to DAC1 to share it with the main speaker */ 6500 static void alc285_fixup_speaker2_to_dac1(struct hda_codec *codec, 6501 const struct hda_fixup *fix, int action) 6502 { 6503 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6504 static const hda_nid_t conn[] = { 0x02 }; 6505 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 6506 } 6507 } 6508 6509 /* Hook to update amp GPIO4 for automute */ 6510 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec, 6511 struct hda_jack_callback *jack) 6512 { 6513 struct alc_spec *spec = codec->spec; 6514 6515 snd_hda_gen_hp_automute(codec, jack); 6516 /* mute_led_polarity is set to 0, so we pass inverted value here */ 6517 alc_update_gpio_led(codec, 0x10, spec->mute_led_polarity, 6518 !spec->gen.hp_jack_present); 6519 } 6520 6521 /* Manage GPIOs for HP EliteBook Folio 9480m. 6522 * 6523 * GPIO4 is the headphone amplifier power control 6524 * GPIO3 is the audio output mute indicator LED 6525 */ 6526 6527 static void alc280_fixup_hp_9480m(struct hda_codec *codec, 6528 const struct hda_fixup *fix, 6529 int action) 6530 { 6531 struct alc_spec *spec = codec->spec; 6532 6533 alc_fixup_hp_gpio_led(codec, action, 0x08, 0); 6534 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6535 /* amp at GPIO4; toggled via alc280_hp_gpio4_automute_hook() */ 6536 spec->gpio_mask |= 0x10; 6537 spec->gpio_dir |= 0x10; 6538 spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook; 6539 } 6540 } 6541 6542 static void alc275_fixup_gpio4_off(struct hda_codec *codec, 6543 const struct hda_fixup *fix, 6544 int action) 6545 { 6546 struct alc_spec *spec = codec->spec; 6547 6548 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6549 spec->gpio_mask |= 0x04; 6550 spec->gpio_dir |= 0x04; 6551 /* set data bit low */ 6552 } 6553 } 6554 6555 /* Quirk for Thinkpad X1 7th and 8th Gen 6556 * The following fixed routing needed 6557 * DAC1 (NID 0x02) -> Speaker (NID 0x14); some eq applied secretly 6558 * DAC2 (NID 0x03) -> Bass (NID 0x17) & Headphone (NID 0x21); sharing a DAC 6559 * DAC3 (NID 0x06) -> Unused, due to the lack of volume amp 6560 */ 6561 static void alc285_fixup_thinkpad_x1_gen7(struct hda_codec *codec, 6562 const struct hda_fixup *fix, int action) 6563 { 6564 static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */ 6565 static const hda_nid_t preferred_pairs[] = { 6566 0x14, 0x02, 0x17, 0x03, 0x21, 0x03, 0 6567 }; 6568 struct alc_spec *spec = codec->spec; 6569 6570 switch (action) { 6571 case HDA_FIXUP_ACT_PRE_PROBE: 6572 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 6573 spec->gen.preferred_dacs = preferred_pairs; 6574 break; 6575 case HDA_FIXUP_ACT_BUILD: 6576 /* The generic parser creates somewhat unintuitive volume ctls 6577 * with the fixed routing above, and the shared DAC2 may be 6578 * confusing for PA. 6579 * Rename those to unique names so that PA doesn't touch them 6580 * and use only Master volume. 6581 */ 6582 rename_ctl(codec, "Front Playback Volume", "DAC1 Playback Volume"); 6583 rename_ctl(codec, "Bass Speaker Playback Volume", "DAC2 Playback Volume"); 6584 break; 6585 } 6586 } 6587 6588 static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec, 6589 const struct hda_fixup *fix, 6590 int action) 6591 { 6592 alc_fixup_dual_codecs(codec, fix, action); 6593 switch (action) { 6594 case HDA_FIXUP_ACT_PRE_PROBE: 6595 /* override card longname to provide a unique UCM profile */ 6596 strcpy(codec->card->longname, "HDAudio-Lenovo-DualCodecs"); 6597 break; 6598 case HDA_FIXUP_ACT_BUILD: 6599 /* rename Capture controls depending on the codec */ 6600 rename_ctl(codec, "Capture Volume", 6601 codec->addr == 0 ? 6602 "Rear-Panel Capture Volume" : 6603 "Front-Panel Capture Volume"); 6604 rename_ctl(codec, "Capture Switch", 6605 codec->addr == 0 ? 6606 "Rear-Panel Capture Switch" : 6607 "Front-Panel Capture Switch"); 6608 break; 6609 } 6610 } 6611 6612 static void alc225_fixup_s3_pop_noise(struct hda_codec *codec, 6613 const struct hda_fixup *fix, int action) 6614 { 6615 if (action != HDA_FIXUP_ACT_PRE_PROBE) 6616 return; 6617 6618 codec->power_save_node = 1; 6619 } 6620 6621 /* Forcibly assign NID 0x03 to HP/LO while NID 0x02 to SPK for EQ */ 6622 static void alc274_fixup_bind_dacs(struct hda_codec *codec, 6623 const struct hda_fixup *fix, int action) 6624 { 6625 struct alc_spec *spec = codec->spec; 6626 static const hda_nid_t preferred_pairs[] = { 6627 0x21, 0x03, 0x1b, 0x03, 0x16, 0x02, 6628 0 6629 }; 6630 6631 if (action != HDA_FIXUP_ACT_PRE_PROBE) 6632 return; 6633 6634 spec->gen.preferred_dacs = preferred_pairs; 6635 spec->gen.auto_mute_via_amp = 1; 6636 codec->power_save_node = 0; 6637 } 6638 6639 /* avoid DAC 0x06 for bass speaker 0x17; it has no volume control */ 6640 static void alc289_fixup_asus_ga401(struct hda_codec *codec, 6641 const struct hda_fixup *fix, int action) 6642 { 6643 static const hda_nid_t preferred_pairs[] = { 6644 0x14, 0x02, 0x17, 0x02, 0x21, 0x03, 0 6645 }; 6646 struct alc_spec *spec = codec->spec; 6647 6648 if (action == HDA_FIXUP_ACT_PRE_PROBE) 6649 spec->gen.preferred_dacs = preferred_pairs; 6650 } 6651 6652 /* The DAC of NID 0x3 will introduce click/pop noise on headphones, so invalidate it */ 6653 static void alc285_fixup_invalidate_dacs(struct hda_codec *codec, 6654 const struct hda_fixup *fix, int action) 6655 { 6656 if (action != HDA_FIXUP_ACT_PRE_PROBE) 6657 return; 6658 6659 snd_hda_override_wcaps(codec, 0x03, 0); 6660 } 6661 6662 static void alc_combo_jack_hp_jd_restart(struct hda_codec *codec) 6663 { 6664 switch (codec->core.vendor_id) { 6665 case 0x10ec0274: 6666 case 0x10ec0294: 6667 case 0x10ec0225: 6668 case 0x10ec0295: 6669 case 0x10ec0299: 6670 alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */ 6671 alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15); 6672 break; 6673 case 0x10ec0230: 6674 case 0x10ec0235: 6675 case 0x10ec0236: 6676 case 0x10ec0255: 6677 case 0x10ec0256: 6678 case 0x10ec0257: 6679 case 0x19e58326: 6680 alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */ 6681 alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15); 6682 break; 6683 } 6684 } 6685 6686 static void alc295_fixup_chromebook(struct hda_codec *codec, 6687 const struct hda_fixup *fix, int action) 6688 { 6689 struct alc_spec *spec = codec->spec; 6690 6691 switch (action) { 6692 case HDA_FIXUP_ACT_PRE_PROBE: 6693 spec->ultra_low_power = true; 6694 break; 6695 case HDA_FIXUP_ACT_INIT: 6696 alc_combo_jack_hp_jd_restart(codec); 6697 break; 6698 } 6699 } 6700 6701 static void alc256_fixup_chromebook(struct hda_codec *codec, 6702 const struct hda_fixup *fix, int action) 6703 { 6704 struct alc_spec *spec = codec->spec; 6705 6706 switch (action) { 6707 case HDA_FIXUP_ACT_PRE_PROBE: 6708 spec->gen.suppress_auto_mute = 1; 6709 spec->gen.suppress_auto_mic = 1; 6710 spec->en_3kpull_low = false; 6711 break; 6712 } 6713 } 6714 6715 static void alc_fixup_disable_mic_vref(struct hda_codec *codec, 6716 const struct hda_fixup *fix, int action) 6717 { 6718 if (action == HDA_FIXUP_ACT_PRE_PROBE) 6719 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ); 6720 } 6721 6722 6723 static void alc294_gx502_toggle_output(struct hda_codec *codec, 6724 struct hda_jack_callback *cb) 6725 { 6726 /* The Windows driver sets the codec up in a very different way where 6727 * it appears to leave 0x10 = 0x8a20 set. For Linux we need to toggle it 6728 */ 6729 if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT) 6730 alc_write_coef_idx(codec, 0x10, 0x8a20); 6731 else 6732 alc_write_coef_idx(codec, 0x10, 0x0a20); 6733 } 6734 6735 static void alc294_fixup_gx502_hp(struct hda_codec *codec, 6736 const struct hda_fixup *fix, int action) 6737 { 6738 /* Pin 0x21: headphones/headset mic */ 6739 if (!is_jack_detectable(codec, 0x21)) 6740 return; 6741 6742 switch (action) { 6743 case HDA_FIXUP_ACT_PRE_PROBE: 6744 snd_hda_jack_detect_enable_callback(codec, 0x21, 6745 alc294_gx502_toggle_output); 6746 break; 6747 case HDA_FIXUP_ACT_INIT: 6748 /* Make sure to start in a correct state, i.e. if 6749 * headphones have been plugged in before powering up the system 6750 */ 6751 alc294_gx502_toggle_output(codec, NULL); 6752 break; 6753 } 6754 } 6755 6756 static void alc294_gu502_toggle_output(struct hda_codec *codec, 6757 struct hda_jack_callback *cb) 6758 { 6759 /* Windows sets 0x10 to 0x8420 for Node 0x20 which is 6760 * responsible from changes between speakers and headphones 6761 */ 6762 if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT) 6763 alc_write_coef_idx(codec, 0x10, 0x8420); 6764 else 6765 alc_write_coef_idx(codec, 0x10, 0x0a20); 6766 } 6767 6768 static void alc294_fixup_gu502_hp(struct hda_codec *codec, 6769 const struct hda_fixup *fix, int action) 6770 { 6771 if (!is_jack_detectable(codec, 0x21)) 6772 return; 6773 6774 switch (action) { 6775 case HDA_FIXUP_ACT_PRE_PROBE: 6776 snd_hda_jack_detect_enable_callback(codec, 0x21, 6777 alc294_gu502_toggle_output); 6778 break; 6779 case HDA_FIXUP_ACT_INIT: 6780 alc294_gu502_toggle_output(codec, NULL); 6781 break; 6782 } 6783 } 6784 6785 static void alc285_fixup_hp_gpio_amp_init(struct hda_codec *codec, 6786 const struct hda_fixup *fix, int action) 6787 { 6788 if (action != HDA_FIXUP_ACT_INIT) 6789 return; 6790 6791 msleep(100); 6792 alc_write_coef_idx(codec, 0x65, 0x0); 6793 } 6794 6795 static void alc274_fixup_hp_headset_mic(struct hda_codec *codec, 6796 const struct hda_fixup *fix, int action) 6797 { 6798 switch (action) { 6799 case HDA_FIXUP_ACT_INIT: 6800 alc_combo_jack_hp_jd_restart(codec); 6801 break; 6802 } 6803 } 6804 6805 static void alc_fixup_no_int_mic(struct hda_codec *codec, 6806 const struct hda_fixup *fix, int action) 6807 { 6808 struct alc_spec *spec = codec->spec; 6809 6810 switch (action) { 6811 case HDA_FIXUP_ACT_PRE_PROBE: 6812 /* Mic RING SLEEVE swap for combo jack */ 6813 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12); 6814 spec->no_internal_mic_pin = true; 6815 break; 6816 case HDA_FIXUP_ACT_INIT: 6817 alc_combo_jack_hp_jd_restart(codec); 6818 break; 6819 } 6820 } 6821 6822 /* GPIO1 = amplifier on/off 6823 * GPIO3 = mic mute LED 6824 */ 6825 static void alc285_fixup_hp_spectre_x360_eb1(struct hda_codec *codec, 6826 const struct hda_fixup *fix, int action) 6827 { 6828 static const hda_nid_t conn[] = { 0x02 }; 6829 6830 struct alc_spec *spec = codec->spec; 6831 static const struct hda_pintbl pincfgs[] = { 6832 { 0x14, 0x90170110 }, /* front/high speakers */ 6833 { 0x17, 0x90170130 }, /* back/bass speakers */ 6834 { } 6835 }; 6836 6837 //enable micmute led 6838 alc_fixup_hp_gpio_led(codec, action, 0x00, 0x04); 6839 6840 switch (action) { 6841 case HDA_FIXUP_ACT_PRE_PROBE: 6842 spec->micmute_led_polarity = 1; 6843 /* needed for amp of back speakers */ 6844 spec->gpio_mask |= 0x01; 6845 spec->gpio_dir |= 0x01; 6846 snd_hda_apply_pincfgs(codec, pincfgs); 6847 /* share DAC to have unified volume control */ 6848 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn); 6849 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 6850 break; 6851 case HDA_FIXUP_ACT_INIT: 6852 /* need to toggle GPIO to enable the amp of back speakers */ 6853 alc_update_gpio_data(codec, 0x01, true); 6854 msleep(100); 6855 alc_update_gpio_data(codec, 0x01, false); 6856 break; 6857 } 6858 } 6859 6860 static void alc285_fixup_hp_spectre_x360(struct hda_codec *codec, 6861 const struct hda_fixup *fix, int action) 6862 { 6863 static const hda_nid_t conn[] = { 0x02 }; 6864 static const struct hda_pintbl pincfgs[] = { 6865 { 0x14, 0x90170110 }, /* rear speaker */ 6866 { } 6867 }; 6868 6869 switch (action) { 6870 case HDA_FIXUP_ACT_PRE_PROBE: 6871 snd_hda_apply_pincfgs(codec, pincfgs); 6872 /* force front speaker to DAC1 */ 6873 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 6874 break; 6875 } 6876 } 6877 6878 static void alc285_fixup_hp_envy_x360(struct hda_codec *codec, 6879 const struct hda_fixup *fix, 6880 int action) 6881 { 6882 static const struct coef_fw coefs[] = { 6883 WRITE_COEF(0x08, 0x6a0c), WRITE_COEF(0x0d, 0xa023), 6884 WRITE_COEF(0x10, 0x0320), WRITE_COEF(0x1a, 0x8c03), 6885 WRITE_COEF(0x25, 0x1800), WRITE_COEF(0x26, 0x003a), 6886 WRITE_COEF(0x28, 0x1dfe), WRITE_COEF(0x29, 0xb014), 6887 WRITE_COEF(0x2b, 0x1dfe), WRITE_COEF(0x37, 0xfe15), 6888 WRITE_COEF(0x38, 0x7909), WRITE_COEF(0x45, 0xd489), 6889 WRITE_COEF(0x46, 0x00f4), WRITE_COEF(0x4a, 0x21e0), 6890 WRITE_COEF(0x66, 0x03f0), WRITE_COEF(0x67, 0x1000), 6891 WRITE_COEF(0x6e, 0x1005), { } 6892 }; 6893 6894 static const struct hda_pintbl pincfgs[] = { 6895 { 0x12, 0xb7a60130 }, /* Internal microphone*/ 6896 { 0x14, 0x90170150 }, /* B&O soundbar speakers */ 6897 { 0x17, 0x90170153 }, /* Side speakers */ 6898 { 0x19, 0x03a11040 }, /* Headset microphone */ 6899 { } 6900 }; 6901 6902 switch (action) { 6903 case HDA_FIXUP_ACT_PRE_PROBE: 6904 snd_hda_apply_pincfgs(codec, pincfgs); 6905 6906 /* Fixes volume control problem for side speakers */ 6907 alc295_fixup_disable_dac3(codec, fix, action); 6908 6909 /* Fixes no sound from headset speaker */ 6910 snd_hda_codec_amp_stereo(codec, 0x21, HDA_OUTPUT, 0, -1, 0); 6911 6912 /* Auto-enable headset mic when plugged */ 6913 snd_hda_jack_set_gating_jack(codec, 0x19, 0x21); 6914 6915 /* Headset mic volume enhancement */ 6916 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREF50); 6917 break; 6918 case HDA_FIXUP_ACT_INIT: 6919 alc_process_coef_fw(codec, coefs); 6920 break; 6921 case HDA_FIXUP_ACT_BUILD: 6922 rename_ctl(codec, "Bass Speaker Playback Volume", 6923 "B&O-Tuned Playback Volume"); 6924 rename_ctl(codec, "Front Playback Switch", 6925 "B&O Soundbar Playback Switch"); 6926 rename_ctl(codec, "Bass Speaker Playback Switch", 6927 "Side Speaker Playback Switch"); 6928 break; 6929 } 6930 } 6931 6932 /* for hda_fixup_thinkpad_acpi() */ 6933 #include "thinkpad_helper.c" 6934 6935 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec, 6936 const struct hda_fixup *fix, int action) 6937 { 6938 alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */ 6939 hda_fixup_thinkpad_acpi(codec, fix, action); 6940 } 6941 6942 /* Fixup for Lenovo Legion 15IMHg05 speaker output on headset removal. */ 6943 static void alc287_fixup_legion_15imhg05_speakers(struct hda_codec *codec, 6944 const struct hda_fixup *fix, 6945 int action) 6946 { 6947 struct alc_spec *spec = codec->spec; 6948 6949 switch (action) { 6950 case HDA_FIXUP_ACT_PRE_PROBE: 6951 spec->gen.suppress_auto_mute = 1; 6952 break; 6953 } 6954 } 6955 6956 static void comp_acpi_device_notify(acpi_handle handle, u32 event, void *data) 6957 { 6958 struct hda_codec *cdc = data; 6959 struct alc_spec *spec = cdc->spec; 6960 6961 codec_info(cdc, "ACPI Notification %d\n", event); 6962 6963 hda_component_acpi_device_notify(&spec->comps, handle, event, data); 6964 } 6965 6966 static int comp_bind(struct device *dev) 6967 { 6968 struct hda_codec *cdc = dev_to_hda_codec(dev); 6969 struct alc_spec *spec = cdc->spec; 6970 int ret; 6971 6972 ret = hda_component_manager_bind(cdc, &spec->comps); 6973 if (ret) 6974 return ret; 6975 6976 return hda_component_manager_bind_acpi_notifications(cdc, 6977 &spec->comps, 6978 comp_acpi_device_notify, cdc); 6979 } 6980 6981 static void comp_unbind(struct device *dev) 6982 { 6983 struct hda_codec *cdc = dev_to_hda_codec(dev); 6984 struct alc_spec *spec = cdc->spec; 6985 6986 hda_component_manager_unbind_acpi_notifications(cdc, &spec->comps, comp_acpi_device_notify); 6987 hda_component_manager_unbind(cdc, &spec->comps); 6988 } 6989 6990 static const struct component_master_ops comp_master_ops = { 6991 .bind = comp_bind, 6992 .unbind = comp_unbind, 6993 }; 6994 6995 static void comp_generic_playback_hook(struct hda_pcm_stream *hinfo, struct hda_codec *cdc, 6996 struct snd_pcm_substream *sub, int action) 6997 { 6998 struct alc_spec *spec = cdc->spec; 6999 7000 hda_component_manager_playback_hook(&spec->comps, action); 7001 } 7002 7003 static void comp_generic_fixup(struct hda_codec *cdc, int action, const char *bus, 7004 const char *hid, const char *match_str, int count) 7005 { 7006 struct alc_spec *spec = cdc->spec; 7007 int ret; 7008 7009 switch (action) { 7010 case HDA_FIXUP_ACT_PRE_PROBE: 7011 ret = hda_component_manager_init(cdc, &spec->comps, count, bus, hid, 7012 match_str, &comp_master_ops); 7013 if (ret) 7014 return; 7015 7016 spec->gen.pcm_playback_hook = comp_generic_playback_hook; 7017 break; 7018 case HDA_FIXUP_ACT_FREE: 7019 hda_component_manager_free(&spec->comps, &comp_master_ops); 7020 break; 7021 } 7022 } 7023 7024 static void find_cirrus_companion_amps(struct hda_codec *cdc) 7025 { 7026 struct device *dev = hda_codec_dev(cdc); 7027 struct acpi_device *adev; 7028 struct fwnode_handle *fwnode __free(fwnode_handle) = NULL; 7029 const char *bus = NULL; 7030 static const struct { 7031 const char *hid; 7032 const char *name; 7033 } acpi_ids[] = {{ "CSC3554", "cs35l54-hda" }, 7034 { "CSC3556", "cs35l56-hda" }, 7035 { "CSC3557", "cs35l57-hda" }}; 7036 char *match; 7037 int i, count = 0, count_devindex = 0; 7038 7039 for (i = 0; i < ARRAY_SIZE(acpi_ids); ++i) { 7040 adev = acpi_dev_get_first_match_dev(acpi_ids[i].hid, NULL, -1); 7041 if (adev) 7042 break; 7043 } 7044 if (!adev) { 7045 codec_dbg(cdc, "Did not find ACPI entry for a Cirrus Amp\n"); 7046 return; 7047 } 7048 7049 count = i2c_acpi_client_count(adev); 7050 if (count > 0) { 7051 bus = "i2c"; 7052 } else { 7053 count = acpi_spi_count_resources(adev); 7054 if (count > 0) 7055 bus = "spi"; 7056 } 7057 7058 fwnode = fwnode_handle_get(acpi_fwnode_handle(adev)); 7059 acpi_dev_put(adev); 7060 7061 if (!bus) { 7062 codec_err(cdc, "Did not find any buses for %s\n", acpi_ids[i].hid); 7063 return; 7064 } 7065 7066 if (!fwnode) { 7067 codec_err(cdc, "Could not get fwnode for %s\n", acpi_ids[i].hid); 7068 return; 7069 } 7070 7071 /* 7072 * When available the cirrus,dev-index property is an accurate 7073 * count of the amps in a system and is used in preference to 7074 * the count of bus devices that can contain additional address 7075 * alias entries. 7076 */ 7077 count_devindex = fwnode_property_count_u32(fwnode, "cirrus,dev-index"); 7078 if (count_devindex > 0) 7079 count = count_devindex; 7080 7081 match = devm_kasprintf(dev, GFP_KERNEL, "-%%s:00-%s.%%d", acpi_ids[i].name); 7082 if (!match) 7083 return; 7084 codec_info(cdc, "Found %d %s on %s (%s)\n", count, acpi_ids[i].hid, bus, match); 7085 comp_generic_fixup(cdc, HDA_FIXUP_ACT_PRE_PROBE, bus, acpi_ids[i].hid, match, count); 7086 } 7087 7088 static void cs35l41_fixup_i2c_two(struct hda_codec *cdc, const struct hda_fixup *fix, int action) 7089 { 7090 comp_generic_fixup(cdc, action, "i2c", "CSC3551", "-%s:00-cs35l41-hda.%d", 2); 7091 } 7092 7093 static void cs35l41_fixup_i2c_four(struct hda_codec *cdc, const struct hda_fixup *fix, int action) 7094 { 7095 comp_generic_fixup(cdc, action, "i2c", "CSC3551", "-%s:00-cs35l41-hda.%d", 4); 7096 } 7097 7098 static void cs35l41_fixup_spi_two(struct hda_codec *codec, const struct hda_fixup *fix, int action) 7099 { 7100 comp_generic_fixup(codec, action, "spi", "CSC3551", "-%s:00-cs35l41-hda.%d", 2); 7101 } 7102 7103 static void cs35l41_fixup_spi_four(struct hda_codec *codec, const struct hda_fixup *fix, int action) 7104 { 7105 comp_generic_fixup(codec, action, "spi", "CSC3551", "-%s:00-cs35l41-hda.%d", 4); 7106 } 7107 7108 static void alc287_fixup_legion_16achg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix, 7109 int action) 7110 { 7111 comp_generic_fixup(cdc, action, "i2c", "CLSA0100", "-%s:00-cs35l41-hda.%d", 2); 7112 } 7113 7114 static void alc287_fixup_legion_16ithg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix, 7115 int action) 7116 { 7117 comp_generic_fixup(cdc, action, "i2c", "CLSA0101", "-%s:00-cs35l41-hda.%d", 2); 7118 } 7119 7120 static void alc285_fixup_asus_ga403u(struct hda_codec *cdc, const struct hda_fixup *fix, int action) 7121 { 7122 /* 7123 * The same SSID has been re-used in different hardware, they have 7124 * different codecs and the newer GA403U has a ALC285. 7125 */ 7126 if (cdc->core.vendor_id != 0x10ec0285) 7127 alc_fixup_inv_dmic(cdc, fix, action); 7128 } 7129 7130 static void tas2781_fixup_i2c(struct hda_codec *cdc, 7131 const struct hda_fixup *fix, int action) 7132 { 7133 comp_generic_fixup(cdc, action, "i2c", "TIAS2781", "-%s:00", 1); 7134 } 7135 7136 static void yoga7_14arb7_fixup_i2c(struct hda_codec *cdc, 7137 const struct hda_fixup *fix, int action) 7138 { 7139 comp_generic_fixup(cdc, action, "i2c", "INT8866", "-%s:00", 1); 7140 } 7141 7142 static void alc256_fixup_acer_sfg16_micmute_led(struct hda_codec *codec, 7143 const struct hda_fixup *fix, int action) 7144 { 7145 alc_fixup_hp_gpio_led(codec, action, 0, 0x04); 7146 } 7147 7148 7149 /* for alc295_fixup_hp_top_speakers */ 7150 #include "hp_x360_helper.c" 7151 7152 /* for alc285_fixup_ideapad_s740_coef() */ 7153 #include "ideapad_s740_helper.c" 7154 7155 static const struct coef_fw alc256_fixup_set_coef_defaults_coefs[] = { 7156 WRITE_COEF(0x10, 0x0020), WRITE_COEF(0x24, 0x0000), 7157 WRITE_COEF(0x26, 0x0000), WRITE_COEF(0x29, 0x3000), 7158 WRITE_COEF(0x37, 0xfe05), WRITE_COEF(0x45, 0x5089), 7159 {} 7160 }; 7161 7162 static void alc256_fixup_set_coef_defaults(struct hda_codec *codec, 7163 const struct hda_fixup *fix, 7164 int action) 7165 { 7166 /* 7167 * A certain other OS sets these coeffs to different values. On at least 7168 * one TongFang barebone these settings might survive even a cold 7169 * reboot. So to restore a clean slate the values are explicitly reset 7170 * to default here. Without this, the external microphone is always in a 7171 * plugged-in state, while the internal microphone is always in an 7172 * unplugged state, breaking the ability to use the internal microphone. 7173 */ 7174 alc_process_coef_fw(codec, alc256_fixup_set_coef_defaults_coefs); 7175 } 7176 7177 static const struct coef_fw alc233_fixup_no_audio_jack_coefs[] = { 7178 WRITE_COEF(0x1a, 0x9003), WRITE_COEF(0x1b, 0x0e2b), WRITE_COEF(0x37, 0xfe06), 7179 WRITE_COEF(0x38, 0x4981), WRITE_COEF(0x45, 0xd489), WRITE_COEF(0x46, 0x0074), 7180 WRITE_COEF(0x49, 0x0149), 7181 {} 7182 }; 7183 7184 static void alc233_fixup_no_audio_jack(struct hda_codec *codec, 7185 const struct hda_fixup *fix, 7186 int action) 7187 { 7188 /* 7189 * The audio jack input and output is not detected on the ASRock NUC Box 7190 * 1100 series when cold booting without this fix. Warm rebooting from a 7191 * certain other OS makes the audio functional, as COEF settings are 7192 * preserved in this case. This fix sets these altered COEF values as 7193 * the default. 7194 */ 7195 alc_process_coef_fw(codec, alc233_fixup_no_audio_jack_coefs); 7196 } 7197 7198 static void alc256_fixup_mic_no_presence_and_resume(struct hda_codec *codec, 7199 const struct hda_fixup *fix, 7200 int action) 7201 { 7202 /* 7203 * The Clevo NJ51CU comes either with the ALC293 or the ALC256 codec, 7204 * but uses the 0x8686 subproduct id in both cases. The ALC256 codec 7205 * needs an additional quirk for sound working after suspend and resume. 7206 */ 7207 if (codec->core.vendor_id == 0x10ec0256) { 7208 alc_update_coef_idx(codec, 0x10, 1<<9, 0); 7209 snd_hda_codec_set_pincfg(codec, 0x19, 0x04a11120); 7210 } else { 7211 snd_hda_codec_set_pincfg(codec, 0x1a, 0x04a1113c); 7212 } 7213 } 7214 7215 static void alc256_decrease_headphone_amp_val(struct hda_codec *codec, 7216 const struct hda_fixup *fix, int action) 7217 { 7218 u32 caps; 7219 u8 nsteps, offs; 7220 7221 if (action != HDA_FIXUP_ACT_PRE_PROBE) 7222 return; 7223 7224 caps = query_amp_caps(codec, 0x3, HDA_OUTPUT); 7225 nsteps = ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) - 10; 7226 offs = ((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT) - 10; 7227 caps &= ~AC_AMPCAP_NUM_STEPS & ~AC_AMPCAP_OFFSET; 7228 caps |= (nsteps << AC_AMPCAP_NUM_STEPS_SHIFT) | (offs << AC_AMPCAP_OFFSET_SHIFT); 7229 7230 if (snd_hda_override_amp_caps(codec, 0x3, HDA_OUTPUT, caps)) 7231 codec_warn(codec, "failed to override amp caps for NID 0x3\n"); 7232 } 7233 7234 static void alc_fixup_dell4_mic_no_presence_quiet(struct hda_codec *codec, 7235 const struct hda_fixup *fix, 7236 int action) 7237 { 7238 struct alc_spec *spec = codec->spec; 7239 struct hda_input_mux *imux = &spec->gen.input_mux; 7240 int i; 7241 7242 alc269_fixup_limit_int_mic_boost(codec, fix, action); 7243 7244 switch (action) { 7245 case HDA_FIXUP_ACT_PRE_PROBE: 7246 /** 7247 * Set the vref of pin 0x19 (Headset Mic) and pin 0x1b (Headphone Mic) 7248 * to Hi-Z to avoid pop noises at startup and when plugging and 7249 * unplugging headphones. 7250 */ 7251 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ); 7252 snd_hda_codec_set_pin_target(codec, 0x1b, PIN_VREFHIZ); 7253 break; 7254 case HDA_FIXUP_ACT_PROBE: 7255 /** 7256 * Make the internal mic (0x12) the default input source to 7257 * prevent pop noises on cold boot. 7258 */ 7259 for (i = 0; i < imux->num_items; i++) { 7260 if (spec->gen.imux_pins[i] == 0x12) { 7261 spec->gen.cur_mux[0] = i; 7262 break; 7263 } 7264 } 7265 break; 7266 } 7267 } 7268 7269 static void alc287_fixup_yoga9_14iap7_bass_spk_pin(struct hda_codec *codec, 7270 const struct hda_fixup *fix, int action) 7271 { 7272 /* 7273 * The Pin Complex 0x17 for the bass speakers is wrongly reported as 7274 * unconnected. 7275 */ 7276 static const struct hda_pintbl pincfgs[] = { 7277 { 0x17, 0x90170121 }, 7278 { } 7279 }; 7280 /* 7281 * Avoid DAC 0x06 and 0x08, as they have no volume controls. 7282 * DAC 0x02 and 0x03 would be fine. 7283 */ 7284 static const hda_nid_t conn[] = { 0x02, 0x03 }; 7285 /* 7286 * Prefer both speakerbar (0x14) and bass speakers (0x17) connected to DAC 0x02. 7287 * Headphones (0x21) are connected to DAC 0x03. 7288 */ 7289 static const hda_nid_t preferred_pairs[] = { 7290 0x14, 0x02, 7291 0x17, 0x02, 7292 0x21, 0x03, 7293 0 7294 }; 7295 struct alc_spec *spec = codec->spec; 7296 7297 switch (action) { 7298 case HDA_FIXUP_ACT_PRE_PROBE: 7299 snd_hda_apply_pincfgs(codec, pincfgs); 7300 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 7301 spec->gen.preferred_dacs = preferred_pairs; 7302 break; 7303 } 7304 } 7305 7306 static void alc295_fixup_dell_inspiron_top_speakers(struct hda_codec *codec, 7307 const struct hda_fixup *fix, int action) 7308 { 7309 static const struct hda_pintbl pincfgs[] = { 7310 { 0x14, 0x90170151 }, 7311 { 0x17, 0x90170150 }, 7312 { } 7313 }; 7314 static const hda_nid_t conn[] = { 0x02, 0x03 }; 7315 static const hda_nid_t preferred_pairs[] = { 7316 0x14, 0x02, 7317 0x17, 0x03, 7318 0x21, 0x02, 7319 0 7320 }; 7321 struct alc_spec *spec = codec->spec; 7322 7323 alc_fixup_no_shutup(codec, fix, action); 7324 7325 switch (action) { 7326 case HDA_FIXUP_ACT_PRE_PROBE: 7327 snd_hda_apply_pincfgs(codec, pincfgs); 7328 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 7329 spec->gen.preferred_dacs = preferred_pairs; 7330 break; 7331 } 7332 } 7333 7334 /* Forcibly assign NID 0x03 to HP while NID 0x02 to SPK */ 7335 static void alc287_fixup_bind_dacs(struct hda_codec *codec, 7336 const struct hda_fixup *fix, int action) 7337 { 7338 struct alc_spec *spec = codec->spec; 7339 static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */ 7340 static const hda_nid_t preferred_pairs[] = { 7341 0x17, 0x02, 0x21, 0x03, 0 7342 }; 7343 7344 if (action != HDA_FIXUP_ACT_PRE_PROBE) 7345 return; 7346 7347 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 7348 spec->gen.preferred_dacs = preferred_pairs; 7349 spec->gen.auto_mute_via_amp = 1; 7350 if (spec->gen.autocfg.speaker_pins[0] != 0x14) { 7351 snd_hda_codec_write_cache(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 7352 0x0); /* Make sure 0x14 was disable */ 7353 } 7354 } 7355 /* Fix none verb table of Headset Mic pin */ 7356 static void alc_fixup_headset_mic(struct hda_codec *codec, 7357 const struct hda_fixup *fix, int action) 7358 { 7359 struct alc_spec *spec = codec->spec; 7360 static const struct hda_pintbl pincfgs[] = { 7361 { 0x19, 0x03a1103c }, 7362 { } 7363 }; 7364 7365 switch (action) { 7366 case HDA_FIXUP_ACT_PRE_PROBE: 7367 snd_hda_apply_pincfgs(codec, pincfgs); 7368 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12); 7369 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 7370 break; 7371 } 7372 } 7373 7374 static void alc245_fixup_hp_spectre_x360_eu0xxx(struct hda_codec *codec, 7375 const struct hda_fixup *fix, int action) 7376 { 7377 /* 7378 * The Pin Complex 0x14 for the treble speakers is wrongly reported as 7379 * unconnected. 7380 * The Pin Complex 0x17 for the bass speakers has the lowest association 7381 * and sequence values so shift it up a bit to squeeze 0x14 in. 7382 */ 7383 static const struct hda_pintbl pincfgs[] = { 7384 { 0x14, 0x90170110 }, // top/treble 7385 { 0x17, 0x90170111 }, // bottom/bass 7386 { } 7387 }; 7388 7389 /* 7390 * Force DAC 0x02 for the bass speakers 0x17. 7391 */ 7392 static const hda_nid_t conn[] = { 0x02 }; 7393 7394 switch (action) { 7395 case HDA_FIXUP_ACT_PRE_PROBE: 7396 snd_hda_apply_pincfgs(codec, pincfgs); 7397 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 7398 break; 7399 } 7400 7401 cs35l41_fixup_i2c_two(codec, fix, action); 7402 alc245_fixup_hp_mute_led_coefbit(codec, fix, action); 7403 alc245_fixup_hp_gpio_led(codec, fix, action); 7404 } 7405 7406 /* some changes for Spectre x360 16, 2024 model */ 7407 static void alc245_fixup_hp_spectre_x360_16_aa0xxx(struct hda_codec *codec, 7408 const struct hda_fixup *fix, int action) 7409 { 7410 /* 7411 * The Pin Complex 0x14 for the treble speakers is wrongly reported as 7412 * unconnected. 7413 * The Pin Complex 0x17 for the bass speakers has the lowest association 7414 * and sequence values so shift it up a bit to squeeze 0x14 in. 7415 */ 7416 struct alc_spec *spec = codec->spec; 7417 static const struct hda_pintbl pincfgs[] = { 7418 { 0x14, 0x90170110 }, // top/treble 7419 { 0x17, 0x90170111 }, // bottom/bass 7420 { } 7421 }; 7422 7423 /* 7424 * Force DAC 0x02 for the bass speakers 0x17. 7425 */ 7426 static const hda_nid_t conn[] = { 0x02 }; 7427 7428 switch (action) { 7429 case HDA_FIXUP_ACT_PRE_PROBE: 7430 /* needed for amp of back speakers */ 7431 spec->gpio_mask |= 0x01; 7432 spec->gpio_dir |= 0x01; 7433 snd_hda_apply_pincfgs(codec, pincfgs); 7434 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 7435 break; 7436 case HDA_FIXUP_ACT_INIT: 7437 /* need to toggle GPIO to enable the amp of back speakers */ 7438 alc_update_gpio_data(codec, 0x01, true); 7439 msleep(100); 7440 alc_update_gpio_data(codec, 0x01, false); 7441 break; 7442 } 7443 7444 cs35l41_fixup_i2c_two(codec, fix, action); 7445 alc245_fixup_hp_mute_led_coefbit(codec, fix, action); 7446 alc245_fixup_hp_gpio_led(codec, fix, action); 7447 } 7448 7449 /* 7450 * ALC287 PCM hooks 7451 */ 7452 static void alc287_alc1318_playback_pcm_hook(struct hda_pcm_stream *hinfo, 7453 struct hda_codec *codec, 7454 struct snd_pcm_substream *substream, 7455 int action) 7456 { 7457 alc_write_coef_idx(codec, 0x10, 0x8806); /* Change MLK to GPIO3 */ 7458 switch (action) { 7459 case HDA_GEN_PCM_ACT_OPEN: 7460 alc_write_coefex_idx(codec, 0x5a, 0x00, 0x954f); /* write gpio3 to high */ 7461 break; 7462 case HDA_GEN_PCM_ACT_CLOSE: 7463 alc_write_coefex_idx(codec, 0x5a, 0x00, 0x554f); /* write gpio3 as default value */ 7464 break; 7465 } 7466 } 7467 7468 static void alc287_s4_power_gpio3_default(struct hda_codec *codec) 7469 { 7470 if (is_s4_suspend(codec)) { 7471 alc_write_coef_idx(codec, 0x10, 0x8806); /* Change MLK to GPIO3 */ 7472 alc_write_coefex_idx(codec, 0x5a, 0x00, 0x554f); /* write gpio3 as default value */ 7473 } 7474 } 7475 7476 static void alc287_fixup_lenovo_thinkpad_with_alc1318(struct hda_codec *codec, 7477 const struct hda_fixup *fix, int action) 7478 { 7479 struct alc_spec *spec = codec->spec; 7480 7481 if (action != HDA_FIXUP_ACT_PRE_PROBE) 7482 return; 7483 spec->power_hook = alc287_s4_power_gpio3_default; 7484 spec->gen.pcm_playback_hook = alc287_alc1318_playback_pcm_hook; 7485 } 7486 7487 7488 enum { 7489 ALC269_FIXUP_GPIO2, 7490 ALC269_FIXUP_SONY_VAIO, 7491 ALC275_FIXUP_SONY_VAIO_GPIO2, 7492 ALC269_FIXUP_DELL_M101Z, 7493 ALC269_FIXUP_SKU_IGNORE, 7494 ALC269_FIXUP_ASUS_G73JW, 7495 ALC269_FIXUP_ASUS_N7601ZM_PINS, 7496 ALC269_FIXUP_ASUS_N7601ZM, 7497 ALC269_FIXUP_LENOVO_EAPD, 7498 ALC275_FIXUP_SONY_HWEQ, 7499 ALC275_FIXUP_SONY_DISABLE_AAMIX, 7500 ALC271_FIXUP_DMIC, 7501 ALC269_FIXUP_PCM_44K, 7502 ALC269_FIXUP_STEREO_DMIC, 7503 ALC269_FIXUP_HEADSET_MIC, 7504 ALC269_FIXUP_QUANTA_MUTE, 7505 ALC269_FIXUP_LIFEBOOK, 7506 ALC269_FIXUP_LIFEBOOK_EXTMIC, 7507 ALC269_FIXUP_LIFEBOOK_HP_PIN, 7508 ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT, 7509 ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, 7510 ALC269_FIXUP_AMIC, 7511 ALC269_FIXUP_DMIC, 7512 ALC269VB_FIXUP_AMIC, 7513 ALC269VB_FIXUP_DMIC, 7514 ALC269_FIXUP_HP_MUTE_LED, 7515 ALC269_FIXUP_HP_MUTE_LED_MIC1, 7516 ALC269_FIXUP_HP_MUTE_LED_MIC2, 7517 ALC269_FIXUP_HP_MUTE_LED_MIC3, 7518 ALC269_FIXUP_HP_GPIO_LED, 7519 ALC269_FIXUP_HP_GPIO_MIC1_LED, 7520 ALC269_FIXUP_HP_LINE1_MIC1_LED, 7521 ALC269_FIXUP_INV_DMIC, 7522 ALC269_FIXUP_LENOVO_DOCK, 7523 ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, 7524 ALC269_FIXUP_NO_SHUTUP, 7525 ALC286_FIXUP_SONY_MIC_NO_PRESENCE, 7526 ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT, 7527 ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 7528 ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, 7529 ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, 7530 ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 7531 ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET, 7532 ALC269_FIXUP_HEADSET_MODE, 7533 ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, 7534 ALC269_FIXUP_ASPIRE_HEADSET_MIC, 7535 ALC269_FIXUP_ASUS_X101_FUNC, 7536 ALC269_FIXUP_ASUS_X101_VERB, 7537 ALC269_FIXUP_ASUS_X101, 7538 ALC271_FIXUP_AMIC_MIC2, 7539 ALC271_FIXUP_HP_GATE_MIC_JACK, 7540 ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, 7541 ALC269_FIXUP_ACER_AC700, 7542 ALC269_FIXUP_LIMIT_INT_MIC_BOOST, 7543 ALC269VB_FIXUP_ASUS_ZENBOOK, 7544 ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, 7545 ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE, 7546 ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED, 7547 ALC269VB_FIXUP_ORDISSIMO_EVE2, 7548 ALC283_FIXUP_CHROME_BOOK, 7549 ALC283_FIXUP_SENSE_COMBO_JACK, 7550 ALC282_FIXUP_ASUS_TX300, 7551 ALC283_FIXUP_INT_MIC, 7552 ALC290_FIXUP_MONO_SPEAKERS, 7553 ALC290_FIXUP_MONO_SPEAKERS_HSJACK, 7554 ALC290_FIXUP_SUBWOOFER, 7555 ALC290_FIXUP_SUBWOOFER_HSJACK, 7556 ALC269_FIXUP_THINKPAD_ACPI, 7557 ALC269_FIXUP_DMIC_THINKPAD_ACPI, 7558 ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO, 7559 ALC255_FIXUP_ACER_MIC_NO_PRESENCE, 7560 ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, 7561 ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 7562 ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, 7563 ALC255_FIXUP_HEADSET_MODE, 7564 ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC, 7565 ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, 7566 ALC292_FIXUP_TPT440_DOCK, 7567 ALC292_FIXUP_TPT440, 7568 ALC283_FIXUP_HEADSET_MIC, 7569 ALC255_FIXUP_MIC_MUTE_LED, 7570 ALC282_FIXUP_ASPIRE_V5_PINS, 7571 ALC269VB_FIXUP_ASPIRE_E1_COEF, 7572 ALC280_FIXUP_HP_GPIO4, 7573 ALC286_FIXUP_HP_GPIO_LED, 7574 ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, 7575 ALC280_FIXUP_HP_DOCK_PINS, 7576 ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, 7577 ALC280_FIXUP_HP_9480M, 7578 ALC245_FIXUP_HP_X360_AMP, 7579 ALC285_FIXUP_HP_SPECTRE_X360_EB1, 7580 ALC285_FIXUP_HP_ENVY_X360, 7581 ALC288_FIXUP_DELL_HEADSET_MODE, 7582 ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, 7583 ALC288_FIXUP_DELL_XPS_13, 7584 ALC288_FIXUP_DISABLE_AAMIX, 7585 ALC292_FIXUP_DELL_E7X_AAMIX, 7586 ALC292_FIXUP_DELL_E7X, 7587 ALC292_FIXUP_DISABLE_AAMIX, 7588 ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, 7589 ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE, 7590 ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 7591 ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, 7592 ALC275_FIXUP_DELL_XPS, 7593 ALC293_FIXUP_LENOVO_SPK_NOISE, 7594 ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, 7595 ALC255_FIXUP_DELL_SPK_NOISE, 7596 ALC225_FIXUP_DISABLE_MIC_VREF, 7597 ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 7598 ALC295_FIXUP_DISABLE_DAC3, 7599 ALC285_FIXUP_SPEAKER2_TO_DAC1, 7600 ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1, 7601 ALC285_FIXUP_ASUS_HEADSET_MIC, 7602 ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS, 7603 ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1, 7604 ALC285_FIXUP_ASUS_I2C_HEADSET_MIC, 7605 ALC280_FIXUP_HP_HEADSET_MIC, 7606 ALC221_FIXUP_HP_FRONT_MIC, 7607 ALC292_FIXUP_TPT460, 7608 ALC298_FIXUP_SPK_VOLUME, 7609 ALC298_FIXUP_LENOVO_SPK_VOLUME, 7610 ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, 7611 ALC269_FIXUP_ATIV_BOOK_8, 7612 ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE, 7613 ALC221_FIXUP_HP_MIC_NO_PRESENCE, 7614 ALC256_FIXUP_ASUS_HEADSET_MODE, 7615 ALC256_FIXUP_ASUS_MIC, 7616 ALC256_FIXUP_ASUS_AIO_GPIO2, 7617 ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, 7618 ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, 7619 ALC233_FIXUP_LENOVO_MULTI_CODECS, 7620 ALC233_FIXUP_ACER_HEADSET_MIC, 7621 ALC294_FIXUP_LENOVO_MIC_LOCATION, 7622 ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, 7623 ALC225_FIXUP_S3_POP_NOISE, 7624 ALC700_FIXUP_INTEL_REFERENCE, 7625 ALC274_FIXUP_DELL_BIND_DACS, 7626 ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, 7627 ALC298_FIXUP_TPT470_DOCK_FIX, 7628 ALC298_FIXUP_TPT470_DOCK, 7629 ALC255_FIXUP_DUMMY_LINEOUT_VERB, 7630 ALC255_FIXUP_DELL_HEADSET_MIC, 7631 ALC256_FIXUP_HUAWEI_MACH_WX9_PINS, 7632 ALC298_FIXUP_HUAWEI_MBX_STEREO, 7633 ALC295_FIXUP_HP_X360, 7634 ALC221_FIXUP_HP_HEADSET_MIC, 7635 ALC285_FIXUP_LENOVO_HEADPHONE_NOISE, 7636 ALC295_FIXUP_HP_AUTO_MUTE, 7637 ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE, 7638 ALC294_FIXUP_ASUS_MIC, 7639 ALC294_FIXUP_ASUS_HEADSET_MIC, 7640 ALC294_FIXUP_ASUS_SPK, 7641 ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE, 7642 ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE, 7643 ALC255_FIXUP_ACER_HEADSET_MIC, 7644 ALC295_FIXUP_CHROME_BOOK, 7645 ALC225_FIXUP_HEADSET_JACK, 7646 ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE, 7647 ALC225_FIXUP_WYSE_AUTO_MUTE, 7648 ALC225_FIXUP_WYSE_DISABLE_MIC_VREF, 7649 ALC286_FIXUP_ACER_AIO_HEADSET_MIC, 7650 ALC256_FIXUP_ASUS_HEADSET_MIC, 7651 ALC256_FIXUP_ASUS_MIC_NO_PRESENCE, 7652 ALC299_FIXUP_PREDATOR_SPK, 7653 ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, 7654 ALC289_FIXUP_DELL_SPK1, 7655 ALC289_FIXUP_DELL_SPK2, 7656 ALC289_FIXUP_DUAL_SPK, 7657 ALC289_FIXUP_RTK_AMP_DUAL_SPK, 7658 ALC294_FIXUP_SPK2_TO_DAC1, 7659 ALC294_FIXUP_ASUS_DUAL_SPK, 7660 ALC285_FIXUP_THINKPAD_X1_GEN7, 7661 ALC285_FIXUP_THINKPAD_HEADSET_JACK, 7662 ALC294_FIXUP_ASUS_ALLY, 7663 ALC294_FIXUP_ASUS_ALLY_X, 7664 ALC294_FIXUP_ASUS_ALLY_PINS, 7665 ALC294_FIXUP_ASUS_ALLY_VERBS, 7666 ALC294_FIXUP_ASUS_ALLY_SPEAKER, 7667 ALC294_FIXUP_ASUS_HPE, 7668 ALC294_FIXUP_ASUS_COEF_1B, 7669 ALC294_FIXUP_ASUS_GX502_HP, 7670 ALC294_FIXUP_ASUS_GX502_PINS, 7671 ALC294_FIXUP_ASUS_GX502_VERBS, 7672 ALC294_FIXUP_ASUS_GU502_HP, 7673 ALC294_FIXUP_ASUS_GU502_PINS, 7674 ALC294_FIXUP_ASUS_GU502_VERBS, 7675 ALC294_FIXUP_ASUS_G513_PINS, 7676 ALC285_FIXUP_ASUS_G533Z_PINS, 7677 ALC285_FIXUP_HP_GPIO_LED, 7678 ALC285_FIXUP_HP_MUTE_LED, 7679 ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED, 7680 ALC236_FIXUP_HP_MUTE_LED_COEFBIT2, 7681 ALC236_FIXUP_HP_GPIO_LED, 7682 ALC236_FIXUP_HP_MUTE_LED, 7683 ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF, 7684 ALC236_FIXUP_LENOVO_INV_DMIC, 7685 ALC298_FIXUP_SAMSUNG_AMP, 7686 ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS, 7687 ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS, 7688 ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, 7689 ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, 7690 ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, 7691 ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS, 7692 ALC269VC_FIXUP_ACER_HEADSET_MIC, 7693 ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE, 7694 ALC289_FIXUP_ASUS_GA401, 7695 ALC289_FIXUP_ASUS_GA502, 7696 ALC256_FIXUP_ACER_MIC_NO_PRESENCE, 7697 ALC285_FIXUP_HP_GPIO_AMP_INIT, 7698 ALC269_FIXUP_CZC_B20, 7699 ALC269_FIXUP_CZC_TMI, 7700 ALC269_FIXUP_CZC_L101, 7701 ALC269_FIXUP_LEMOTE_A1802, 7702 ALC269_FIXUP_LEMOTE_A190X, 7703 ALC256_FIXUP_INTEL_NUC8_RUGGED, 7704 ALC233_FIXUP_INTEL_NUC8_DMIC, 7705 ALC233_FIXUP_INTEL_NUC8_BOOST, 7706 ALC256_FIXUP_INTEL_NUC10, 7707 ALC255_FIXUP_XIAOMI_HEADSET_MIC, 7708 ALC274_FIXUP_HP_MIC, 7709 ALC274_FIXUP_HP_HEADSET_MIC, 7710 ALC274_FIXUP_HP_ENVY_GPIO, 7711 ALC256_FIXUP_ASUS_HPE, 7712 ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK, 7713 ALC287_FIXUP_HP_GPIO_LED, 7714 ALC256_FIXUP_HP_HEADSET_MIC, 7715 ALC245_FIXUP_HP_GPIO_LED, 7716 ALC236_FIXUP_DELL_AIO_HEADSET_MIC, 7717 ALC282_FIXUP_ACER_DISABLE_LINEOUT, 7718 ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST, 7719 ALC256_FIXUP_ACER_HEADSET_MIC, 7720 ALC285_FIXUP_IDEAPAD_S740_COEF, 7721 ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST, 7722 ALC295_FIXUP_ASUS_DACS, 7723 ALC295_FIXUP_HP_OMEN, 7724 ALC285_FIXUP_HP_SPECTRE_X360, 7725 ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, 7726 ALC623_FIXUP_LENOVO_THINKSTATION_P340, 7727 ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, 7728 ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST, 7729 ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS, 7730 ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE, 7731 ALC287_FIXUP_YOGA7_14ITL_SPEAKERS, 7732 ALC298_FIXUP_LENOVO_C940_DUET7, 7733 ALC287_FIXUP_LENOVO_14IRP8_DUETITL, 7734 ALC287_FIXUP_LENOVO_LEGION_7, 7735 ALC287_FIXUP_13S_GEN2_SPEAKERS, 7736 ALC256_FIXUP_SET_COEF_DEFAULTS, 7737 ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE, 7738 ALC233_FIXUP_NO_AUDIO_JACK, 7739 ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME, 7740 ALC285_FIXUP_LEGION_Y9000X_SPEAKERS, 7741 ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE, 7742 ALC287_FIXUP_LEGION_16ACHG6, 7743 ALC287_FIXUP_CS35L41_I2C_2, 7744 ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED, 7745 ALC287_FIXUP_CS35L41_I2C_4, 7746 ALC245_FIXUP_CS35L41_SPI_2, 7747 ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED, 7748 ALC245_FIXUP_CS35L41_SPI_4, 7749 ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED, 7750 ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED, 7751 ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE, 7752 ALC287_FIXUP_LEGION_16ITHG6, 7753 ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK, 7754 ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN, 7755 ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN, 7756 ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS, 7757 ALC236_FIXUP_DELL_DUAL_CODECS, 7758 ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI, 7759 ALC287_FIXUP_TAS2781_I2C, 7760 ALC287_FIXUP_YOGA7_14ARB7_I2C, 7761 ALC245_FIXUP_HP_MUTE_LED_COEFBIT, 7762 ALC245_FIXUP_HP_X360_MUTE_LEDS, 7763 ALC287_FIXUP_THINKPAD_I2S_SPK, 7764 ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD, 7765 ALC2XX_FIXUP_HEADSET_MIC, 7766 ALC289_FIXUP_DELL_CS35L41_SPI_2, 7767 ALC294_FIXUP_CS35L41_I2C_2, 7768 ALC256_FIXUP_ACER_SFG16_MICMUTE_LED, 7769 ALC256_FIXUP_HEADPHONE_AMP_VOL, 7770 ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX, 7771 ALC245_FIXUP_HP_SPECTRE_X360_16_AA0XXX, 7772 ALC285_FIXUP_ASUS_GA403U, 7773 ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC, 7774 ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1, 7775 ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC, 7776 ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1, 7777 ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318, 7778 ALC256_FIXUP_CHROME_BOOK, 7779 ALC287_FIXUP_LENOVO_14ARP8_LEGION_IAH7, 7780 ALC287_FIXUP_LENOVO_SSID_17AA3820, 7781 ALC245_FIXUP_CLEVO_NOISY_MIC, 7782 ALC269_FIXUP_VAIO_VJFH52_MIC_NO_PRESENCE, 7783 }; 7784 7785 /* A special fixup for Lenovo C940 and Yoga Duet 7; 7786 * both have the very same PCI SSID, and we need to apply different fixups 7787 * depending on the codec ID 7788 */ 7789 static void alc298_fixup_lenovo_c940_duet7(struct hda_codec *codec, 7790 const struct hda_fixup *fix, 7791 int action) 7792 { 7793 int id; 7794 7795 if (codec->core.vendor_id == 0x10ec0298) 7796 id = ALC298_FIXUP_LENOVO_SPK_VOLUME; /* C940 */ 7797 else 7798 id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* Duet 7 */ 7799 __snd_hda_apply_fixup(codec, id, action, 0); 7800 } 7801 7802 /* A special fixup for Lenovo Slim/Yoga Pro 9 14IRP8 and Yoga DuetITL 2021; 7803 * 14IRP8 PCI SSID will mistakenly be matched with the DuetITL codec SSID, 7804 * so we need to apply a different fixup in this case. The only DuetITL codec 7805 * SSID reported so far is the 17aa:3802 while the 14IRP8 has the 17aa:38be 7806 * and 17aa:38bf. If it weren't for the PCI SSID, the 14IRP8 models would 7807 * have matched correctly by their codecs. 7808 */ 7809 static void alc287_fixup_lenovo_14irp8_duetitl(struct hda_codec *codec, 7810 const struct hda_fixup *fix, 7811 int action) 7812 { 7813 int id; 7814 7815 if (codec->core.subsystem_id == 0x17aa3802) 7816 id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* DuetITL */ 7817 else 7818 id = ALC287_FIXUP_TAS2781_I2C; /* 14IRP8 */ 7819 __snd_hda_apply_fixup(codec, id, action, 0); 7820 } 7821 7822 /* Similar to above the Lenovo Yoga Pro 7 14ARP8 PCI SSID matches the codec SSID of the 7823 Legion Y9000X 2022 IAH7.*/ 7824 static void alc287_fixup_lenovo_14arp8_legion_iah7(struct hda_codec *codec, 7825 const struct hda_fixup *fix, 7826 int action) 7827 { 7828 int id; 7829 7830 if (codec->core.subsystem_id == 0x17aa386e) 7831 id = ALC287_FIXUP_CS35L41_I2C_2; /* Legion Y9000X 2022 IAH7 */ 7832 else 7833 id = ALC285_FIXUP_SPEAKER2_TO_DAC1; /* Yoga Pro 7 14ARP8 */ 7834 __snd_hda_apply_fixup(codec, id, action, 0); 7835 } 7836 7837 /* Another hilarious PCI SSID conflict with Lenovo Legion Pro 7 16ARX8H (with 7838 * TAS2781 codec) and Legion 7i 16IAX7 (with CS35L41 codec); 7839 * we apply a corresponding fixup depending on the codec SSID instead 7840 */ 7841 static void alc287_fixup_lenovo_legion_7(struct hda_codec *codec, 7842 const struct hda_fixup *fix, 7843 int action) 7844 { 7845 int id; 7846 7847 if (codec->core.subsystem_id == 0x17aa38a8) 7848 id = ALC287_FIXUP_TAS2781_I2C; /* Legion Pro 7 16ARX8H */ 7849 else 7850 id = ALC287_FIXUP_CS35L41_I2C_2; /* Legion 7i 16IAX7 */ 7851 __snd_hda_apply_fixup(codec, id, action, 0); 7852 } 7853 7854 /* Yet more conflicting PCI SSID (17aa:3820) on two Lenovo models */ 7855 static void alc287_fixup_lenovo_ssid_17aa3820(struct hda_codec *codec, 7856 const struct hda_fixup *fix, 7857 int action) 7858 { 7859 int id; 7860 7861 if (codec->core.subsystem_id == 0x17aa3820) 7862 id = ALC269_FIXUP_ASPIRE_HEADSET_MIC; /* IdeaPad 330-17IKB 81DM */ 7863 else /* 0x17aa3802 */ 7864 id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* "Yoga Duet 7 13ITL6 */ 7865 __snd_hda_apply_fixup(codec, id, action, 0); 7866 } 7867 7868 static const struct hda_fixup alc269_fixups[] = { 7869 [ALC269_FIXUP_GPIO2] = { 7870 .type = HDA_FIXUP_FUNC, 7871 .v.func = alc_fixup_gpio2, 7872 }, 7873 [ALC269_FIXUP_SONY_VAIO] = { 7874 .type = HDA_FIXUP_PINCTLS, 7875 .v.pins = (const struct hda_pintbl[]) { 7876 {0x19, PIN_VREFGRD}, 7877 {} 7878 } 7879 }, 7880 [ALC275_FIXUP_SONY_VAIO_GPIO2] = { 7881 .type = HDA_FIXUP_FUNC, 7882 .v.func = alc275_fixup_gpio4_off, 7883 .chained = true, 7884 .chain_id = ALC269_FIXUP_SONY_VAIO 7885 }, 7886 [ALC269_FIXUP_DELL_M101Z] = { 7887 .type = HDA_FIXUP_VERBS, 7888 .v.verbs = (const struct hda_verb[]) { 7889 /* Enables internal speaker */ 7890 {0x20, AC_VERB_SET_COEF_INDEX, 13}, 7891 {0x20, AC_VERB_SET_PROC_COEF, 0x4040}, 7892 {} 7893 } 7894 }, 7895 [ALC269_FIXUP_SKU_IGNORE] = { 7896 .type = HDA_FIXUP_FUNC, 7897 .v.func = alc_fixup_sku_ignore, 7898 }, 7899 [ALC269_FIXUP_ASUS_G73JW] = { 7900 .type = HDA_FIXUP_PINS, 7901 .v.pins = (const struct hda_pintbl[]) { 7902 { 0x17, 0x99130111 }, /* subwoofer */ 7903 { } 7904 } 7905 }, 7906 [ALC269_FIXUP_ASUS_N7601ZM_PINS] = { 7907 .type = HDA_FIXUP_PINS, 7908 .v.pins = (const struct hda_pintbl[]) { 7909 { 0x19, 0x03A11050 }, 7910 { 0x1a, 0x03A11C30 }, 7911 { 0x21, 0x03211420 }, 7912 { } 7913 } 7914 }, 7915 [ALC269_FIXUP_ASUS_N7601ZM] = { 7916 .type = HDA_FIXUP_VERBS, 7917 .v.verbs = (const struct hda_verb[]) { 7918 {0x20, AC_VERB_SET_COEF_INDEX, 0x62}, 7919 {0x20, AC_VERB_SET_PROC_COEF, 0xa007}, 7920 {0x20, AC_VERB_SET_COEF_INDEX, 0x10}, 7921 {0x20, AC_VERB_SET_PROC_COEF, 0x8420}, 7922 {0x20, AC_VERB_SET_COEF_INDEX, 0x0f}, 7923 {0x20, AC_VERB_SET_PROC_COEF, 0x7774}, 7924 { } 7925 }, 7926 .chained = true, 7927 .chain_id = ALC269_FIXUP_ASUS_N7601ZM_PINS, 7928 }, 7929 [ALC269_FIXUP_LENOVO_EAPD] = { 7930 .type = HDA_FIXUP_VERBS, 7931 .v.verbs = (const struct hda_verb[]) { 7932 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0}, 7933 {} 7934 } 7935 }, 7936 [ALC275_FIXUP_SONY_HWEQ] = { 7937 .type = HDA_FIXUP_FUNC, 7938 .v.func = alc269_fixup_hweq, 7939 .chained = true, 7940 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2 7941 }, 7942 [ALC275_FIXUP_SONY_DISABLE_AAMIX] = { 7943 .type = HDA_FIXUP_FUNC, 7944 .v.func = alc_fixup_disable_aamix, 7945 .chained = true, 7946 .chain_id = ALC269_FIXUP_SONY_VAIO 7947 }, 7948 [ALC271_FIXUP_DMIC] = { 7949 .type = HDA_FIXUP_FUNC, 7950 .v.func = alc271_fixup_dmic, 7951 }, 7952 [ALC269_FIXUP_PCM_44K] = { 7953 .type = HDA_FIXUP_FUNC, 7954 .v.func = alc269_fixup_pcm_44k, 7955 .chained = true, 7956 .chain_id = ALC269_FIXUP_QUANTA_MUTE 7957 }, 7958 [ALC269_FIXUP_STEREO_DMIC] = { 7959 .type = HDA_FIXUP_FUNC, 7960 .v.func = alc269_fixup_stereo_dmic, 7961 }, 7962 [ALC269_FIXUP_HEADSET_MIC] = { 7963 .type = HDA_FIXUP_FUNC, 7964 .v.func = alc269_fixup_headset_mic, 7965 }, 7966 [ALC269_FIXUP_QUANTA_MUTE] = { 7967 .type = HDA_FIXUP_FUNC, 7968 .v.func = alc269_fixup_quanta_mute, 7969 }, 7970 [ALC269_FIXUP_LIFEBOOK] = { 7971 .type = HDA_FIXUP_PINS, 7972 .v.pins = (const struct hda_pintbl[]) { 7973 { 0x1a, 0x2101103f }, /* dock line-out */ 7974 { 0x1b, 0x23a11040 }, /* dock mic-in */ 7975 { } 7976 }, 7977 .chained = true, 7978 .chain_id = ALC269_FIXUP_QUANTA_MUTE 7979 }, 7980 [ALC269_FIXUP_LIFEBOOK_EXTMIC] = { 7981 .type = HDA_FIXUP_PINS, 7982 .v.pins = (const struct hda_pintbl[]) { 7983 { 0x19, 0x01a1903c }, /* headset mic, with jack detect */ 7984 { } 7985 }, 7986 }, 7987 [ALC269_FIXUP_LIFEBOOK_HP_PIN] = { 7988 .type = HDA_FIXUP_PINS, 7989 .v.pins = (const struct hda_pintbl[]) { 7990 { 0x21, 0x0221102f }, /* HP out */ 7991 { } 7992 }, 7993 }, 7994 [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = { 7995 .type = HDA_FIXUP_FUNC, 7996 .v.func = alc269_fixup_pincfg_no_hp_to_lineout, 7997 }, 7998 [ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = { 7999 .type = HDA_FIXUP_FUNC, 8000 .v.func = alc269_fixup_pincfg_U7x7_headset_mic, 8001 }, 8002 [ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO] = { 8003 .type = HDA_FIXUP_PINS, 8004 .v.pins = (const struct hda_pintbl[]) { 8005 { 0x18, 0x03a19020 }, /* headset mic */ 8006 { 0x1b, 0x90170150 }, /* speaker */ 8007 { } 8008 }, 8009 }, 8010 [ALC269_FIXUP_AMIC] = { 8011 .type = HDA_FIXUP_PINS, 8012 .v.pins = (const struct hda_pintbl[]) { 8013 { 0x14, 0x99130110 }, /* speaker */ 8014 { 0x15, 0x0121401f }, /* HP out */ 8015 { 0x18, 0x01a19c20 }, /* mic */ 8016 { 0x19, 0x99a3092f }, /* int-mic */ 8017 { } 8018 }, 8019 }, 8020 [ALC269_FIXUP_DMIC] = { 8021 .type = HDA_FIXUP_PINS, 8022 .v.pins = (const struct hda_pintbl[]) { 8023 { 0x12, 0x99a3092f }, /* int-mic */ 8024 { 0x14, 0x99130110 }, /* speaker */ 8025 { 0x15, 0x0121401f }, /* HP out */ 8026 { 0x18, 0x01a19c20 }, /* mic */ 8027 { } 8028 }, 8029 }, 8030 [ALC269VB_FIXUP_AMIC] = { 8031 .type = HDA_FIXUP_PINS, 8032 .v.pins = (const struct hda_pintbl[]) { 8033 { 0x14, 0x99130110 }, /* speaker */ 8034 { 0x18, 0x01a19c20 }, /* mic */ 8035 { 0x19, 0x99a3092f }, /* int-mic */ 8036 { 0x21, 0x0121401f }, /* HP out */ 8037 { } 8038 }, 8039 }, 8040 [ALC269VB_FIXUP_DMIC] = { 8041 .type = HDA_FIXUP_PINS, 8042 .v.pins = (const struct hda_pintbl[]) { 8043 { 0x12, 0x99a3092f }, /* int-mic */ 8044 { 0x14, 0x99130110 }, /* speaker */ 8045 { 0x18, 0x01a19c20 }, /* mic */ 8046 { 0x21, 0x0121401f }, /* HP out */ 8047 { } 8048 }, 8049 }, 8050 [ALC269_FIXUP_HP_MUTE_LED] = { 8051 .type = HDA_FIXUP_FUNC, 8052 .v.func = alc269_fixup_hp_mute_led, 8053 }, 8054 [ALC269_FIXUP_HP_MUTE_LED_MIC1] = { 8055 .type = HDA_FIXUP_FUNC, 8056 .v.func = alc269_fixup_hp_mute_led_mic1, 8057 }, 8058 [ALC269_FIXUP_HP_MUTE_LED_MIC2] = { 8059 .type = HDA_FIXUP_FUNC, 8060 .v.func = alc269_fixup_hp_mute_led_mic2, 8061 }, 8062 [ALC269_FIXUP_HP_MUTE_LED_MIC3] = { 8063 .type = HDA_FIXUP_FUNC, 8064 .v.func = alc269_fixup_hp_mute_led_mic3, 8065 .chained = true, 8066 .chain_id = ALC295_FIXUP_HP_AUTO_MUTE 8067 }, 8068 [ALC269_FIXUP_HP_GPIO_LED] = { 8069 .type = HDA_FIXUP_FUNC, 8070 .v.func = alc269_fixup_hp_gpio_led, 8071 }, 8072 [ALC269_FIXUP_HP_GPIO_MIC1_LED] = { 8073 .type = HDA_FIXUP_FUNC, 8074 .v.func = alc269_fixup_hp_gpio_mic1_led, 8075 }, 8076 [ALC269_FIXUP_HP_LINE1_MIC1_LED] = { 8077 .type = HDA_FIXUP_FUNC, 8078 .v.func = alc269_fixup_hp_line1_mic1_led, 8079 }, 8080 [ALC269_FIXUP_INV_DMIC] = { 8081 .type = HDA_FIXUP_FUNC, 8082 .v.func = alc_fixup_inv_dmic, 8083 }, 8084 [ALC269_FIXUP_NO_SHUTUP] = { 8085 .type = HDA_FIXUP_FUNC, 8086 .v.func = alc_fixup_no_shutup, 8087 }, 8088 [ALC269_FIXUP_LENOVO_DOCK] = { 8089 .type = HDA_FIXUP_PINS, 8090 .v.pins = (const struct hda_pintbl[]) { 8091 { 0x19, 0x23a11040 }, /* dock mic */ 8092 { 0x1b, 0x2121103f }, /* dock headphone */ 8093 { } 8094 }, 8095 .chained = true, 8096 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT 8097 }, 8098 [ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST] = { 8099 .type = HDA_FIXUP_FUNC, 8100 .v.func = alc269_fixup_limit_int_mic_boost, 8101 .chained = true, 8102 .chain_id = ALC269_FIXUP_LENOVO_DOCK, 8103 }, 8104 [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = { 8105 .type = HDA_FIXUP_FUNC, 8106 .v.func = alc269_fixup_pincfg_no_hp_to_lineout, 8107 .chained = true, 8108 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 8109 }, 8110 [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = { 8111 .type = HDA_FIXUP_PINS, 8112 .v.pins = (const struct hda_pintbl[]) { 8113 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8114 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 8115 { } 8116 }, 8117 .chained = true, 8118 .chain_id = ALC269_FIXUP_HEADSET_MODE 8119 }, 8120 [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = { 8121 .type = HDA_FIXUP_PINS, 8122 .v.pins = (const struct hda_pintbl[]) { 8123 { 0x16, 0x21014020 }, /* dock line out */ 8124 { 0x19, 0x21a19030 }, /* dock mic */ 8125 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8126 { } 8127 }, 8128 .chained = true, 8129 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 8130 }, 8131 [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = { 8132 .type = HDA_FIXUP_PINS, 8133 .v.pins = (const struct hda_pintbl[]) { 8134 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8135 { } 8136 }, 8137 .chained = true, 8138 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 8139 }, 8140 [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = { 8141 .type = HDA_FIXUP_PINS, 8142 .v.pins = (const struct hda_pintbl[]) { 8143 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8144 { 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 8145 { } 8146 }, 8147 .chained = true, 8148 .chain_id = ALC269_FIXUP_HEADSET_MODE 8149 }, 8150 [ALC269_FIXUP_HEADSET_MODE] = { 8151 .type = HDA_FIXUP_FUNC, 8152 .v.func = alc_fixup_headset_mode, 8153 .chained = true, 8154 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 8155 }, 8156 [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = { 8157 .type = HDA_FIXUP_FUNC, 8158 .v.func = alc_fixup_headset_mode_no_hp_mic, 8159 }, 8160 [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = { 8161 .type = HDA_FIXUP_PINS, 8162 .v.pins = (const struct hda_pintbl[]) { 8163 { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */ 8164 { } 8165 }, 8166 .chained = true, 8167 .chain_id = ALC269_FIXUP_HEADSET_MODE, 8168 }, 8169 [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = { 8170 .type = HDA_FIXUP_PINS, 8171 .v.pins = (const struct hda_pintbl[]) { 8172 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8173 { } 8174 }, 8175 .chained = true, 8176 .chain_id = ALC269_FIXUP_HEADSET_MIC 8177 }, 8178 [ALC256_FIXUP_HUAWEI_MACH_WX9_PINS] = { 8179 .type = HDA_FIXUP_PINS, 8180 .v.pins = (const struct hda_pintbl[]) { 8181 {0x12, 0x90a60130}, 8182 {0x13, 0x40000000}, 8183 {0x14, 0x90170110}, 8184 {0x18, 0x411111f0}, 8185 {0x19, 0x04a11040}, 8186 {0x1a, 0x411111f0}, 8187 {0x1b, 0x90170112}, 8188 {0x1d, 0x40759a05}, 8189 {0x1e, 0x411111f0}, 8190 {0x21, 0x04211020}, 8191 { } 8192 }, 8193 .chained = true, 8194 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 8195 }, 8196 [ALC298_FIXUP_HUAWEI_MBX_STEREO] = { 8197 .type = HDA_FIXUP_FUNC, 8198 .v.func = alc298_fixup_huawei_mbx_stereo, 8199 .chained = true, 8200 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 8201 }, 8202 [ALC269_FIXUP_ASUS_X101_FUNC] = { 8203 .type = HDA_FIXUP_FUNC, 8204 .v.func = alc269_fixup_x101_headset_mic, 8205 }, 8206 [ALC269_FIXUP_ASUS_X101_VERB] = { 8207 .type = HDA_FIXUP_VERBS, 8208 .v.verbs = (const struct hda_verb[]) { 8209 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 8210 {0x20, AC_VERB_SET_COEF_INDEX, 0x08}, 8211 {0x20, AC_VERB_SET_PROC_COEF, 0x0310}, 8212 { } 8213 }, 8214 .chained = true, 8215 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC 8216 }, 8217 [ALC269_FIXUP_ASUS_X101] = { 8218 .type = HDA_FIXUP_PINS, 8219 .v.pins = (const struct hda_pintbl[]) { 8220 { 0x18, 0x04a1182c }, /* Headset mic */ 8221 { } 8222 }, 8223 .chained = true, 8224 .chain_id = ALC269_FIXUP_ASUS_X101_VERB 8225 }, 8226 [ALC271_FIXUP_AMIC_MIC2] = { 8227 .type = HDA_FIXUP_PINS, 8228 .v.pins = (const struct hda_pintbl[]) { 8229 { 0x14, 0x99130110 }, /* speaker */ 8230 { 0x19, 0x01a19c20 }, /* mic */ 8231 { 0x1b, 0x99a7012f }, /* int-mic */ 8232 { 0x21, 0x0121401f }, /* HP out */ 8233 { } 8234 }, 8235 }, 8236 [ALC271_FIXUP_HP_GATE_MIC_JACK] = { 8237 .type = HDA_FIXUP_FUNC, 8238 .v.func = alc271_hp_gate_mic_jack, 8239 .chained = true, 8240 .chain_id = ALC271_FIXUP_AMIC_MIC2, 8241 }, 8242 [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = { 8243 .type = HDA_FIXUP_FUNC, 8244 .v.func = alc269_fixup_limit_int_mic_boost, 8245 .chained = true, 8246 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK, 8247 }, 8248 [ALC269_FIXUP_ACER_AC700] = { 8249 .type = HDA_FIXUP_PINS, 8250 .v.pins = (const struct hda_pintbl[]) { 8251 { 0x12, 0x99a3092f }, /* int-mic */ 8252 { 0x14, 0x99130110 }, /* speaker */ 8253 { 0x18, 0x03a11c20 }, /* mic */ 8254 { 0x1e, 0x0346101e }, /* SPDIF1 */ 8255 { 0x21, 0x0321101f }, /* HP out */ 8256 { } 8257 }, 8258 .chained = true, 8259 .chain_id = ALC271_FIXUP_DMIC, 8260 }, 8261 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = { 8262 .type = HDA_FIXUP_FUNC, 8263 .v.func = alc269_fixup_limit_int_mic_boost, 8264 .chained = true, 8265 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 8266 }, 8267 [ALC269VB_FIXUP_ASUS_ZENBOOK] = { 8268 .type = HDA_FIXUP_FUNC, 8269 .v.func = alc269_fixup_limit_int_mic_boost, 8270 .chained = true, 8271 .chain_id = ALC269VB_FIXUP_DMIC, 8272 }, 8273 [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = { 8274 .type = HDA_FIXUP_VERBS, 8275 .v.verbs = (const struct hda_verb[]) { 8276 /* class-D output amp +5dB */ 8277 { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 }, 8278 { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 }, 8279 {} 8280 }, 8281 .chained = true, 8282 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK, 8283 }, 8284 [ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE] = { 8285 .type = HDA_FIXUP_PINS, 8286 .v.pins = (const struct hda_pintbl[]) { 8287 { 0x18, 0x01a110f0 }, /* use as headset mic */ 8288 { } 8289 }, 8290 .chained = true, 8291 .chain_id = ALC269_FIXUP_HEADSET_MIC 8292 }, 8293 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = { 8294 .type = HDA_FIXUP_FUNC, 8295 .v.func = alc269_fixup_limit_int_mic_boost, 8296 .chained = true, 8297 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1, 8298 }, 8299 [ALC269VB_FIXUP_ORDISSIMO_EVE2] = { 8300 .type = HDA_FIXUP_PINS, 8301 .v.pins = (const struct hda_pintbl[]) { 8302 { 0x12, 0x99a3092f }, /* int-mic */ 8303 { 0x18, 0x03a11d20 }, /* mic */ 8304 { 0x19, 0x411111f0 }, /* Unused bogus pin */ 8305 { } 8306 }, 8307 }, 8308 [ALC283_FIXUP_CHROME_BOOK] = { 8309 .type = HDA_FIXUP_FUNC, 8310 .v.func = alc283_fixup_chromebook, 8311 }, 8312 [ALC283_FIXUP_SENSE_COMBO_JACK] = { 8313 .type = HDA_FIXUP_FUNC, 8314 .v.func = alc283_fixup_sense_combo_jack, 8315 .chained = true, 8316 .chain_id = ALC283_FIXUP_CHROME_BOOK, 8317 }, 8318 [ALC282_FIXUP_ASUS_TX300] = { 8319 .type = HDA_FIXUP_FUNC, 8320 .v.func = alc282_fixup_asus_tx300, 8321 }, 8322 [ALC283_FIXUP_INT_MIC] = { 8323 .type = HDA_FIXUP_VERBS, 8324 .v.verbs = (const struct hda_verb[]) { 8325 {0x20, AC_VERB_SET_COEF_INDEX, 0x1a}, 8326 {0x20, AC_VERB_SET_PROC_COEF, 0x0011}, 8327 { } 8328 }, 8329 .chained = true, 8330 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST 8331 }, 8332 [ALC290_FIXUP_SUBWOOFER_HSJACK] = { 8333 .type = HDA_FIXUP_PINS, 8334 .v.pins = (const struct hda_pintbl[]) { 8335 { 0x17, 0x90170112 }, /* subwoofer */ 8336 { } 8337 }, 8338 .chained = true, 8339 .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, 8340 }, 8341 [ALC290_FIXUP_SUBWOOFER] = { 8342 .type = HDA_FIXUP_PINS, 8343 .v.pins = (const struct hda_pintbl[]) { 8344 { 0x17, 0x90170112 }, /* subwoofer */ 8345 { } 8346 }, 8347 .chained = true, 8348 .chain_id = ALC290_FIXUP_MONO_SPEAKERS, 8349 }, 8350 [ALC290_FIXUP_MONO_SPEAKERS] = { 8351 .type = HDA_FIXUP_FUNC, 8352 .v.func = alc290_fixup_mono_speakers, 8353 }, 8354 [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = { 8355 .type = HDA_FIXUP_FUNC, 8356 .v.func = alc290_fixup_mono_speakers, 8357 .chained = true, 8358 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, 8359 }, 8360 [ALC269_FIXUP_THINKPAD_ACPI] = { 8361 .type = HDA_FIXUP_FUNC, 8362 .v.func = alc_fixup_thinkpad_acpi, 8363 .chained = true, 8364 .chain_id = ALC269_FIXUP_SKU_IGNORE, 8365 }, 8366 [ALC269_FIXUP_DMIC_THINKPAD_ACPI] = { 8367 .type = HDA_FIXUP_FUNC, 8368 .v.func = alc_fixup_inv_dmic, 8369 .chained = true, 8370 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 8371 }, 8372 [ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = { 8373 .type = HDA_FIXUP_PINS, 8374 .v.pins = (const struct hda_pintbl[]) { 8375 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8376 { } 8377 }, 8378 .chained = true, 8379 .chain_id = ALC255_FIXUP_HEADSET_MODE 8380 }, 8381 [ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = { 8382 .type = HDA_FIXUP_PINS, 8383 .v.pins = (const struct hda_pintbl[]) { 8384 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8385 { } 8386 }, 8387 .chained = true, 8388 .chain_id = ALC255_FIXUP_HEADSET_MODE 8389 }, 8390 [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = { 8391 .type = HDA_FIXUP_PINS, 8392 .v.pins = (const struct hda_pintbl[]) { 8393 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8394 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 8395 { } 8396 }, 8397 .chained = true, 8398 .chain_id = ALC255_FIXUP_HEADSET_MODE 8399 }, 8400 [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = { 8401 .type = HDA_FIXUP_PINS, 8402 .v.pins = (const struct hda_pintbl[]) { 8403 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8404 { } 8405 }, 8406 .chained = true, 8407 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC 8408 }, 8409 [ALC255_FIXUP_HEADSET_MODE] = { 8410 .type = HDA_FIXUP_FUNC, 8411 .v.func = alc_fixup_headset_mode_alc255, 8412 .chained = true, 8413 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 8414 }, 8415 [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = { 8416 .type = HDA_FIXUP_FUNC, 8417 .v.func = alc_fixup_headset_mode_alc255_no_hp_mic, 8418 }, 8419 [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = { 8420 .type = HDA_FIXUP_PINS, 8421 .v.pins = (const struct hda_pintbl[]) { 8422 { 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 8423 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8424 { } 8425 }, 8426 .chained = true, 8427 .chain_id = ALC269_FIXUP_HEADSET_MODE 8428 }, 8429 [ALC292_FIXUP_TPT440_DOCK] = { 8430 .type = HDA_FIXUP_FUNC, 8431 .v.func = alc_fixup_tpt440_dock, 8432 .chained = true, 8433 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST 8434 }, 8435 [ALC292_FIXUP_TPT440] = { 8436 .type = HDA_FIXUP_FUNC, 8437 .v.func = alc_fixup_disable_aamix, 8438 .chained = true, 8439 .chain_id = ALC292_FIXUP_TPT440_DOCK, 8440 }, 8441 [ALC283_FIXUP_HEADSET_MIC] = { 8442 .type = HDA_FIXUP_PINS, 8443 .v.pins = (const struct hda_pintbl[]) { 8444 { 0x19, 0x04a110f0 }, 8445 { }, 8446 }, 8447 }, 8448 [ALC255_FIXUP_MIC_MUTE_LED] = { 8449 .type = HDA_FIXUP_FUNC, 8450 .v.func = alc_fixup_micmute_led, 8451 }, 8452 [ALC282_FIXUP_ASPIRE_V5_PINS] = { 8453 .type = HDA_FIXUP_PINS, 8454 .v.pins = (const struct hda_pintbl[]) { 8455 { 0x12, 0x90a60130 }, 8456 { 0x14, 0x90170110 }, 8457 { 0x17, 0x40000008 }, 8458 { 0x18, 0x411111f0 }, 8459 { 0x19, 0x01a1913c }, 8460 { 0x1a, 0x411111f0 }, 8461 { 0x1b, 0x411111f0 }, 8462 { 0x1d, 0x40f89b2d }, 8463 { 0x1e, 0x411111f0 }, 8464 { 0x21, 0x0321101f }, 8465 { }, 8466 }, 8467 }, 8468 [ALC269VB_FIXUP_ASPIRE_E1_COEF] = { 8469 .type = HDA_FIXUP_FUNC, 8470 .v.func = alc269vb_fixup_aspire_e1_coef, 8471 }, 8472 [ALC280_FIXUP_HP_GPIO4] = { 8473 .type = HDA_FIXUP_FUNC, 8474 .v.func = alc280_fixup_hp_gpio4, 8475 }, 8476 [ALC286_FIXUP_HP_GPIO_LED] = { 8477 .type = HDA_FIXUP_FUNC, 8478 .v.func = alc286_fixup_hp_gpio_led, 8479 }, 8480 [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = { 8481 .type = HDA_FIXUP_FUNC, 8482 .v.func = alc280_fixup_hp_gpio2_mic_hotkey, 8483 }, 8484 [ALC280_FIXUP_HP_DOCK_PINS] = { 8485 .type = HDA_FIXUP_PINS, 8486 .v.pins = (const struct hda_pintbl[]) { 8487 { 0x1b, 0x21011020 }, /* line-out */ 8488 { 0x1a, 0x01a1903c }, /* headset mic */ 8489 { 0x18, 0x2181103f }, /* line-in */ 8490 { }, 8491 }, 8492 .chained = true, 8493 .chain_id = ALC280_FIXUP_HP_GPIO4 8494 }, 8495 [ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = { 8496 .type = HDA_FIXUP_PINS, 8497 .v.pins = (const struct hda_pintbl[]) { 8498 { 0x1b, 0x21011020 }, /* line-out */ 8499 { 0x18, 0x2181103f }, /* line-in */ 8500 { }, 8501 }, 8502 .chained = true, 8503 .chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED 8504 }, 8505 [ALC280_FIXUP_HP_9480M] = { 8506 .type = HDA_FIXUP_FUNC, 8507 .v.func = alc280_fixup_hp_9480m, 8508 }, 8509 [ALC245_FIXUP_HP_X360_AMP] = { 8510 .type = HDA_FIXUP_FUNC, 8511 .v.func = alc245_fixup_hp_x360_amp, 8512 .chained = true, 8513 .chain_id = ALC245_FIXUP_HP_GPIO_LED 8514 }, 8515 [ALC288_FIXUP_DELL_HEADSET_MODE] = { 8516 .type = HDA_FIXUP_FUNC, 8517 .v.func = alc_fixup_headset_mode_dell_alc288, 8518 .chained = true, 8519 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 8520 }, 8521 [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = { 8522 .type = HDA_FIXUP_PINS, 8523 .v.pins = (const struct hda_pintbl[]) { 8524 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8525 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 8526 { } 8527 }, 8528 .chained = true, 8529 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE 8530 }, 8531 [ALC288_FIXUP_DISABLE_AAMIX] = { 8532 .type = HDA_FIXUP_FUNC, 8533 .v.func = alc_fixup_disable_aamix, 8534 .chained = true, 8535 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE 8536 }, 8537 [ALC288_FIXUP_DELL_XPS_13] = { 8538 .type = HDA_FIXUP_FUNC, 8539 .v.func = alc_fixup_dell_xps13, 8540 .chained = true, 8541 .chain_id = ALC288_FIXUP_DISABLE_AAMIX 8542 }, 8543 [ALC292_FIXUP_DISABLE_AAMIX] = { 8544 .type = HDA_FIXUP_FUNC, 8545 .v.func = alc_fixup_disable_aamix, 8546 .chained = true, 8547 .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE 8548 }, 8549 [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = { 8550 .type = HDA_FIXUP_FUNC, 8551 .v.func = alc_fixup_disable_aamix, 8552 .chained = true, 8553 .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE 8554 }, 8555 [ALC292_FIXUP_DELL_E7X_AAMIX] = { 8556 .type = HDA_FIXUP_FUNC, 8557 .v.func = alc_fixup_dell_xps13, 8558 .chained = true, 8559 .chain_id = ALC292_FIXUP_DISABLE_AAMIX 8560 }, 8561 [ALC292_FIXUP_DELL_E7X] = { 8562 .type = HDA_FIXUP_FUNC, 8563 .v.func = alc_fixup_micmute_led, 8564 /* micmute fixup must be applied at last */ 8565 .chained_before = true, 8566 .chain_id = ALC292_FIXUP_DELL_E7X_AAMIX, 8567 }, 8568 [ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE] = { 8569 .type = HDA_FIXUP_PINS, 8570 .v.pins = (const struct hda_pintbl[]) { 8571 { 0x18, 0x01a1913c }, /* headset mic w/o jack detect */ 8572 { } 8573 }, 8574 .chained_before = true, 8575 .chain_id = ALC269_FIXUP_HEADSET_MODE, 8576 }, 8577 [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = { 8578 .type = HDA_FIXUP_PINS, 8579 .v.pins = (const struct hda_pintbl[]) { 8580 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8581 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 8582 { } 8583 }, 8584 .chained = true, 8585 .chain_id = ALC269_FIXUP_HEADSET_MODE 8586 }, 8587 [ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = { 8588 .type = HDA_FIXUP_PINS, 8589 .v.pins = (const struct hda_pintbl[]) { 8590 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8591 { } 8592 }, 8593 .chained = true, 8594 .chain_id = ALC269_FIXUP_HEADSET_MODE 8595 }, 8596 [ALC275_FIXUP_DELL_XPS] = { 8597 .type = HDA_FIXUP_VERBS, 8598 .v.verbs = (const struct hda_verb[]) { 8599 /* Enables internal speaker */ 8600 {0x20, AC_VERB_SET_COEF_INDEX, 0x1f}, 8601 {0x20, AC_VERB_SET_PROC_COEF, 0x00c0}, 8602 {0x20, AC_VERB_SET_COEF_INDEX, 0x30}, 8603 {0x20, AC_VERB_SET_PROC_COEF, 0x00b1}, 8604 {} 8605 } 8606 }, 8607 [ALC293_FIXUP_LENOVO_SPK_NOISE] = { 8608 .type = HDA_FIXUP_FUNC, 8609 .v.func = alc_fixup_disable_aamix, 8610 .chained = true, 8611 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 8612 }, 8613 [ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = { 8614 .type = HDA_FIXUP_FUNC, 8615 .v.func = alc233_fixup_lenovo_line2_mic_hotkey, 8616 }, 8617 [ALC233_FIXUP_INTEL_NUC8_DMIC] = { 8618 .type = HDA_FIXUP_FUNC, 8619 .v.func = alc_fixup_inv_dmic, 8620 .chained = true, 8621 .chain_id = ALC233_FIXUP_INTEL_NUC8_BOOST, 8622 }, 8623 [ALC233_FIXUP_INTEL_NUC8_BOOST] = { 8624 .type = HDA_FIXUP_FUNC, 8625 .v.func = alc269_fixup_limit_int_mic_boost 8626 }, 8627 [ALC255_FIXUP_DELL_SPK_NOISE] = { 8628 .type = HDA_FIXUP_FUNC, 8629 .v.func = alc_fixup_disable_aamix, 8630 .chained = true, 8631 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE 8632 }, 8633 [ALC225_FIXUP_DISABLE_MIC_VREF] = { 8634 .type = HDA_FIXUP_FUNC, 8635 .v.func = alc_fixup_disable_mic_vref, 8636 .chained = true, 8637 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE 8638 }, 8639 [ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = { 8640 .type = HDA_FIXUP_VERBS, 8641 .v.verbs = (const struct hda_verb[]) { 8642 /* Disable pass-through path for FRONT 14h */ 8643 { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 }, 8644 { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 }, 8645 {} 8646 }, 8647 .chained = true, 8648 .chain_id = ALC225_FIXUP_DISABLE_MIC_VREF 8649 }, 8650 [ALC280_FIXUP_HP_HEADSET_MIC] = { 8651 .type = HDA_FIXUP_FUNC, 8652 .v.func = alc_fixup_disable_aamix, 8653 .chained = true, 8654 .chain_id = ALC269_FIXUP_HEADSET_MIC, 8655 }, 8656 [ALC221_FIXUP_HP_FRONT_MIC] = { 8657 .type = HDA_FIXUP_PINS, 8658 .v.pins = (const struct hda_pintbl[]) { 8659 { 0x19, 0x02a19020 }, /* Front Mic */ 8660 { } 8661 }, 8662 }, 8663 [ALC292_FIXUP_TPT460] = { 8664 .type = HDA_FIXUP_FUNC, 8665 .v.func = alc_fixup_tpt440_dock, 8666 .chained = true, 8667 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE, 8668 }, 8669 [ALC298_FIXUP_SPK_VOLUME] = { 8670 .type = HDA_FIXUP_FUNC, 8671 .v.func = alc298_fixup_speaker_volume, 8672 .chained = true, 8673 .chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, 8674 }, 8675 [ALC298_FIXUP_LENOVO_SPK_VOLUME] = { 8676 .type = HDA_FIXUP_FUNC, 8677 .v.func = alc298_fixup_speaker_volume, 8678 }, 8679 [ALC295_FIXUP_DISABLE_DAC3] = { 8680 .type = HDA_FIXUP_FUNC, 8681 .v.func = alc295_fixup_disable_dac3, 8682 }, 8683 [ALC285_FIXUP_SPEAKER2_TO_DAC1] = { 8684 .type = HDA_FIXUP_FUNC, 8685 .v.func = alc285_fixup_speaker2_to_dac1, 8686 .chained = true, 8687 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 8688 }, 8689 [ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1] = { 8690 .type = HDA_FIXUP_FUNC, 8691 .v.func = alc285_fixup_speaker2_to_dac1, 8692 .chained = true, 8693 .chain_id = ALC245_FIXUP_CS35L41_SPI_2 8694 }, 8695 [ALC285_FIXUP_ASUS_HEADSET_MIC] = { 8696 .type = HDA_FIXUP_PINS, 8697 .v.pins = (const struct hda_pintbl[]) { 8698 { 0x19, 0x03a11050 }, 8699 { 0x1b, 0x03a11c30 }, 8700 { } 8701 }, 8702 .chained = true, 8703 .chain_id = ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1 8704 }, 8705 [ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS] = { 8706 .type = HDA_FIXUP_PINS, 8707 .v.pins = (const struct hda_pintbl[]) { 8708 { 0x14, 0x90170120 }, 8709 { } 8710 }, 8711 .chained = true, 8712 .chain_id = ALC285_FIXUP_ASUS_HEADSET_MIC 8713 }, 8714 [ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1] = { 8715 .type = HDA_FIXUP_FUNC, 8716 .v.func = alc285_fixup_speaker2_to_dac1, 8717 .chained = true, 8718 .chain_id = ALC287_FIXUP_CS35L41_I2C_2 8719 }, 8720 [ALC285_FIXUP_ASUS_I2C_HEADSET_MIC] = { 8721 .type = HDA_FIXUP_PINS, 8722 .v.pins = (const struct hda_pintbl[]) { 8723 { 0x19, 0x03a11050 }, 8724 { 0x1b, 0x03a11c30 }, 8725 { } 8726 }, 8727 .chained = true, 8728 .chain_id = ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1 8729 }, 8730 [ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = { 8731 .type = HDA_FIXUP_PINS, 8732 .v.pins = (const struct hda_pintbl[]) { 8733 { 0x1b, 0x90170151 }, 8734 { } 8735 }, 8736 .chained = true, 8737 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE 8738 }, 8739 [ALC269_FIXUP_ATIV_BOOK_8] = { 8740 .type = HDA_FIXUP_FUNC, 8741 .v.func = alc_fixup_auto_mute_via_amp, 8742 .chained = true, 8743 .chain_id = ALC269_FIXUP_NO_SHUTUP 8744 }, 8745 [ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE] = { 8746 .type = HDA_FIXUP_PINS, 8747 .v.pins = (const struct hda_pintbl[]) { 8748 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8749 { 0x1a, 0x01813030 }, /* use as headphone mic, without its own jack detect */ 8750 { } 8751 }, 8752 .chained = true, 8753 .chain_id = ALC269_FIXUP_HEADSET_MODE 8754 }, 8755 [ALC221_FIXUP_HP_MIC_NO_PRESENCE] = { 8756 .type = HDA_FIXUP_PINS, 8757 .v.pins = (const struct hda_pintbl[]) { 8758 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8759 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 8760 { } 8761 }, 8762 .chained = true, 8763 .chain_id = ALC269_FIXUP_HEADSET_MODE 8764 }, 8765 [ALC256_FIXUP_ASUS_HEADSET_MODE] = { 8766 .type = HDA_FIXUP_FUNC, 8767 .v.func = alc_fixup_headset_mode, 8768 }, 8769 [ALC256_FIXUP_ASUS_MIC] = { 8770 .type = HDA_FIXUP_PINS, 8771 .v.pins = (const struct hda_pintbl[]) { 8772 { 0x13, 0x90a60160 }, /* use as internal mic */ 8773 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */ 8774 { } 8775 }, 8776 .chained = true, 8777 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 8778 }, 8779 [ALC256_FIXUP_ASUS_AIO_GPIO2] = { 8780 .type = HDA_FIXUP_FUNC, 8781 /* Set up GPIO2 for the speaker amp */ 8782 .v.func = alc_fixup_gpio4, 8783 }, 8784 [ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = { 8785 .type = HDA_FIXUP_PINS, 8786 .v.pins = (const struct hda_pintbl[]) { 8787 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8788 { } 8789 }, 8790 .chained = true, 8791 .chain_id = ALC269_FIXUP_HEADSET_MIC 8792 }, 8793 [ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = { 8794 .type = HDA_FIXUP_VERBS, 8795 .v.verbs = (const struct hda_verb[]) { 8796 /* Enables internal speaker */ 8797 {0x20, AC_VERB_SET_COEF_INDEX, 0x40}, 8798 {0x20, AC_VERB_SET_PROC_COEF, 0x8800}, 8799 {} 8800 }, 8801 .chained = true, 8802 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE 8803 }, 8804 [ALC233_FIXUP_LENOVO_MULTI_CODECS] = { 8805 .type = HDA_FIXUP_FUNC, 8806 .v.func = alc233_alc662_fixup_lenovo_dual_codecs, 8807 .chained = true, 8808 .chain_id = ALC269_FIXUP_GPIO2 8809 }, 8810 [ALC233_FIXUP_ACER_HEADSET_MIC] = { 8811 .type = HDA_FIXUP_VERBS, 8812 .v.verbs = (const struct hda_verb[]) { 8813 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 }, 8814 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 }, 8815 { } 8816 }, 8817 .chained = true, 8818 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE 8819 }, 8820 [ALC294_FIXUP_LENOVO_MIC_LOCATION] = { 8821 .type = HDA_FIXUP_PINS, 8822 .v.pins = (const struct hda_pintbl[]) { 8823 /* Change the mic location from front to right, otherwise there are 8824 two front mics with the same name, pulseaudio can't handle them. 8825 This is just a temporary workaround, after applying this fixup, 8826 there will be one "Front Mic" and one "Mic" in this machine. 8827 */ 8828 { 0x1a, 0x04a19040 }, 8829 { } 8830 }, 8831 }, 8832 [ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = { 8833 .type = HDA_FIXUP_PINS, 8834 .v.pins = (const struct hda_pintbl[]) { 8835 { 0x16, 0x0101102f }, /* Rear Headset HP */ 8836 { 0x19, 0x02a1913c }, /* use as Front headset mic, without its own jack detect */ 8837 { 0x1a, 0x01a19030 }, /* Rear Headset MIC */ 8838 { 0x1b, 0x02011020 }, 8839 { } 8840 }, 8841 .chained = true, 8842 .chain_id = ALC225_FIXUP_S3_POP_NOISE 8843 }, 8844 [ALC225_FIXUP_S3_POP_NOISE] = { 8845 .type = HDA_FIXUP_FUNC, 8846 .v.func = alc225_fixup_s3_pop_noise, 8847 .chained = true, 8848 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 8849 }, 8850 [ALC700_FIXUP_INTEL_REFERENCE] = { 8851 .type = HDA_FIXUP_VERBS, 8852 .v.verbs = (const struct hda_verb[]) { 8853 /* Enables internal speaker */ 8854 {0x20, AC_VERB_SET_COEF_INDEX, 0x45}, 8855 {0x20, AC_VERB_SET_PROC_COEF, 0x5289}, 8856 {0x20, AC_VERB_SET_COEF_INDEX, 0x4A}, 8857 {0x20, AC_VERB_SET_PROC_COEF, 0x001b}, 8858 {0x58, AC_VERB_SET_COEF_INDEX, 0x00}, 8859 {0x58, AC_VERB_SET_PROC_COEF, 0x3888}, 8860 {0x20, AC_VERB_SET_COEF_INDEX, 0x6f}, 8861 {0x20, AC_VERB_SET_PROC_COEF, 0x2c0b}, 8862 {} 8863 } 8864 }, 8865 [ALC274_FIXUP_DELL_BIND_DACS] = { 8866 .type = HDA_FIXUP_FUNC, 8867 .v.func = alc274_fixup_bind_dacs, 8868 .chained = true, 8869 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE 8870 }, 8871 [ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = { 8872 .type = HDA_FIXUP_PINS, 8873 .v.pins = (const struct hda_pintbl[]) { 8874 { 0x1b, 0x0401102f }, 8875 { } 8876 }, 8877 .chained = true, 8878 .chain_id = ALC274_FIXUP_DELL_BIND_DACS 8879 }, 8880 [ALC298_FIXUP_TPT470_DOCK_FIX] = { 8881 .type = HDA_FIXUP_FUNC, 8882 .v.func = alc_fixup_tpt470_dock, 8883 .chained = true, 8884 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE 8885 }, 8886 [ALC298_FIXUP_TPT470_DOCK] = { 8887 .type = HDA_FIXUP_FUNC, 8888 .v.func = alc_fixup_tpt470_dacs, 8889 .chained = true, 8890 .chain_id = ALC298_FIXUP_TPT470_DOCK_FIX 8891 }, 8892 [ALC255_FIXUP_DUMMY_LINEOUT_VERB] = { 8893 .type = HDA_FIXUP_PINS, 8894 .v.pins = (const struct hda_pintbl[]) { 8895 { 0x14, 0x0201101f }, 8896 { } 8897 }, 8898 .chained = true, 8899 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE 8900 }, 8901 [ALC255_FIXUP_DELL_HEADSET_MIC] = { 8902 .type = HDA_FIXUP_PINS, 8903 .v.pins = (const struct hda_pintbl[]) { 8904 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8905 { } 8906 }, 8907 .chained = true, 8908 .chain_id = ALC269_FIXUP_HEADSET_MIC 8909 }, 8910 [ALC295_FIXUP_HP_X360] = { 8911 .type = HDA_FIXUP_FUNC, 8912 .v.func = alc295_fixup_hp_top_speakers, 8913 .chained = true, 8914 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3 8915 }, 8916 [ALC221_FIXUP_HP_HEADSET_MIC] = { 8917 .type = HDA_FIXUP_PINS, 8918 .v.pins = (const struct hda_pintbl[]) { 8919 { 0x19, 0x0181313f}, 8920 { } 8921 }, 8922 .chained = true, 8923 .chain_id = ALC269_FIXUP_HEADSET_MIC 8924 }, 8925 [ALC285_FIXUP_LENOVO_HEADPHONE_NOISE] = { 8926 .type = HDA_FIXUP_FUNC, 8927 .v.func = alc285_fixup_invalidate_dacs, 8928 .chained = true, 8929 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 8930 }, 8931 [ALC295_FIXUP_HP_AUTO_MUTE] = { 8932 .type = HDA_FIXUP_FUNC, 8933 .v.func = alc_fixup_auto_mute_via_amp, 8934 }, 8935 [ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE] = { 8936 .type = HDA_FIXUP_PINS, 8937 .v.pins = (const struct hda_pintbl[]) { 8938 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8939 { } 8940 }, 8941 .chained = true, 8942 .chain_id = ALC269_FIXUP_HEADSET_MIC 8943 }, 8944 [ALC294_FIXUP_ASUS_MIC] = { 8945 .type = HDA_FIXUP_PINS, 8946 .v.pins = (const struct hda_pintbl[]) { 8947 { 0x13, 0x90a60160 }, /* use as internal mic */ 8948 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */ 8949 { } 8950 }, 8951 .chained = true, 8952 .chain_id = ALC269_FIXUP_HEADSET_MIC 8953 }, 8954 [ALC294_FIXUP_ASUS_HEADSET_MIC] = { 8955 .type = HDA_FIXUP_PINS, 8956 .v.pins = (const struct hda_pintbl[]) { 8957 { 0x19, 0x01a1103c }, /* use as headset mic */ 8958 { } 8959 }, 8960 .chained = true, 8961 .chain_id = ALC269_FIXUP_HEADSET_MIC 8962 }, 8963 [ALC294_FIXUP_ASUS_SPK] = { 8964 .type = HDA_FIXUP_VERBS, 8965 .v.verbs = (const struct hda_verb[]) { 8966 /* Set EAPD high */ 8967 { 0x20, AC_VERB_SET_COEF_INDEX, 0x40 }, 8968 { 0x20, AC_VERB_SET_PROC_COEF, 0x8800 }, 8969 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f }, 8970 { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 }, 8971 { } 8972 }, 8973 .chained = true, 8974 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC 8975 }, 8976 [ALC295_FIXUP_CHROME_BOOK] = { 8977 .type = HDA_FIXUP_FUNC, 8978 .v.func = alc295_fixup_chromebook, 8979 .chained = true, 8980 .chain_id = ALC225_FIXUP_HEADSET_JACK 8981 }, 8982 [ALC225_FIXUP_HEADSET_JACK] = { 8983 .type = HDA_FIXUP_FUNC, 8984 .v.func = alc_fixup_headset_jack, 8985 }, 8986 [ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = { 8987 .type = HDA_FIXUP_PINS, 8988 .v.pins = (const struct hda_pintbl[]) { 8989 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8990 { } 8991 }, 8992 .chained = true, 8993 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 8994 }, 8995 [ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE] = { 8996 .type = HDA_FIXUP_VERBS, 8997 .v.verbs = (const struct hda_verb[]) { 8998 /* Disable PCBEEP-IN passthrough */ 8999 { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 }, 9000 { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 }, 9001 { } 9002 }, 9003 .chained = true, 9004 .chain_id = ALC285_FIXUP_LENOVO_HEADPHONE_NOISE 9005 }, 9006 [ALC255_FIXUP_ACER_HEADSET_MIC] = { 9007 .type = HDA_FIXUP_PINS, 9008 .v.pins = (const struct hda_pintbl[]) { 9009 { 0x19, 0x03a11130 }, 9010 { 0x1a, 0x90a60140 }, /* use as internal mic */ 9011 { } 9012 }, 9013 .chained = true, 9014 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC 9015 }, 9016 [ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE] = { 9017 .type = HDA_FIXUP_PINS, 9018 .v.pins = (const struct hda_pintbl[]) { 9019 { 0x16, 0x01011020 }, /* Rear Line out */ 9020 { 0x19, 0x01a1913c }, /* use as Front headset mic, without its own jack detect */ 9021 { } 9022 }, 9023 .chained = true, 9024 .chain_id = ALC225_FIXUP_WYSE_AUTO_MUTE 9025 }, 9026 [ALC225_FIXUP_WYSE_AUTO_MUTE] = { 9027 .type = HDA_FIXUP_FUNC, 9028 .v.func = alc_fixup_auto_mute_via_amp, 9029 .chained = true, 9030 .chain_id = ALC225_FIXUP_WYSE_DISABLE_MIC_VREF 9031 }, 9032 [ALC225_FIXUP_WYSE_DISABLE_MIC_VREF] = { 9033 .type = HDA_FIXUP_FUNC, 9034 .v.func = alc_fixup_disable_mic_vref, 9035 .chained = true, 9036 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 9037 }, 9038 [ALC286_FIXUP_ACER_AIO_HEADSET_MIC] = { 9039 .type = HDA_FIXUP_VERBS, 9040 .v.verbs = (const struct hda_verb[]) { 9041 { 0x20, AC_VERB_SET_COEF_INDEX, 0x4f }, 9042 { 0x20, AC_VERB_SET_PROC_COEF, 0x5029 }, 9043 { } 9044 }, 9045 .chained = true, 9046 .chain_id = ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE 9047 }, 9048 [ALC256_FIXUP_ASUS_HEADSET_MIC] = { 9049 .type = HDA_FIXUP_PINS, 9050 .v.pins = (const struct hda_pintbl[]) { 9051 { 0x19, 0x03a11020 }, /* headset mic with jack detect */ 9052 { } 9053 }, 9054 .chained = true, 9055 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 9056 }, 9057 [ALC256_FIXUP_ASUS_MIC_NO_PRESENCE] = { 9058 .type = HDA_FIXUP_PINS, 9059 .v.pins = (const struct hda_pintbl[]) { 9060 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */ 9061 { } 9062 }, 9063 .chained = true, 9064 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 9065 }, 9066 [ALC299_FIXUP_PREDATOR_SPK] = { 9067 .type = HDA_FIXUP_PINS, 9068 .v.pins = (const struct hda_pintbl[]) { 9069 { 0x21, 0x90170150 }, /* use as headset mic, without its own jack detect */ 9070 { } 9071 } 9072 }, 9073 [ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = { 9074 .type = HDA_FIXUP_PINS, 9075 .v.pins = (const struct hda_pintbl[]) { 9076 { 0x19, 0x04a11040 }, 9077 { 0x21, 0x04211020 }, 9078 { } 9079 }, 9080 .chained = true, 9081 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 9082 }, 9083 [ALC289_FIXUP_DELL_SPK1] = { 9084 .type = HDA_FIXUP_PINS, 9085 .v.pins = (const struct hda_pintbl[]) { 9086 { 0x14, 0x90170140 }, 9087 { } 9088 }, 9089 .chained = true, 9090 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE 9091 }, 9092 [ALC289_FIXUP_DELL_SPK2] = { 9093 .type = HDA_FIXUP_PINS, 9094 .v.pins = (const struct hda_pintbl[]) { 9095 { 0x17, 0x90170130 }, /* bass spk */ 9096 { } 9097 }, 9098 .chained = true, 9099 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE 9100 }, 9101 [ALC289_FIXUP_DUAL_SPK] = { 9102 .type = HDA_FIXUP_FUNC, 9103 .v.func = alc285_fixup_speaker2_to_dac1, 9104 .chained = true, 9105 .chain_id = ALC289_FIXUP_DELL_SPK2 9106 }, 9107 [ALC289_FIXUP_RTK_AMP_DUAL_SPK] = { 9108 .type = HDA_FIXUP_FUNC, 9109 .v.func = alc285_fixup_speaker2_to_dac1, 9110 .chained = true, 9111 .chain_id = ALC289_FIXUP_DELL_SPK1 9112 }, 9113 [ALC294_FIXUP_SPK2_TO_DAC1] = { 9114 .type = HDA_FIXUP_FUNC, 9115 .v.func = alc285_fixup_speaker2_to_dac1, 9116 .chained = true, 9117 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC 9118 }, 9119 [ALC294_FIXUP_ASUS_DUAL_SPK] = { 9120 .type = HDA_FIXUP_FUNC, 9121 /* The GPIO must be pulled to initialize the AMP */ 9122 .v.func = alc_fixup_gpio4, 9123 .chained = true, 9124 .chain_id = ALC294_FIXUP_SPK2_TO_DAC1 9125 }, 9126 [ALC294_FIXUP_ASUS_ALLY] = { 9127 .type = HDA_FIXUP_FUNC, 9128 .v.func = cs35l41_fixup_i2c_two, 9129 .chained = true, 9130 .chain_id = ALC294_FIXUP_ASUS_ALLY_PINS 9131 }, 9132 [ALC294_FIXUP_ASUS_ALLY_X] = { 9133 .type = HDA_FIXUP_FUNC, 9134 .v.func = tas2781_fixup_i2c, 9135 .chained = true, 9136 .chain_id = ALC294_FIXUP_ASUS_ALLY_PINS 9137 }, 9138 [ALC294_FIXUP_ASUS_ALLY_PINS] = { 9139 .type = HDA_FIXUP_PINS, 9140 .v.pins = (const struct hda_pintbl[]) { 9141 { 0x19, 0x03a11050 }, 9142 { 0x1a, 0x03a11c30 }, 9143 { 0x21, 0x03211420 }, 9144 { } 9145 }, 9146 .chained = true, 9147 .chain_id = ALC294_FIXUP_ASUS_ALLY_VERBS 9148 }, 9149 [ALC294_FIXUP_ASUS_ALLY_VERBS] = { 9150 .type = HDA_FIXUP_VERBS, 9151 .v.verbs = (const struct hda_verb[]) { 9152 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 }, 9153 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 }, 9154 { 0x20, AC_VERB_SET_COEF_INDEX, 0x46 }, 9155 { 0x20, AC_VERB_SET_PROC_COEF, 0x0004 }, 9156 { 0x20, AC_VERB_SET_COEF_INDEX, 0x47 }, 9157 { 0x20, AC_VERB_SET_PROC_COEF, 0xa47a }, 9158 { 0x20, AC_VERB_SET_COEF_INDEX, 0x49 }, 9159 { 0x20, AC_VERB_SET_PROC_COEF, 0x0049}, 9160 { 0x20, AC_VERB_SET_COEF_INDEX, 0x4a }, 9161 { 0x20, AC_VERB_SET_PROC_COEF, 0x201b }, 9162 { 0x20, AC_VERB_SET_COEF_INDEX, 0x6b }, 9163 { 0x20, AC_VERB_SET_PROC_COEF, 0x4278}, 9164 { } 9165 }, 9166 .chained = true, 9167 .chain_id = ALC294_FIXUP_ASUS_ALLY_SPEAKER 9168 }, 9169 [ALC294_FIXUP_ASUS_ALLY_SPEAKER] = { 9170 .type = HDA_FIXUP_FUNC, 9171 .v.func = alc285_fixup_speaker2_to_dac1, 9172 }, 9173 [ALC285_FIXUP_THINKPAD_X1_GEN7] = { 9174 .type = HDA_FIXUP_FUNC, 9175 .v.func = alc285_fixup_thinkpad_x1_gen7, 9176 .chained = true, 9177 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 9178 }, 9179 [ALC285_FIXUP_THINKPAD_HEADSET_JACK] = { 9180 .type = HDA_FIXUP_FUNC, 9181 .v.func = alc_fixup_headset_jack, 9182 .chained = true, 9183 .chain_id = ALC285_FIXUP_THINKPAD_X1_GEN7 9184 }, 9185 [ALC294_FIXUP_ASUS_HPE] = { 9186 .type = HDA_FIXUP_VERBS, 9187 .v.verbs = (const struct hda_verb[]) { 9188 /* Set EAPD high */ 9189 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f }, 9190 { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 }, 9191 { } 9192 }, 9193 .chained = true, 9194 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC 9195 }, 9196 [ALC294_FIXUP_ASUS_GX502_PINS] = { 9197 .type = HDA_FIXUP_PINS, 9198 .v.pins = (const struct hda_pintbl[]) { 9199 { 0x19, 0x03a11050 }, /* front HP mic */ 9200 { 0x1a, 0x01a11830 }, /* rear external mic */ 9201 { 0x21, 0x03211020 }, /* front HP out */ 9202 { } 9203 }, 9204 .chained = true, 9205 .chain_id = ALC294_FIXUP_ASUS_GX502_VERBS 9206 }, 9207 [ALC294_FIXUP_ASUS_GX502_VERBS] = { 9208 .type = HDA_FIXUP_VERBS, 9209 .v.verbs = (const struct hda_verb[]) { 9210 /* set 0x15 to HP-OUT ctrl */ 9211 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 9212 /* unmute the 0x15 amp */ 9213 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 }, 9214 { } 9215 }, 9216 .chained = true, 9217 .chain_id = ALC294_FIXUP_ASUS_GX502_HP 9218 }, 9219 [ALC294_FIXUP_ASUS_GX502_HP] = { 9220 .type = HDA_FIXUP_FUNC, 9221 .v.func = alc294_fixup_gx502_hp, 9222 }, 9223 [ALC294_FIXUP_ASUS_GU502_PINS] = { 9224 .type = HDA_FIXUP_PINS, 9225 .v.pins = (const struct hda_pintbl[]) { 9226 { 0x19, 0x01a11050 }, /* rear HP mic */ 9227 { 0x1a, 0x01a11830 }, /* rear external mic */ 9228 { 0x21, 0x012110f0 }, /* rear HP out */ 9229 { } 9230 }, 9231 .chained = true, 9232 .chain_id = ALC294_FIXUP_ASUS_GU502_VERBS 9233 }, 9234 [ALC294_FIXUP_ASUS_GU502_VERBS] = { 9235 .type = HDA_FIXUP_VERBS, 9236 .v.verbs = (const struct hda_verb[]) { 9237 /* set 0x15 to HP-OUT ctrl */ 9238 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 9239 /* unmute the 0x15 amp */ 9240 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 }, 9241 /* set 0x1b to HP-OUT */ 9242 { 0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 9243 { } 9244 }, 9245 .chained = true, 9246 .chain_id = ALC294_FIXUP_ASUS_GU502_HP 9247 }, 9248 [ALC294_FIXUP_ASUS_GU502_HP] = { 9249 .type = HDA_FIXUP_FUNC, 9250 .v.func = alc294_fixup_gu502_hp, 9251 }, 9252 [ALC294_FIXUP_ASUS_G513_PINS] = { 9253 .type = HDA_FIXUP_PINS, 9254 .v.pins = (const struct hda_pintbl[]) { 9255 { 0x19, 0x03a11050 }, /* front HP mic */ 9256 { 0x1a, 0x03a11c30 }, /* rear external mic */ 9257 { 0x21, 0x03211420 }, /* front HP out */ 9258 { } 9259 }, 9260 }, 9261 [ALC285_FIXUP_ASUS_G533Z_PINS] = { 9262 .type = HDA_FIXUP_PINS, 9263 .v.pins = (const struct hda_pintbl[]) { 9264 { 0x14, 0x90170152 }, /* Speaker Surround Playback Switch */ 9265 { 0x19, 0x03a19020 }, /* Mic Boost Volume */ 9266 { 0x1a, 0x03a11c30 }, /* Mic Boost Volume */ 9267 { 0x1e, 0x90170151 }, /* Rear jack, IN OUT EAPD Detect */ 9268 { 0x21, 0x03211420 }, 9269 { } 9270 }, 9271 }, 9272 [ALC294_FIXUP_ASUS_COEF_1B] = { 9273 .type = HDA_FIXUP_VERBS, 9274 .v.verbs = (const struct hda_verb[]) { 9275 /* Set bit 10 to correct noisy output after reboot from 9276 * Windows 10 (due to pop noise reduction?) 9277 */ 9278 { 0x20, AC_VERB_SET_COEF_INDEX, 0x1b }, 9279 { 0x20, AC_VERB_SET_PROC_COEF, 0x4e4b }, 9280 { } 9281 }, 9282 .chained = true, 9283 .chain_id = ALC289_FIXUP_ASUS_GA401, 9284 }, 9285 [ALC285_FIXUP_HP_GPIO_LED] = { 9286 .type = HDA_FIXUP_FUNC, 9287 .v.func = alc285_fixup_hp_gpio_led, 9288 }, 9289 [ALC285_FIXUP_HP_MUTE_LED] = { 9290 .type = HDA_FIXUP_FUNC, 9291 .v.func = alc285_fixup_hp_mute_led, 9292 }, 9293 [ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED] = { 9294 .type = HDA_FIXUP_FUNC, 9295 .v.func = alc285_fixup_hp_spectre_x360_mute_led, 9296 }, 9297 [ALC236_FIXUP_HP_MUTE_LED_COEFBIT2] = { 9298 .type = HDA_FIXUP_FUNC, 9299 .v.func = alc236_fixup_hp_mute_led_coefbit2, 9300 }, 9301 [ALC236_FIXUP_HP_GPIO_LED] = { 9302 .type = HDA_FIXUP_FUNC, 9303 .v.func = alc236_fixup_hp_gpio_led, 9304 }, 9305 [ALC236_FIXUP_HP_MUTE_LED] = { 9306 .type = HDA_FIXUP_FUNC, 9307 .v.func = alc236_fixup_hp_mute_led, 9308 }, 9309 [ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF] = { 9310 .type = HDA_FIXUP_FUNC, 9311 .v.func = alc236_fixup_hp_mute_led_micmute_vref, 9312 }, 9313 [ALC236_FIXUP_LENOVO_INV_DMIC] = { 9314 .type = HDA_FIXUP_FUNC, 9315 .v.func = alc_fixup_inv_dmic, 9316 .chained = true, 9317 .chain_id = ALC283_FIXUP_INT_MIC, 9318 }, 9319 [ALC298_FIXUP_SAMSUNG_AMP] = { 9320 .type = HDA_FIXUP_FUNC, 9321 .v.func = alc298_fixup_samsung_amp, 9322 .chained = true, 9323 .chain_id = ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET 9324 }, 9325 [ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS] = { 9326 .type = HDA_FIXUP_FUNC, 9327 .v.func = alc298_fixup_samsung_amp_v2_2_amps 9328 }, 9329 [ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS] = { 9330 .type = HDA_FIXUP_FUNC, 9331 .v.func = alc298_fixup_samsung_amp_v2_4_amps 9332 }, 9333 [ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = { 9334 .type = HDA_FIXUP_VERBS, 9335 .v.verbs = (const struct hda_verb[]) { 9336 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc5 }, 9337 { } 9338 }, 9339 }, 9340 [ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = { 9341 .type = HDA_FIXUP_VERBS, 9342 .v.verbs = (const struct hda_verb[]) { 9343 { 0x20, AC_VERB_SET_COEF_INDEX, 0x08}, 9344 { 0x20, AC_VERB_SET_PROC_COEF, 0x2fcf}, 9345 { } 9346 }, 9347 }, 9348 [ALC295_FIXUP_ASUS_MIC_NO_PRESENCE] = { 9349 .type = HDA_FIXUP_PINS, 9350 .v.pins = (const struct hda_pintbl[]) { 9351 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 9352 { } 9353 }, 9354 .chained = true, 9355 .chain_id = ALC269_FIXUP_HEADSET_MODE 9356 }, 9357 [ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS] = { 9358 .type = HDA_FIXUP_PINS, 9359 .v.pins = (const struct hda_pintbl[]) { 9360 { 0x14, 0x90100120 }, /* use as internal speaker */ 9361 { 0x18, 0x02a111f0 }, /* use as headset mic, without its own jack detect */ 9362 { 0x1a, 0x01011020 }, /* use as line out */ 9363 { }, 9364 }, 9365 .chained = true, 9366 .chain_id = ALC269_FIXUP_HEADSET_MIC 9367 }, 9368 [ALC269VC_FIXUP_ACER_HEADSET_MIC] = { 9369 .type = HDA_FIXUP_PINS, 9370 .v.pins = (const struct hda_pintbl[]) { 9371 { 0x18, 0x02a11030 }, /* use as headset mic */ 9372 { } 9373 }, 9374 .chained = true, 9375 .chain_id = ALC269_FIXUP_HEADSET_MIC 9376 }, 9377 [ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE] = { 9378 .type = HDA_FIXUP_PINS, 9379 .v.pins = (const struct hda_pintbl[]) { 9380 { 0x18, 0x01a11130 }, /* use as headset mic, without its own jack detect */ 9381 { } 9382 }, 9383 .chained = true, 9384 .chain_id = ALC269_FIXUP_HEADSET_MIC 9385 }, 9386 [ALC289_FIXUP_ASUS_GA401] = { 9387 .type = HDA_FIXUP_FUNC, 9388 .v.func = alc289_fixup_asus_ga401, 9389 .chained = true, 9390 .chain_id = ALC289_FIXUP_ASUS_GA502, 9391 }, 9392 [ALC289_FIXUP_ASUS_GA502] = { 9393 .type = HDA_FIXUP_PINS, 9394 .v.pins = (const struct hda_pintbl[]) { 9395 { 0x19, 0x03a11020 }, /* headset mic with jack detect */ 9396 { } 9397 }, 9398 }, 9399 [ALC256_FIXUP_ACER_MIC_NO_PRESENCE] = { 9400 .type = HDA_FIXUP_PINS, 9401 .v.pins = (const struct hda_pintbl[]) { 9402 { 0x19, 0x02a11120 }, /* use as headset mic, without its own jack detect */ 9403 { } 9404 }, 9405 .chained = true, 9406 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 9407 }, 9408 [ALC285_FIXUP_HP_GPIO_AMP_INIT] = { 9409 .type = HDA_FIXUP_FUNC, 9410 .v.func = alc285_fixup_hp_gpio_amp_init, 9411 .chained = true, 9412 .chain_id = ALC285_FIXUP_HP_GPIO_LED 9413 }, 9414 [ALC269_FIXUP_CZC_B20] = { 9415 .type = HDA_FIXUP_PINS, 9416 .v.pins = (const struct hda_pintbl[]) { 9417 { 0x12, 0x411111f0 }, 9418 { 0x14, 0x90170110 }, /* speaker */ 9419 { 0x15, 0x032f1020 }, /* HP out */ 9420 { 0x17, 0x411111f0 }, 9421 { 0x18, 0x03ab1040 }, /* mic */ 9422 { 0x19, 0xb7a7013f }, 9423 { 0x1a, 0x0181305f }, 9424 { 0x1b, 0x411111f0 }, 9425 { 0x1d, 0x411111f0 }, 9426 { 0x1e, 0x411111f0 }, 9427 { } 9428 }, 9429 .chain_id = ALC269_FIXUP_DMIC, 9430 }, 9431 [ALC269_FIXUP_CZC_TMI] = { 9432 .type = HDA_FIXUP_PINS, 9433 .v.pins = (const struct hda_pintbl[]) { 9434 { 0x12, 0x4000c000 }, 9435 { 0x14, 0x90170110 }, /* speaker */ 9436 { 0x15, 0x0421401f }, /* HP out */ 9437 { 0x17, 0x411111f0 }, 9438 { 0x18, 0x04a19020 }, /* mic */ 9439 { 0x19, 0x411111f0 }, 9440 { 0x1a, 0x411111f0 }, 9441 { 0x1b, 0x411111f0 }, 9442 { 0x1d, 0x40448505 }, 9443 { 0x1e, 0x411111f0 }, 9444 { 0x20, 0x8000ffff }, 9445 { } 9446 }, 9447 .chain_id = ALC269_FIXUP_DMIC, 9448 }, 9449 [ALC269_FIXUP_CZC_L101] = { 9450 .type = HDA_FIXUP_PINS, 9451 .v.pins = (const struct hda_pintbl[]) { 9452 { 0x12, 0x40000000 }, 9453 { 0x14, 0x01014010 }, /* speaker */ 9454 { 0x15, 0x411111f0 }, /* HP out */ 9455 { 0x16, 0x411111f0 }, 9456 { 0x18, 0x01a19020 }, /* mic */ 9457 { 0x19, 0x02a19021 }, 9458 { 0x1a, 0x0181302f }, 9459 { 0x1b, 0x0221401f }, 9460 { 0x1c, 0x411111f0 }, 9461 { 0x1d, 0x4044c601 }, 9462 { 0x1e, 0x411111f0 }, 9463 { } 9464 }, 9465 .chain_id = ALC269_FIXUP_DMIC, 9466 }, 9467 [ALC269_FIXUP_LEMOTE_A1802] = { 9468 .type = HDA_FIXUP_PINS, 9469 .v.pins = (const struct hda_pintbl[]) { 9470 { 0x12, 0x40000000 }, 9471 { 0x14, 0x90170110 }, /* speaker */ 9472 { 0x17, 0x411111f0 }, 9473 { 0x18, 0x03a19040 }, /* mic1 */ 9474 { 0x19, 0x90a70130 }, /* mic2 */ 9475 { 0x1a, 0x411111f0 }, 9476 { 0x1b, 0x411111f0 }, 9477 { 0x1d, 0x40489d2d }, 9478 { 0x1e, 0x411111f0 }, 9479 { 0x20, 0x0003ffff }, 9480 { 0x21, 0x03214020 }, 9481 { } 9482 }, 9483 .chain_id = ALC269_FIXUP_DMIC, 9484 }, 9485 [ALC269_FIXUP_LEMOTE_A190X] = { 9486 .type = HDA_FIXUP_PINS, 9487 .v.pins = (const struct hda_pintbl[]) { 9488 { 0x14, 0x99130110 }, /* speaker */ 9489 { 0x15, 0x0121401f }, /* HP out */ 9490 { 0x18, 0x01a19c20 }, /* rear mic */ 9491 { 0x19, 0x99a3092f }, /* front mic */ 9492 { 0x1b, 0x0201401f }, /* front lineout */ 9493 { } 9494 }, 9495 .chain_id = ALC269_FIXUP_DMIC, 9496 }, 9497 [ALC256_FIXUP_INTEL_NUC8_RUGGED] = { 9498 .type = HDA_FIXUP_PINS, 9499 .v.pins = (const struct hda_pintbl[]) { 9500 { 0x1b, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 9501 { } 9502 }, 9503 .chained = true, 9504 .chain_id = ALC269_FIXUP_HEADSET_MODE 9505 }, 9506 [ALC256_FIXUP_INTEL_NUC10] = { 9507 .type = HDA_FIXUP_PINS, 9508 .v.pins = (const struct hda_pintbl[]) { 9509 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 9510 { } 9511 }, 9512 .chained = true, 9513 .chain_id = ALC269_FIXUP_HEADSET_MODE 9514 }, 9515 [ALC255_FIXUP_XIAOMI_HEADSET_MIC] = { 9516 .type = HDA_FIXUP_VERBS, 9517 .v.verbs = (const struct hda_verb[]) { 9518 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 }, 9519 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 }, 9520 { } 9521 }, 9522 .chained = true, 9523 .chain_id = ALC289_FIXUP_ASUS_GA502 9524 }, 9525 [ALC274_FIXUP_HP_MIC] = { 9526 .type = HDA_FIXUP_VERBS, 9527 .v.verbs = (const struct hda_verb[]) { 9528 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 }, 9529 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 }, 9530 { } 9531 }, 9532 }, 9533 [ALC274_FIXUP_HP_HEADSET_MIC] = { 9534 .type = HDA_FIXUP_FUNC, 9535 .v.func = alc274_fixup_hp_headset_mic, 9536 .chained = true, 9537 .chain_id = ALC274_FIXUP_HP_MIC 9538 }, 9539 [ALC274_FIXUP_HP_ENVY_GPIO] = { 9540 .type = HDA_FIXUP_FUNC, 9541 .v.func = alc274_fixup_hp_envy_gpio, 9542 }, 9543 [ALC256_FIXUP_ASUS_HPE] = { 9544 .type = HDA_FIXUP_VERBS, 9545 .v.verbs = (const struct hda_verb[]) { 9546 /* Set EAPD high */ 9547 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f }, 9548 { 0x20, AC_VERB_SET_PROC_COEF, 0x7778 }, 9549 { } 9550 }, 9551 .chained = true, 9552 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC 9553 }, 9554 [ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK] = { 9555 .type = HDA_FIXUP_FUNC, 9556 .v.func = alc_fixup_headset_jack, 9557 .chained = true, 9558 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 9559 }, 9560 [ALC287_FIXUP_HP_GPIO_LED] = { 9561 .type = HDA_FIXUP_FUNC, 9562 .v.func = alc287_fixup_hp_gpio_led, 9563 }, 9564 [ALC256_FIXUP_HP_HEADSET_MIC] = { 9565 .type = HDA_FIXUP_FUNC, 9566 .v.func = alc274_fixup_hp_headset_mic, 9567 }, 9568 [ALC236_FIXUP_DELL_AIO_HEADSET_MIC] = { 9569 .type = HDA_FIXUP_FUNC, 9570 .v.func = alc_fixup_no_int_mic, 9571 .chained = true, 9572 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE 9573 }, 9574 [ALC282_FIXUP_ACER_DISABLE_LINEOUT] = { 9575 .type = HDA_FIXUP_PINS, 9576 .v.pins = (const struct hda_pintbl[]) { 9577 { 0x1b, 0x411111f0 }, 9578 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 9579 { }, 9580 }, 9581 .chained = true, 9582 .chain_id = ALC269_FIXUP_HEADSET_MODE 9583 }, 9584 [ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST] = { 9585 .type = HDA_FIXUP_FUNC, 9586 .v.func = alc269_fixup_limit_int_mic_boost, 9587 .chained = true, 9588 .chain_id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, 9589 }, 9590 [ALC256_FIXUP_ACER_HEADSET_MIC] = { 9591 .type = HDA_FIXUP_PINS, 9592 .v.pins = (const struct hda_pintbl[]) { 9593 { 0x19, 0x02a1113c }, /* use as headset mic, without its own jack detect */ 9594 { 0x1a, 0x90a1092f }, /* use as internal mic */ 9595 { } 9596 }, 9597 .chained = true, 9598 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 9599 }, 9600 [ALC285_FIXUP_IDEAPAD_S740_COEF] = { 9601 .type = HDA_FIXUP_FUNC, 9602 .v.func = alc285_fixup_ideapad_s740_coef, 9603 .chained = true, 9604 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 9605 }, 9606 [ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST] = { 9607 .type = HDA_FIXUP_FUNC, 9608 .v.func = alc269_fixup_limit_int_mic_boost, 9609 .chained = true, 9610 .chain_id = ALC285_FIXUP_HP_MUTE_LED, 9611 }, 9612 [ALC295_FIXUP_ASUS_DACS] = { 9613 .type = HDA_FIXUP_FUNC, 9614 .v.func = alc295_fixup_asus_dacs, 9615 }, 9616 [ALC295_FIXUP_HP_OMEN] = { 9617 .type = HDA_FIXUP_PINS, 9618 .v.pins = (const struct hda_pintbl[]) { 9619 { 0x12, 0xb7a60130 }, 9620 { 0x13, 0x40000000 }, 9621 { 0x14, 0x411111f0 }, 9622 { 0x16, 0x411111f0 }, 9623 { 0x17, 0x90170110 }, 9624 { 0x18, 0x411111f0 }, 9625 { 0x19, 0x02a11030 }, 9626 { 0x1a, 0x411111f0 }, 9627 { 0x1b, 0x04a19030 }, 9628 { 0x1d, 0x40600001 }, 9629 { 0x1e, 0x411111f0 }, 9630 { 0x21, 0x03211020 }, 9631 {} 9632 }, 9633 .chained = true, 9634 .chain_id = ALC269_FIXUP_HP_LINE1_MIC1_LED, 9635 }, 9636 [ALC285_FIXUP_HP_SPECTRE_X360] = { 9637 .type = HDA_FIXUP_FUNC, 9638 .v.func = alc285_fixup_hp_spectre_x360, 9639 }, 9640 [ALC285_FIXUP_HP_SPECTRE_X360_EB1] = { 9641 .type = HDA_FIXUP_FUNC, 9642 .v.func = alc285_fixup_hp_spectre_x360_eb1 9643 }, 9644 [ALC285_FIXUP_HP_ENVY_X360] = { 9645 .type = HDA_FIXUP_FUNC, 9646 .v.func = alc285_fixup_hp_envy_x360, 9647 .chained = true, 9648 .chain_id = ALC285_FIXUP_HP_GPIO_AMP_INIT, 9649 }, 9650 [ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP] = { 9651 .type = HDA_FIXUP_FUNC, 9652 .v.func = alc285_fixup_ideapad_s740_coef, 9653 .chained = true, 9654 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK, 9655 }, 9656 [ALC623_FIXUP_LENOVO_THINKSTATION_P340] = { 9657 .type = HDA_FIXUP_FUNC, 9658 .v.func = alc_fixup_no_shutup, 9659 .chained = true, 9660 .chain_id = ALC283_FIXUP_HEADSET_MIC, 9661 }, 9662 [ALC255_FIXUP_ACER_HEADPHONE_AND_MIC] = { 9663 .type = HDA_FIXUP_PINS, 9664 .v.pins = (const struct hda_pintbl[]) { 9665 { 0x21, 0x03211030 }, /* Change the Headphone location to Left */ 9666 { } 9667 }, 9668 .chained = true, 9669 .chain_id = ALC255_FIXUP_XIAOMI_HEADSET_MIC 9670 }, 9671 [ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST] = { 9672 .type = HDA_FIXUP_FUNC, 9673 .v.func = alc269_fixup_limit_int_mic_boost, 9674 .chained = true, 9675 .chain_id = ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF, 9676 }, 9677 [ALC285_FIXUP_LEGION_Y9000X_SPEAKERS] = { 9678 .type = HDA_FIXUP_FUNC, 9679 .v.func = alc285_fixup_ideapad_s740_coef, 9680 .chained = true, 9681 .chain_id = ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE, 9682 }, 9683 [ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE] = { 9684 .type = HDA_FIXUP_FUNC, 9685 .v.func = alc287_fixup_legion_15imhg05_speakers, 9686 .chained = true, 9687 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 9688 }, 9689 [ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS] = { 9690 .type = HDA_FIXUP_VERBS, 9691 //.v.verbs = legion_15imhg05_coefs, 9692 .v.verbs = (const struct hda_verb[]) { 9693 // set left speaker Legion 7i. 9694 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 9695 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 }, 9696 9697 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9698 { 0x20, AC_VERB_SET_PROC_COEF, 0xc }, 9699 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9700 { 0x20, AC_VERB_SET_PROC_COEF, 0x1a }, 9701 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9702 9703 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9704 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 9705 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9706 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9707 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9708 9709 // set right speaker Legion 7i. 9710 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 9711 { 0x20, AC_VERB_SET_PROC_COEF, 0x42 }, 9712 9713 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9714 { 0x20, AC_VERB_SET_PROC_COEF, 0xc }, 9715 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9716 { 0x20, AC_VERB_SET_PROC_COEF, 0x2a }, 9717 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9718 9719 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9720 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 9721 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9722 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9723 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9724 {} 9725 }, 9726 .chained = true, 9727 .chain_id = ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE, 9728 }, 9729 [ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE] = { 9730 .type = HDA_FIXUP_FUNC, 9731 .v.func = alc287_fixup_legion_15imhg05_speakers, 9732 .chained = true, 9733 .chain_id = ALC269_FIXUP_HEADSET_MODE, 9734 }, 9735 [ALC287_FIXUP_YOGA7_14ITL_SPEAKERS] = { 9736 .type = HDA_FIXUP_VERBS, 9737 .v.verbs = (const struct hda_verb[]) { 9738 // set left speaker Yoga 7i. 9739 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 9740 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 }, 9741 9742 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9743 { 0x20, AC_VERB_SET_PROC_COEF, 0xc }, 9744 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9745 { 0x20, AC_VERB_SET_PROC_COEF, 0x1a }, 9746 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9747 9748 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9749 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 9750 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9751 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9752 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9753 9754 // set right speaker Yoga 7i. 9755 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 9756 { 0x20, AC_VERB_SET_PROC_COEF, 0x46 }, 9757 9758 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9759 { 0x20, AC_VERB_SET_PROC_COEF, 0xc }, 9760 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9761 { 0x20, AC_VERB_SET_PROC_COEF, 0x2a }, 9762 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9763 9764 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9765 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 9766 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9767 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9768 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9769 {} 9770 }, 9771 .chained = true, 9772 .chain_id = ALC269_FIXUP_HEADSET_MODE, 9773 }, 9774 [ALC298_FIXUP_LENOVO_C940_DUET7] = { 9775 .type = HDA_FIXUP_FUNC, 9776 .v.func = alc298_fixup_lenovo_c940_duet7, 9777 }, 9778 [ALC287_FIXUP_LENOVO_14IRP8_DUETITL] = { 9779 .type = HDA_FIXUP_FUNC, 9780 .v.func = alc287_fixup_lenovo_14irp8_duetitl, 9781 }, 9782 [ALC287_FIXUP_LENOVO_LEGION_7] = { 9783 .type = HDA_FIXUP_FUNC, 9784 .v.func = alc287_fixup_lenovo_legion_7, 9785 }, 9786 [ALC287_FIXUP_13S_GEN2_SPEAKERS] = { 9787 .type = HDA_FIXUP_VERBS, 9788 .v.verbs = (const struct hda_verb[]) { 9789 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 9790 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 }, 9791 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9792 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 9793 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9794 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9795 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9796 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 9797 { 0x20, AC_VERB_SET_PROC_COEF, 0x42 }, 9798 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9799 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 9800 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9801 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9802 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9803 {} 9804 }, 9805 .chained = true, 9806 .chain_id = ALC269_FIXUP_HEADSET_MODE, 9807 }, 9808 [ALC256_FIXUP_SET_COEF_DEFAULTS] = { 9809 .type = HDA_FIXUP_FUNC, 9810 .v.func = alc256_fixup_set_coef_defaults, 9811 }, 9812 [ALC245_FIXUP_HP_GPIO_LED] = { 9813 .type = HDA_FIXUP_FUNC, 9814 .v.func = alc245_fixup_hp_gpio_led, 9815 }, 9816 [ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = { 9817 .type = HDA_FIXUP_PINS, 9818 .v.pins = (const struct hda_pintbl[]) { 9819 { 0x19, 0x03a11120 }, /* use as headset mic, without its own jack detect */ 9820 { } 9821 }, 9822 .chained = true, 9823 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, 9824 }, 9825 [ALC233_FIXUP_NO_AUDIO_JACK] = { 9826 .type = HDA_FIXUP_FUNC, 9827 .v.func = alc233_fixup_no_audio_jack, 9828 }, 9829 [ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME] = { 9830 .type = HDA_FIXUP_FUNC, 9831 .v.func = alc256_fixup_mic_no_presence_and_resume, 9832 .chained = true, 9833 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 9834 }, 9835 [ALC287_FIXUP_LEGION_16ACHG6] = { 9836 .type = HDA_FIXUP_FUNC, 9837 .v.func = alc287_fixup_legion_16achg6_speakers, 9838 }, 9839 [ALC287_FIXUP_CS35L41_I2C_2] = { 9840 .type = HDA_FIXUP_FUNC, 9841 .v.func = cs35l41_fixup_i2c_two, 9842 }, 9843 [ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED] = { 9844 .type = HDA_FIXUP_FUNC, 9845 .v.func = cs35l41_fixup_i2c_two, 9846 .chained = true, 9847 .chain_id = ALC285_FIXUP_HP_MUTE_LED, 9848 }, 9849 [ALC287_FIXUP_CS35L41_I2C_4] = { 9850 .type = HDA_FIXUP_FUNC, 9851 .v.func = cs35l41_fixup_i2c_four, 9852 }, 9853 [ALC245_FIXUP_CS35L41_SPI_2] = { 9854 .type = HDA_FIXUP_FUNC, 9855 .v.func = cs35l41_fixup_spi_two, 9856 }, 9857 [ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED] = { 9858 .type = HDA_FIXUP_FUNC, 9859 .v.func = cs35l41_fixup_spi_two, 9860 .chained = true, 9861 .chain_id = ALC285_FIXUP_HP_GPIO_LED, 9862 }, 9863 [ALC245_FIXUP_CS35L41_SPI_4] = { 9864 .type = HDA_FIXUP_FUNC, 9865 .v.func = cs35l41_fixup_spi_four, 9866 }, 9867 [ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED] = { 9868 .type = HDA_FIXUP_FUNC, 9869 .v.func = cs35l41_fixup_spi_four, 9870 .chained = true, 9871 .chain_id = ALC285_FIXUP_HP_GPIO_LED, 9872 }, 9873 [ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED] = { 9874 .type = HDA_FIXUP_VERBS, 9875 .v.verbs = (const struct hda_verb[]) { 9876 { 0x20, AC_VERB_SET_COEF_INDEX, 0x19 }, 9877 { 0x20, AC_VERB_SET_PROC_COEF, 0x8e11 }, 9878 { } 9879 }, 9880 .chained = true, 9881 .chain_id = ALC285_FIXUP_HP_MUTE_LED, 9882 }, 9883 [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET] = { 9884 .type = HDA_FIXUP_FUNC, 9885 .v.func = alc_fixup_dell4_mic_no_presence_quiet, 9886 .chained = true, 9887 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 9888 }, 9889 [ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE] = { 9890 .type = HDA_FIXUP_PINS, 9891 .v.pins = (const struct hda_pintbl[]) { 9892 { 0x19, 0x02a1112c }, /* use as headset mic, without its own jack detect */ 9893 { } 9894 }, 9895 .chained = true, 9896 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 9897 }, 9898 [ALC287_FIXUP_LEGION_16ITHG6] = { 9899 .type = HDA_FIXUP_FUNC, 9900 .v.func = alc287_fixup_legion_16ithg6_speakers, 9901 }, 9902 [ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK] = { 9903 .type = HDA_FIXUP_VERBS, 9904 .v.verbs = (const struct hda_verb[]) { 9905 // enable left speaker 9906 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 9907 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 }, 9908 9909 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9910 { 0x20, AC_VERB_SET_PROC_COEF, 0xc }, 9911 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9912 { 0x20, AC_VERB_SET_PROC_COEF, 0x1a }, 9913 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9914 9915 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9916 { 0x20, AC_VERB_SET_PROC_COEF, 0xf }, 9917 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9918 { 0x20, AC_VERB_SET_PROC_COEF, 0x42 }, 9919 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9920 9921 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9922 { 0x20, AC_VERB_SET_PROC_COEF, 0x10 }, 9923 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9924 { 0x20, AC_VERB_SET_PROC_COEF, 0x40 }, 9925 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9926 9927 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9928 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 9929 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9930 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9931 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9932 9933 // enable right speaker 9934 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 9935 { 0x20, AC_VERB_SET_PROC_COEF, 0x46 }, 9936 9937 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9938 { 0x20, AC_VERB_SET_PROC_COEF, 0xc }, 9939 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9940 { 0x20, AC_VERB_SET_PROC_COEF, 0x2a }, 9941 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9942 9943 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9944 { 0x20, AC_VERB_SET_PROC_COEF, 0xf }, 9945 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9946 { 0x20, AC_VERB_SET_PROC_COEF, 0x46 }, 9947 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9948 9949 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9950 { 0x20, AC_VERB_SET_PROC_COEF, 0x10 }, 9951 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9952 { 0x20, AC_VERB_SET_PROC_COEF, 0x44 }, 9953 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9954 9955 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9956 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 9957 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9958 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9959 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9960 9961 { }, 9962 }, 9963 }, 9964 [ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN] = { 9965 .type = HDA_FIXUP_FUNC, 9966 .v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin, 9967 .chained = true, 9968 .chain_id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK, 9969 }, 9970 [ALC287_FIXUP_LENOVO_14ARP8_LEGION_IAH7] = { 9971 .type = HDA_FIXUP_FUNC, 9972 .v.func = alc287_fixup_lenovo_14arp8_legion_iah7, 9973 }, 9974 [ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN] = { 9975 .type = HDA_FIXUP_FUNC, 9976 .v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin, 9977 .chained = true, 9978 .chain_id = ALC287_FIXUP_CS35L41_I2C_2, 9979 }, 9980 [ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS] = { 9981 .type = HDA_FIXUP_FUNC, 9982 .v.func = alc295_fixup_dell_inspiron_top_speakers, 9983 .chained = true, 9984 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 9985 }, 9986 [ALC236_FIXUP_DELL_DUAL_CODECS] = { 9987 .type = HDA_FIXUP_PINS, 9988 .v.func = alc1220_fixup_gb_dual_codecs, 9989 .chained = true, 9990 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9991 }, 9992 [ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI] = { 9993 .type = HDA_FIXUP_FUNC, 9994 .v.func = cs35l41_fixup_i2c_two, 9995 .chained = true, 9996 .chain_id = ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK, 9997 }, 9998 [ALC287_FIXUP_TAS2781_I2C] = { 9999 .type = HDA_FIXUP_FUNC, 10000 .v.func = tas2781_fixup_i2c, 10001 .chained = true, 10002 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK, 10003 }, 10004 [ALC287_FIXUP_YOGA7_14ARB7_I2C] = { 10005 .type = HDA_FIXUP_FUNC, 10006 .v.func = yoga7_14arb7_fixup_i2c, 10007 .chained = true, 10008 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK, 10009 }, 10010 [ALC245_FIXUP_HP_MUTE_LED_COEFBIT] = { 10011 .type = HDA_FIXUP_FUNC, 10012 .v.func = alc245_fixup_hp_mute_led_coefbit, 10013 }, 10014 [ALC245_FIXUP_HP_X360_MUTE_LEDS] = { 10015 .type = HDA_FIXUP_FUNC, 10016 .v.func = alc245_fixup_hp_mute_led_coefbit, 10017 .chained = true, 10018 .chain_id = ALC245_FIXUP_HP_GPIO_LED 10019 }, 10020 [ALC287_FIXUP_THINKPAD_I2S_SPK] = { 10021 .type = HDA_FIXUP_FUNC, 10022 .v.func = alc287_fixup_bind_dacs, 10023 .chained = true, 10024 .chain_id = ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK, 10025 }, 10026 [ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD] = { 10027 .type = HDA_FIXUP_FUNC, 10028 .v.func = alc287_fixup_bind_dacs, 10029 .chained = true, 10030 .chain_id = ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI, 10031 }, 10032 [ALC2XX_FIXUP_HEADSET_MIC] = { 10033 .type = HDA_FIXUP_FUNC, 10034 .v.func = alc_fixup_headset_mic, 10035 }, 10036 [ALC289_FIXUP_DELL_CS35L41_SPI_2] = { 10037 .type = HDA_FIXUP_FUNC, 10038 .v.func = cs35l41_fixup_spi_two, 10039 .chained = true, 10040 .chain_id = ALC289_FIXUP_DUAL_SPK 10041 }, 10042 [ALC294_FIXUP_CS35L41_I2C_2] = { 10043 .type = HDA_FIXUP_FUNC, 10044 .v.func = cs35l41_fixup_i2c_two, 10045 }, 10046 [ALC256_FIXUP_ACER_SFG16_MICMUTE_LED] = { 10047 .type = HDA_FIXUP_FUNC, 10048 .v.func = alc256_fixup_acer_sfg16_micmute_led, 10049 }, 10050 [ALC256_FIXUP_HEADPHONE_AMP_VOL] = { 10051 .type = HDA_FIXUP_FUNC, 10052 .v.func = alc256_decrease_headphone_amp_val, 10053 }, 10054 [ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX] = { 10055 .type = HDA_FIXUP_FUNC, 10056 .v.func = alc245_fixup_hp_spectre_x360_eu0xxx, 10057 }, 10058 [ALC245_FIXUP_HP_SPECTRE_X360_16_AA0XXX] = { 10059 .type = HDA_FIXUP_FUNC, 10060 .v.func = alc245_fixup_hp_spectre_x360_16_aa0xxx, 10061 }, 10062 [ALC285_FIXUP_ASUS_GA403U] = { 10063 .type = HDA_FIXUP_FUNC, 10064 .v.func = alc285_fixup_asus_ga403u, 10065 }, 10066 [ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC] = { 10067 .type = HDA_FIXUP_PINS, 10068 .v.pins = (const struct hda_pintbl[]) { 10069 { 0x19, 0x03a11050 }, 10070 { 0x1b, 0x03a11c30 }, 10071 { } 10072 }, 10073 .chained = true, 10074 .chain_id = ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1 10075 }, 10076 [ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1] = { 10077 .type = HDA_FIXUP_FUNC, 10078 .v.func = alc285_fixup_speaker2_to_dac1, 10079 .chained = true, 10080 .chain_id = ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC, 10081 }, 10082 [ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC] = { 10083 .type = HDA_FIXUP_PINS, 10084 .v.pins = (const struct hda_pintbl[]) { 10085 { 0x19, 0x03a11050 }, 10086 { 0x1b, 0x03a11c30 }, 10087 { } 10088 }, 10089 }, 10090 [ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1] = { 10091 .type = HDA_FIXUP_FUNC, 10092 .v.func = alc285_fixup_speaker2_to_dac1, 10093 .chained = true, 10094 .chain_id = ALC285_FIXUP_ASUS_GA403U, 10095 }, 10096 [ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318] = { 10097 .type = HDA_FIXUP_FUNC, 10098 .v.func = alc287_fixup_lenovo_thinkpad_with_alc1318, 10099 .chained = true, 10100 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 10101 }, 10102 [ALC256_FIXUP_CHROME_BOOK] = { 10103 .type = HDA_FIXUP_FUNC, 10104 .v.func = alc256_fixup_chromebook, 10105 .chained = true, 10106 .chain_id = ALC225_FIXUP_HEADSET_JACK 10107 }, 10108 [ALC287_FIXUP_LENOVO_SSID_17AA3820] = { 10109 .type = HDA_FIXUP_FUNC, 10110 .v.func = alc287_fixup_lenovo_ssid_17aa3820, 10111 }, 10112 [ALC245_FIXUP_CLEVO_NOISY_MIC] = { 10113 .type = HDA_FIXUP_FUNC, 10114 .v.func = alc269_fixup_limit_int_mic_boost, 10115 .chained = true, 10116 .chain_id = ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE, 10117 }, 10118 [ALC269_FIXUP_VAIO_VJFH52_MIC_NO_PRESENCE] = { 10119 .type = HDA_FIXUP_PINS, 10120 .v.pins = (const struct hda_pintbl[]) { 10121 { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */ 10122 { 0x1b, 0x20a11040 }, /* dock mic */ 10123 { } 10124 }, 10125 .chained = true, 10126 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST 10127 }, 10128 }; 10129 10130 static const struct snd_pci_quirk alc269_fixup_tbl[] = { 10131 SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC), 10132 SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC), 10133 SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC), 10134 SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700), 10135 SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC), 10136 SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK), 10137 SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK), 10138 SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572), 10139 SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572), 10140 SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS), 10141 SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC), 10142 SND_PCI_QUIRK(0x1025, 0x0840, "Acer Aspire E1", ALC269VB_FIXUP_ASPIRE_E1_COEF), 10143 SND_PCI_QUIRK(0x1025, 0x100c, "Acer Aspire E5-574G", ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST), 10144 SND_PCI_QUIRK(0x1025, 0x101c, "Acer Veriton N2510G", ALC269_FIXUP_LIFEBOOK), 10145 SND_PCI_QUIRK(0x1025, 0x102b, "Acer Aspire C24-860", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE), 10146 SND_PCI_QUIRK(0x1025, 0x1065, "Acer Aspire C20-820", ALC269VC_FIXUP_ACER_HEADSET_MIC), 10147 SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK), 10148 SND_PCI_QUIRK(0x1025, 0x1094, "Acer Aspire E5-575T", ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST), 10149 SND_PCI_QUIRK(0x1025, 0x1099, "Acer Aspire E5-523G", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 10150 SND_PCI_QUIRK(0x1025, 0x110e, "Acer Aspire ES1-432", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 10151 SND_PCI_QUIRK(0x1025, 0x1166, "Acer Veriton N4640G", ALC269_FIXUP_LIFEBOOK), 10152 SND_PCI_QUIRK(0x1025, 0x1167, "Acer Veriton N6640G", ALC269_FIXUP_LIFEBOOK), 10153 SND_PCI_QUIRK(0x1025, 0x1246, "Acer Predator Helios 500", ALC299_FIXUP_PREDATOR_SPK), 10154 SND_PCI_QUIRK(0x1025, 0x1247, "Acer vCopperbox", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS), 10155 SND_PCI_QUIRK(0x1025, 0x1248, "Acer Veriton N4660G", ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE), 10156 SND_PCI_QUIRK(0x1025, 0x1269, "Acer SWIFT SF314-54", ALC256_FIXUP_ACER_HEADSET_MIC), 10157 SND_PCI_QUIRK(0x1025, 0x126a, "Acer Swift SF114-32", ALC256_FIXUP_ACER_MIC_NO_PRESENCE), 10158 SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), 10159 SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), 10160 SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), 10161 SND_PCI_QUIRK(0x1025, 0x129c, "Acer SWIFT SF314-55", ALC256_FIXUP_ACER_HEADSET_MIC), 10162 SND_PCI_QUIRK(0x1025, 0x129d, "Acer SWIFT SF313-51", ALC256_FIXUP_ACER_MIC_NO_PRESENCE), 10163 SND_PCI_QUIRK(0x1025, 0x1300, "Acer SWIFT SF314-56", ALC256_FIXUP_ACER_MIC_NO_PRESENCE), 10164 SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), 10165 SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC), 10166 SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC), 10167 SND_PCI_QUIRK(0x1025, 0x141f, "Acer Spin SP513-54N", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 10168 SND_PCI_QUIRK(0x1025, 0x142b, "Acer Swift SF314-42", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 10169 SND_PCI_QUIRK(0x1025, 0x1430, "Acer TravelMate B311R-31", ALC256_FIXUP_ACER_MIC_NO_PRESENCE), 10170 SND_PCI_QUIRK(0x1025, 0x1466, "Acer Aspire A515-56", ALC255_FIXUP_ACER_HEADPHONE_AND_MIC), 10171 SND_PCI_QUIRK(0x1025, 0x1534, "Acer Predator PH315-54", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 10172 SND_PCI_QUIRK(0x1025, 0x169a, "Acer Swift SFG16", ALC256_FIXUP_ACER_SFG16_MICMUTE_LED), 10173 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z), 10174 SND_PCI_QUIRK(0x1028, 0x053c, "Dell Latitude E5430", ALC292_FIXUP_DELL_E7X), 10175 SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS), 10176 SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X), 10177 SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X), 10178 SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X), 10179 SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X), 10180 SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER), 10181 SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE), 10182 SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE), 10183 SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE), 10184 SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK), 10185 SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK), 10186 SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X), 10187 SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X), 10188 SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK), 10189 SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 10190 SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 10191 SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13), 10192 SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE), 10193 SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK), 10194 SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE), 10195 SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 10196 SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 10197 SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 10198 SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 10199 SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 10200 SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 10201 SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 10202 SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER), 10203 SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE), 10204 SND_PCI_QUIRK(0x1028, 0x0738, "Dell Precision 5820", ALC269_FIXUP_NO_SHUTUP), 10205 SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME), 10206 SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME), 10207 SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER), 10208 SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3), 10209 SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE), 10210 SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB), 10211 SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB), 10212 SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC), 10213 SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC), 10214 SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB), 10215 SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE), 10216 SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE), 10217 SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB), 10218 SND_PCI_QUIRK(0x1028, 0x097d, "Dell Precision", ALC289_FIXUP_DUAL_SPK), 10219 SND_PCI_QUIRK(0x1028, 0x097e, "Dell Precision", ALC289_FIXUP_DUAL_SPK), 10220 SND_PCI_QUIRK(0x1028, 0x098d, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE), 10221 SND_PCI_QUIRK(0x1028, 0x09bf, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE), 10222 SND_PCI_QUIRK(0x1028, 0x0a2e, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC), 10223 SND_PCI_QUIRK(0x1028, 0x0a30, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC), 10224 SND_PCI_QUIRK(0x1028, 0x0a38, "Dell Latitude 7520", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET), 10225 SND_PCI_QUIRK(0x1028, 0x0a58, "Dell", ALC255_FIXUP_DELL_HEADSET_MIC), 10226 SND_PCI_QUIRK(0x1028, 0x0a61, "Dell XPS 15 9510", ALC289_FIXUP_DUAL_SPK), 10227 SND_PCI_QUIRK(0x1028, 0x0a62, "Dell Precision 5560", ALC289_FIXUP_DUAL_SPK), 10228 SND_PCI_QUIRK(0x1028, 0x0a9d, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE), 10229 SND_PCI_QUIRK(0x1028, 0x0a9e, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE), 10230 SND_PCI_QUIRK(0x1028, 0x0b19, "Dell XPS 15 9520", ALC289_FIXUP_DUAL_SPK), 10231 SND_PCI_QUIRK(0x1028, 0x0b1a, "Dell Precision 5570", ALC289_FIXUP_DUAL_SPK), 10232 SND_PCI_QUIRK(0x1028, 0x0b27, "Dell", ALC245_FIXUP_CS35L41_SPI_2), 10233 SND_PCI_QUIRK(0x1028, 0x0b28, "Dell", ALC245_FIXUP_CS35L41_SPI_2), 10234 SND_PCI_QUIRK(0x1028, 0x0b37, "Dell Inspiron 16 Plus 7620 2-in-1", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS), 10235 SND_PCI_QUIRK(0x1028, 0x0b71, "Dell Inspiron 16 Plus 7620", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS), 10236 SND_PCI_QUIRK(0x1028, 0x0beb, "Dell XPS 15 9530 (2023)", ALC289_FIXUP_DELL_CS35L41_SPI_2), 10237 SND_PCI_QUIRK(0x1028, 0x0c03, "Dell Precision 5340", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE), 10238 SND_PCI_QUIRK(0x1028, 0x0c0b, "Dell Oasis 14 RPL-P", ALC289_FIXUP_RTK_AMP_DUAL_SPK), 10239 SND_PCI_QUIRK(0x1028, 0x0c0d, "Dell Oasis", ALC289_FIXUP_RTK_AMP_DUAL_SPK), 10240 SND_PCI_QUIRK(0x1028, 0x0c0e, "Dell Oasis 16", ALC289_FIXUP_RTK_AMP_DUAL_SPK), 10241 SND_PCI_QUIRK(0x1028, 0x0c19, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS), 10242 SND_PCI_QUIRK(0x1028, 0x0c1a, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS), 10243 SND_PCI_QUIRK(0x1028, 0x0c1b, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS), 10244 SND_PCI_QUIRK(0x1028, 0x0c1c, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS), 10245 SND_PCI_QUIRK(0x1028, 0x0c1d, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS), 10246 SND_PCI_QUIRK(0x1028, 0x0c1e, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS), 10247 SND_PCI_QUIRK(0x1028, 0x0c28, "Dell Inspiron 16 Plus 7630", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS), 10248 SND_PCI_QUIRK(0x1028, 0x0c4d, "Dell", ALC287_FIXUP_CS35L41_I2C_4), 10249 SND_PCI_QUIRK(0x1028, 0x0c94, "Dell Polaris 3 metal", ALC287_FIXUP_TAS2781_I2C), 10250 SND_PCI_QUIRK(0x1028, 0x0c96, "Dell Polaris 2in1", ALC287_FIXUP_TAS2781_I2C), 10251 SND_PCI_QUIRK(0x1028, 0x0cbd, "Dell Oasis 13 CS MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2), 10252 SND_PCI_QUIRK(0x1028, 0x0cbe, "Dell Oasis 13 2-IN-1 MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2), 10253 SND_PCI_QUIRK(0x1028, 0x0cbf, "Dell Oasis 13 Low Weight MTU-L", ALC289_FIXUP_DELL_CS35L41_SPI_2), 10254 SND_PCI_QUIRK(0x1028, 0x0cc0, "Dell Oasis 13", ALC289_FIXUP_RTK_AMP_DUAL_SPK), 10255 SND_PCI_QUIRK(0x1028, 0x0cc1, "Dell Oasis 14 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2), 10256 SND_PCI_QUIRK(0x1028, 0x0cc2, "Dell Oasis 14 2-in-1 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2), 10257 SND_PCI_QUIRK(0x1028, 0x0cc3, "Dell Oasis 14 Low Weight MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2), 10258 SND_PCI_QUIRK(0x1028, 0x0cc4, "Dell Oasis 16 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2), 10259 SND_PCI_QUIRK(0x1028, 0x0cc5, "Dell Oasis 14", ALC289_FIXUP_RTK_AMP_DUAL_SPK), 10260 SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 10261 SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 10262 SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2), 10263 SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED), 10264 SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED), 10265 SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10266 SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10267 SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10268 SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10269 SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC), 10270 SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10271 SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10272 SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 10273 SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 10274 SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 10275 SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 10276 SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 10277 SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10278 SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10279 SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10280 SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10281 SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10282 SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10283 SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED), 10284 SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY), 10285 SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10286 SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10287 SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10288 SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10289 SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10290 SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10291 SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10292 SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10293 SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED), 10294 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10295 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS), 10296 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10297 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS), 10298 SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10299 SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10300 SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10301 SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10302 SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10303 SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10304 SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10305 SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10306 SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10307 SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10308 SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10309 SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10310 SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10311 SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10312 SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M), 10313 SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10314 SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10315 SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10316 SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10317 SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10318 SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10319 SND_PCI_QUIRK(0x103c, 0x2b5e, "HP 288 Pro G2 MT", ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE), 10320 SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE), 10321 SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE), 10322 SND_PCI_QUIRK(0x103c, 0x8077, "HP", ALC256_FIXUP_HP_HEADSET_MIC), 10323 SND_PCI_QUIRK(0x103c, 0x8158, "HP", ALC256_FIXUP_HP_HEADSET_MIC), 10324 SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC295_FIXUP_HP_X360), 10325 SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC), 10326 SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360), 10327 SND_PCI_QUIRK(0x103c, 0x827f, "HP x360", ALC269_FIXUP_HP_MUTE_LED_MIC3), 10328 SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE), 10329 SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE), 10330 SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3), 10331 SND_PCI_QUIRK(0x103c, 0x841c, "HP Pavilion 15-CK0xx", ALC269_FIXUP_HP_MUTE_LED_MIC3), 10332 SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3), 10333 SND_PCI_QUIRK(0x103c, 0x84a6, "HP 250 G7 Notebook PC", ALC269_FIXUP_HP_LINE1_MIC1_LED), 10334 SND_PCI_QUIRK(0x103c, 0x84ae, "HP 15-db0403ng", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10335 SND_PCI_QUIRK(0x103c, 0x84da, "HP OMEN dc0019-ur", ALC295_FIXUP_HP_OMEN), 10336 SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3), 10337 SND_PCI_QUIRK(0x103c, 0x8519, "HP Spectre x360 15-df0xxx", ALC285_FIXUP_HP_SPECTRE_X360), 10338 SND_PCI_QUIRK(0x103c, 0x8537, "HP ProBook 440 G6", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10339 SND_PCI_QUIRK(0x103c, 0x85de, "HP Envy x360 13-ar0xxx", ALC285_FIXUP_HP_ENVY_X360), 10340 SND_PCI_QUIRK(0x103c, 0x860f, "HP ZBook 15 G6", ALC285_FIXUP_HP_GPIO_AMP_INIT), 10341 SND_PCI_QUIRK(0x103c, 0x861f, "HP Elite Dragonfly G1", ALC285_FIXUP_HP_GPIO_AMP_INIT), 10342 SND_PCI_QUIRK(0x103c, 0x869d, "HP", ALC236_FIXUP_HP_MUTE_LED), 10343 SND_PCI_QUIRK(0x103c, 0x86c1, "HP Laptop 15-da3001TU", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10344 SND_PCI_QUIRK(0x103c, 0x86c7, "HP Envy AiO 32", ALC274_FIXUP_HP_ENVY_GPIO), 10345 SND_PCI_QUIRK(0x103c, 0x86e7, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1), 10346 SND_PCI_QUIRK(0x103c, 0x86e8, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1), 10347 SND_PCI_QUIRK(0x103c, 0x86f9, "HP Spectre x360 13-aw0xxx", ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED), 10348 SND_PCI_QUIRK(0x103c, 0x8716, "HP Elite Dragonfly G2 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT), 10349 SND_PCI_QUIRK(0x103c, 0x8720, "HP EliteBook x360 1040 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT), 10350 SND_PCI_QUIRK(0x103c, 0x8724, "HP EliteBook 850 G7", ALC285_FIXUP_HP_GPIO_LED), 10351 SND_PCI_QUIRK(0x103c, 0x8728, "HP EliteBook 840 G7", ALC285_FIXUP_HP_GPIO_LED), 10352 SND_PCI_QUIRK(0x103c, 0x8729, "HP", ALC285_FIXUP_HP_GPIO_LED), 10353 SND_PCI_QUIRK(0x103c, 0x8730, "HP ProBook 445 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10354 SND_PCI_QUIRK(0x103c, 0x8735, "HP ProBook 435 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10355 SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_AMP_INIT), 10356 SND_PCI_QUIRK(0x103c, 0x8760, "HP", ALC285_FIXUP_HP_MUTE_LED), 10357 SND_PCI_QUIRK(0x103c, 0x876e, "HP ENVY x360 Convertible 13-ay0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS), 10358 SND_PCI_QUIRK(0x103c, 0x877a, "HP", ALC285_FIXUP_HP_MUTE_LED), 10359 SND_PCI_QUIRK(0x103c, 0x877d, "HP", ALC236_FIXUP_HP_MUTE_LED), 10360 SND_PCI_QUIRK(0x103c, 0x8780, "HP ZBook Fury 17 G7 Mobile Workstation", 10361 ALC285_FIXUP_HP_GPIO_AMP_INIT), 10362 SND_PCI_QUIRK(0x103c, 0x8783, "HP ZBook Fury 15 G7 Mobile Workstation", 10363 ALC285_FIXUP_HP_GPIO_AMP_INIT), 10364 SND_PCI_QUIRK(0x103c, 0x8786, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED), 10365 SND_PCI_QUIRK(0x103c, 0x8787, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED), 10366 SND_PCI_QUIRK(0x103c, 0x8788, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED), 10367 SND_PCI_QUIRK(0x103c, 0x87b7, "HP Laptop 14-fq0xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10368 SND_PCI_QUIRK(0x103c, 0x87c8, "HP", ALC287_FIXUP_HP_GPIO_LED), 10369 SND_PCI_QUIRK(0x103c, 0x87d3, "HP Laptop 15-gw0xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10370 SND_PCI_QUIRK(0x103c, 0x87e5, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 10371 SND_PCI_QUIRK(0x103c, 0x87e7, "HP ProBook 450 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 10372 SND_PCI_QUIRK(0x103c, 0x87f1, "HP ProBook 630 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 10373 SND_PCI_QUIRK(0x103c, 0x87f2, "HP ProBook 640 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 10374 SND_PCI_QUIRK(0x103c, 0x87f4, "HP", ALC287_FIXUP_HP_GPIO_LED), 10375 SND_PCI_QUIRK(0x103c, 0x87f5, "HP", ALC287_FIXUP_HP_GPIO_LED), 10376 SND_PCI_QUIRK(0x103c, 0x87f6, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP), 10377 SND_PCI_QUIRK(0x103c, 0x87f7, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP), 10378 SND_PCI_QUIRK(0x103c, 0x87fd, "HP Laptop 14-dq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10379 SND_PCI_QUIRK(0x103c, 0x87fe, "HP Laptop 15s-fq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10380 SND_PCI_QUIRK(0x103c, 0x8805, "HP ProBook 650 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 10381 SND_PCI_QUIRK(0x103c, 0x880d, "HP EliteBook 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED), 10382 SND_PCI_QUIRK(0x103c, 0x8811, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1), 10383 SND_PCI_QUIRK(0x103c, 0x8812, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1), 10384 SND_PCI_QUIRK(0x103c, 0x881d, "HP 250 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10385 SND_PCI_QUIRK(0x103c, 0x8846, "HP EliteBook 850 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED), 10386 SND_PCI_QUIRK(0x103c, 0x8847, "HP EliteBook x360 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED), 10387 SND_PCI_QUIRK(0x103c, 0x884b, "HP EliteBook 840 Aero G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED), 10388 SND_PCI_QUIRK(0x103c, 0x884c, "HP EliteBook 840 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED), 10389 SND_PCI_QUIRK(0x103c, 0x8862, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST), 10390 SND_PCI_QUIRK(0x103c, 0x8863, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST), 10391 SND_PCI_QUIRK(0x103c, 0x886d, "HP ZBook Fury 17.3 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT), 10392 SND_PCI_QUIRK(0x103c, 0x8870, "HP ZBook Fury 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT), 10393 SND_PCI_QUIRK(0x103c, 0x8873, "HP ZBook Studio 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT), 10394 SND_PCI_QUIRK(0x103c, 0x887a, "HP Laptop 15s-eq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10395 SND_PCI_QUIRK(0x103c, 0x888a, "HP ENVY x360 Convertible 15-eu0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS), 10396 SND_PCI_QUIRK(0x103c, 0x888d, "HP ZBook Power 15.6 inch G8 Mobile Workstation PC", ALC236_FIXUP_HP_GPIO_LED), 10397 SND_PCI_QUIRK(0x103c, 0x8895, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED), 10398 SND_PCI_QUIRK(0x103c, 0x8896, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_MUTE_LED), 10399 SND_PCI_QUIRK(0x103c, 0x8898, "HP EliteBook 845 G8 Notebook PC", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST), 10400 SND_PCI_QUIRK(0x103c, 0x88d0, "HP Pavilion 15-eh1xxx (mainboard 88D0)", ALC287_FIXUP_HP_GPIO_LED), 10401 SND_PCI_QUIRK(0x103c, 0x88dd, "HP Pavilion 15z-ec200", ALC285_FIXUP_HP_MUTE_LED), 10402 SND_PCI_QUIRK(0x103c, 0x8902, "HP OMEN 16", ALC285_FIXUP_HP_MUTE_LED), 10403 SND_PCI_QUIRK(0x103c, 0x890e, "HP 255 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10404 SND_PCI_QUIRK(0x103c, 0x8919, "HP Pavilion Aero Laptop 13-be0xxx", ALC287_FIXUP_HP_GPIO_LED), 10405 SND_PCI_QUIRK(0x103c, 0x896d, "HP ZBook Firefly 16 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10406 SND_PCI_QUIRK(0x103c, 0x896e, "HP EliteBook x360 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10407 SND_PCI_QUIRK(0x103c, 0x8971, "HP EliteBook 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10408 SND_PCI_QUIRK(0x103c, 0x8972, "HP EliteBook 840 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10409 SND_PCI_QUIRK(0x103c, 0x8973, "HP EliteBook 860 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10410 SND_PCI_QUIRK(0x103c, 0x8974, "HP EliteBook 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10411 SND_PCI_QUIRK(0x103c, 0x8975, "HP EliteBook x360 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10412 SND_PCI_QUIRK(0x103c, 0x897d, "HP mt440 Mobile Thin Client U74", ALC236_FIXUP_HP_GPIO_LED), 10413 SND_PCI_QUIRK(0x103c, 0x8981, "HP Elite Dragonfly G3", ALC245_FIXUP_CS35L41_SPI_4), 10414 SND_PCI_QUIRK(0x103c, 0x898e, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2), 10415 SND_PCI_QUIRK(0x103c, 0x898f, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2), 10416 SND_PCI_QUIRK(0x103c, 0x8991, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 10417 SND_PCI_QUIRK(0x103c, 0x8992, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2), 10418 SND_PCI_QUIRK(0x103c, 0x8994, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 10419 SND_PCI_QUIRK(0x103c, 0x8995, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2), 10420 SND_PCI_QUIRK(0x103c, 0x89a4, "HP ProBook 440 G9", ALC236_FIXUP_HP_GPIO_LED), 10421 SND_PCI_QUIRK(0x103c, 0x89a6, "HP ProBook 450 G9", ALC236_FIXUP_HP_GPIO_LED), 10422 SND_PCI_QUIRK(0x103c, 0x89aa, "HP EliteBook 630 G9", ALC236_FIXUP_HP_GPIO_LED), 10423 SND_PCI_QUIRK(0x103c, 0x89ac, "HP EliteBook 640 G9", ALC236_FIXUP_HP_GPIO_LED), 10424 SND_PCI_QUIRK(0x103c, 0x89ae, "HP EliteBook 650 G9", ALC236_FIXUP_HP_GPIO_LED), 10425 SND_PCI_QUIRK(0x103c, 0x89c0, "HP ZBook Power 15.6 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10426 SND_PCI_QUIRK(0x103c, 0x89c3, "Zbook Studio G9", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED), 10427 SND_PCI_QUIRK(0x103c, 0x89c6, "Zbook Fury 17 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10428 SND_PCI_QUIRK(0x103c, 0x89ca, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10429 SND_PCI_QUIRK(0x103c, 0x89d3, "HP EliteBook 645 G9 (MB 89D2)", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10430 SND_PCI_QUIRK(0x103c, 0x89e7, "HP Elite x2 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10431 SND_PCI_QUIRK(0x103c, 0x8a0f, "HP Pavilion 14-ec1xxx", ALC287_FIXUP_HP_GPIO_LED), 10432 SND_PCI_QUIRK(0x103c, 0x8a20, "HP Laptop 15s-fq5xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10433 SND_PCI_QUIRK(0x103c, 0x8a25, "HP Victus 16-d1xxx (MB 8A25)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT), 10434 SND_PCI_QUIRK(0x103c, 0x8a28, "HP Envy 13", ALC287_FIXUP_CS35L41_I2C_2), 10435 SND_PCI_QUIRK(0x103c, 0x8a29, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10436 SND_PCI_QUIRK(0x103c, 0x8a2a, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10437 SND_PCI_QUIRK(0x103c, 0x8a2b, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10438 SND_PCI_QUIRK(0x103c, 0x8a2c, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2), 10439 SND_PCI_QUIRK(0x103c, 0x8a2d, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2), 10440 SND_PCI_QUIRK(0x103c, 0x8a2e, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2), 10441 SND_PCI_QUIRK(0x103c, 0x8a30, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 10442 SND_PCI_QUIRK(0x103c, 0x8a31, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10443 SND_PCI_QUIRK(0x103c, 0x8a6e, "HP EDNA 360", ALC287_FIXUP_CS35L41_I2C_4), 10444 SND_PCI_QUIRK(0x103c, 0x8a74, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 10445 SND_PCI_QUIRK(0x103c, 0x8a78, "HP Dev One", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST), 10446 SND_PCI_QUIRK(0x103c, 0x8aa0, "HP ProBook 440 G9 (MB 8A9E)", ALC236_FIXUP_HP_GPIO_LED), 10447 SND_PCI_QUIRK(0x103c, 0x8aa3, "HP ProBook 450 G9 (MB 8AA1)", ALC236_FIXUP_HP_GPIO_LED), 10448 SND_PCI_QUIRK(0x103c, 0x8aa8, "HP EliteBook 640 G9 (MB 8AA6)", ALC236_FIXUP_HP_GPIO_LED), 10449 SND_PCI_QUIRK(0x103c, 0x8aab, "HP EliteBook 650 G9 (MB 8AA9)", ALC236_FIXUP_HP_GPIO_LED), 10450 SND_PCI_QUIRK(0x103c, 0x8ab9, "HP EliteBook 840 G8 (MB 8AB8)", ALC285_FIXUP_HP_GPIO_LED), 10451 SND_PCI_QUIRK(0x103c, 0x8abb, "HP ZBook Firefly 14 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10452 SND_PCI_QUIRK(0x103c, 0x8ad1, "HP EliteBook 840 14 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10453 SND_PCI_QUIRK(0x103c, 0x8ad2, "HP EliteBook 860 16 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10454 SND_PCI_QUIRK(0x103c, 0x8ad8, "HP 800 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10455 SND_PCI_QUIRK(0x103c, 0x8b0f, "HP Elite mt645 G7 Mobile Thin Client U81", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10456 SND_PCI_QUIRK(0x103c, 0x8b2f, "HP 255 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10457 SND_PCI_QUIRK(0x103c, 0x8b3a, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10458 SND_PCI_QUIRK(0x103c, 0x8b3f, "HP mt440 Mobile Thin Client U91", ALC236_FIXUP_HP_GPIO_LED), 10459 SND_PCI_QUIRK(0x103c, 0x8b42, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10460 SND_PCI_QUIRK(0x103c, 0x8b43, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10461 SND_PCI_QUIRK(0x103c, 0x8b44, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10462 SND_PCI_QUIRK(0x103c, 0x8b45, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10463 SND_PCI_QUIRK(0x103c, 0x8b46, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10464 SND_PCI_QUIRK(0x103c, 0x8b47, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10465 SND_PCI_QUIRK(0x103c, 0x8b59, "HP Elite mt645 G7 Mobile Thin Client U89", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10466 SND_PCI_QUIRK(0x103c, 0x8b5d, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10467 SND_PCI_QUIRK(0x103c, 0x8b5e, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10468 SND_PCI_QUIRK(0x103c, 0x8b63, "HP Elite Dragonfly 13.5 inch G4", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED), 10469 SND_PCI_QUIRK(0x103c, 0x8b65, "HP ProBook 455 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10470 SND_PCI_QUIRK(0x103c, 0x8b66, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10471 SND_PCI_QUIRK(0x103c, 0x8b70, "HP EliteBook 835 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 10472 SND_PCI_QUIRK(0x103c, 0x8b72, "HP EliteBook 845 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 10473 SND_PCI_QUIRK(0x103c, 0x8b74, "HP EliteBook 845W G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 10474 SND_PCI_QUIRK(0x103c, 0x8b77, "HP ElieBook 865 G10", ALC287_FIXUP_CS35L41_I2C_2), 10475 SND_PCI_QUIRK(0x103c, 0x8b7a, "HP", ALC236_FIXUP_HP_GPIO_LED), 10476 SND_PCI_QUIRK(0x103c, 0x8b7d, "HP", ALC236_FIXUP_HP_GPIO_LED), 10477 SND_PCI_QUIRK(0x103c, 0x8b87, "HP", ALC236_FIXUP_HP_GPIO_LED), 10478 SND_PCI_QUIRK(0x103c, 0x8b8a, "HP", ALC236_FIXUP_HP_GPIO_LED), 10479 SND_PCI_QUIRK(0x103c, 0x8b8b, "HP", ALC236_FIXUP_HP_GPIO_LED), 10480 SND_PCI_QUIRK(0x103c, 0x8b8d, "HP", ALC236_FIXUP_HP_GPIO_LED), 10481 SND_PCI_QUIRK(0x103c, 0x8b8f, "HP", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED), 10482 SND_PCI_QUIRK(0x103c, 0x8b92, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10483 SND_PCI_QUIRK(0x103c, 0x8b96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10484 SND_PCI_QUIRK(0x103c, 0x8b97, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10485 SND_PCI_QUIRK(0x103c, 0x8bb3, "HP Slim OMEN", ALC287_FIXUP_CS35L41_I2C_2), 10486 SND_PCI_QUIRK(0x103c, 0x8bb4, "HP Slim OMEN", ALC287_FIXUP_CS35L41_I2C_2), 10487 SND_PCI_QUIRK(0x103c, 0x8bdd, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 10488 SND_PCI_QUIRK(0x103c, 0x8bde, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 10489 SND_PCI_QUIRK(0x103c, 0x8bdf, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10490 SND_PCI_QUIRK(0x103c, 0x8be0, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10491 SND_PCI_QUIRK(0x103c, 0x8be1, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10492 SND_PCI_QUIRK(0x103c, 0x8be2, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10493 SND_PCI_QUIRK(0x103c, 0x8be3, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10494 SND_PCI_QUIRK(0x103c, 0x8be5, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2), 10495 SND_PCI_QUIRK(0x103c, 0x8be6, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2), 10496 SND_PCI_QUIRK(0x103c, 0x8be7, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 10497 SND_PCI_QUIRK(0x103c, 0x8be8, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 10498 SND_PCI_QUIRK(0x103c, 0x8be9, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10499 SND_PCI_QUIRK(0x103c, 0x8bf0, "HP", ALC236_FIXUP_HP_GPIO_LED), 10500 SND_PCI_QUIRK(0x103c, 0x8c15, "HP Spectre x360 2-in-1 Laptop 14-eu0xxx", ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX), 10501 SND_PCI_QUIRK(0x103c, 0x8c16, "HP Spectre x360 2-in-1 Laptop 16-aa0xxx", ALC245_FIXUP_HP_SPECTRE_X360_16_AA0XXX), 10502 SND_PCI_QUIRK(0x103c, 0x8c17, "HP Spectre 16", ALC287_FIXUP_CS35L41_I2C_2), 10503 SND_PCI_QUIRK(0x103c, 0x8c21, "HP Pavilion Plus Laptop 14-ey0XXX", ALC245_FIXUP_HP_X360_MUTE_LEDS), 10504 SND_PCI_QUIRK(0x103c, 0x8c30, "HP Victus 15-fb1xxx", ALC245_FIXUP_HP_MUTE_LED_COEFBIT), 10505 SND_PCI_QUIRK(0x103c, 0x8c46, "HP EliteBook 830 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10506 SND_PCI_QUIRK(0x103c, 0x8c47, "HP EliteBook 840 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10507 SND_PCI_QUIRK(0x103c, 0x8c48, "HP EliteBook 860 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10508 SND_PCI_QUIRK(0x103c, 0x8c49, "HP Elite x360 830 2-in-1 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10509 SND_PCI_QUIRK(0x103c, 0x8c4d, "HP Omen", ALC287_FIXUP_CS35L41_I2C_2), 10510 SND_PCI_QUIRK(0x103c, 0x8c4e, "HP Omen", ALC287_FIXUP_CS35L41_I2C_2), 10511 SND_PCI_QUIRK(0x103c, 0x8c4f, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10512 SND_PCI_QUIRK(0x103c, 0x8c50, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 10513 SND_PCI_QUIRK(0x103c, 0x8c51, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 10514 SND_PCI_QUIRK(0x103c, 0x8c52, "HP EliteBook 1040 G11", ALC285_FIXUP_HP_GPIO_LED), 10515 SND_PCI_QUIRK(0x103c, 0x8c53, "HP Elite x360 1040 2-in-1 G11", ALC285_FIXUP_HP_GPIO_LED), 10516 SND_PCI_QUIRK(0x103c, 0x8c66, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2), 10517 SND_PCI_QUIRK(0x103c, 0x8c67, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 10518 SND_PCI_QUIRK(0x103c, 0x8c68, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 10519 SND_PCI_QUIRK(0x103c, 0x8c6a, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2), 10520 SND_PCI_QUIRK(0x103c, 0x8c70, "HP EliteBook 835 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 10521 SND_PCI_QUIRK(0x103c, 0x8c71, "HP EliteBook 845 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 10522 SND_PCI_QUIRK(0x103c, 0x8c72, "HP EliteBook 865 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 10523 SND_PCI_QUIRK(0x103c, 0x8c7b, "HP ProBook 445 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10524 SND_PCI_QUIRK(0x103c, 0x8c7c, "HP ProBook 445 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10525 SND_PCI_QUIRK(0x103c, 0x8c7d, "HP ProBook 465 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10526 SND_PCI_QUIRK(0x103c, 0x8c7e, "HP ProBook 465 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10527 SND_PCI_QUIRK(0x103c, 0x8c7f, "HP EliteBook 645 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10528 SND_PCI_QUIRK(0x103c, 0x8c80, "HP EliteBook 645 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10529 SND_PCI_QUIRK(0x103c, 0x8c81, "HP EliteBook 665 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10530 SND_PCI_QUIRK(0x103c, 0x8c89, "HP ProBook 460 G11", ALC236_FIXUP_HP_GPIO_LED), 10531 SND_PCI_QUIRK(0x103c, 0x8c8a, "HP EliteBook 630", ALC236_FIXUP_HP_GPIO_LED), 10532 SND_PCI_QUIRK(0x103c, 0x8c8c, "HP EliteBook 660", ALC236_FIXUP_HP_GPIO_LED), 10533 SND_PCI_QUIRK(0x103c, 0x8c8d, "HP ProBook 440 G11", ALC236_FIXUP_HP_GPIO_LED), 10534 SND_PCI_QUIRK(0x103c, 0x8c8e, "HP ProBook 460 G11", ALC236_FIXUP_HP_GPIO_LED), 10535 SND_PCI_QUIRK(0x103c, 0x8c90, "HP EliteBook 640", ALC236_FIXUP_HP_GPIO_LED), 10536 SND_PCI_QUIRK(0x103c, 0x8c91, "HP EliteBook 660", ALC236_FIXUP_HP_GPIO_LED), 10537 SND_PCI_QUIRK(0x103c, 0x8c96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10538 SND_PCI_QUIRK(0x103c, 0x8c97, "HP ZBook", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10539 SND_PCI_QUIRK(0x103c, 0x8ca1, "HP ZBook Power", ALC236_FIXUP_HP_GPIO_LED), 10540 SND_PCI_QUIRK(0x103c, 0x8ca2, "HP ZBook Power", ALC236_FIXUP_HP_GPIO_LED), 10541 SND_PCI_QUIRK(0x103c, 0x8ca4, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10542 SND_PCI_QUIRK(0x103c, 0x8ca7, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10543 SND_PCI_QUIRK(0x103c, 0x8caf, "HP Elite mt645 G8 Mobile Thin Client", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10544 SND_PCI_QUIRK(0x103c, 0x8cbd, "HP Pavilion Aero Laptop 13-bg0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS), 10545 SND_PCI_QUIRK(0x103c, 0x8cdd, "HP Spectre", ALC287_FIXUP_CS35L41_I2C_2), 10546 SND_PCI_QUIRK(0x103c, 0x8cde, "HP Spectre", ALC287_FIXUP_CS35L41_I2C_2), 10547 SND_PCI_QUIRK(0x103c, 0x8cdf, "HP SnowWhite", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 10548 SND_PCI_QUIRK(0x103c, 0x8ce0, "HP SnowWhite", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 10549 SND_PCI_QUIRK(0x103c, 0x8cf5, "HP ZBook Studio 16", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED), 10550 SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC), 10551 SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300), 10552 SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 10553 SND_PCI_QUIRK(0x1043, 0x10a1, "ASUS UX391UA", ALC294_FIXUP_ASUS_SPK), 10554 SND_PCI_QUIRK(0x1043, 0x10a4, "ASUS TP3407SA", ALC287_FIXUP_TAS2781_I2C), 10555 SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC), 10556 SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE), 10557 SND_PCI_QUIRK(0x1043, 0x10d3, "ASUS K6500ZC", ALC294_FIXUP_ASUS_SPK), 10558 SND_PCI_QUIRK(0x1043, 0x1154, "ASUS TP3607SH", ALC287_FIXUP_TAS2781_I2C), 10559 SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 10560 SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE), 10561 SND_PCI_QUIRK(0x1043, 0x1204, "ASUS Strix G615JHR_JMR_JPR", ALC287_FIXUP_TAS2781_I2C), 10562 SND_PCI_QUIRK(0x1043, 0x1214, "ASUS Strix G615LH_LM_LP", ALC287_FIXUP_TAS2781_I2C), 10563 SND_PCI_QUIRK(0x1043, 0x125e, "ASUS Q524UQK", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE), 10564 SND_PCI_QUIRK(0x1043, 0x1271, "ASUS X430UN", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE), 10565 SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE), 10566 SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE), 10567 SND_PCI_QUIRK(0x1043, 0x12a3, "Asus N7691ZM", ALC269_FIXUP_ASUS_N7601ZM), 10568 SND_PCI_QUIRK(0x1043, 0x12af, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2), 10569 SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC), 10570 SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC), 10571 SND_PCI_QUIRK(0x1043, 0x1313, "Asus K42JZ", ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE), 10572 SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC), 10573 SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK), 10574 SND_PCI_QUIRK(0x1043, 0x1433, "ASUS GX650PY/PZ/PV/PU/PYV/PZV/PIV/PVV", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC), 10575 SND_PCI_QUIRK(0x1043, 0x1463, "Asus GA402X/GA402N", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC), 10576 SND_PCI_QUIRK(0x1043, 0x1473, "ASUS GU604VI/VC/VE/VG/VJ/VQ/VU/VV/VY/VZ", ALC285_FIXUP_ASUS_HEADSET_MIC), 10577 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS GU603VQ/VU/VV/VJ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC), 10578 SND_PCI_QUIRK(0x1043, 0x1493, "ASUS GV601VV/VU/VJ/VQ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC), 10579 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G614JY/JZ/JG", ALC245_FIXUP_CS35L41_SPI_2), 10580 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS G513PI/PU/PV", ALC287_FIXUP_CS35L41_I2C_2), 10581 SND_PCI_QUIRK(0x1043, 0x1503, "ASUS G733PY/PZ/PZV/PYV", ALC287_FIXUP_CS35L41_I2C_2), 10582 SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A), 10583 SND_PCI_QUIRK(0x1043, 0x1533, "ASUS GV302XA/XJ/XQ/XU/XV/XI", ALC287_FIXUP_CS35L41_I2C_2), 10584 SND_PCI_QUIRK(0x1043, 0x1573, "ASUS GZ301VV/VQ/VU/VJ/VA/VC/VE/VVC/VQC/VUC/VJC/VEC/VCC", ALC285_FIXUP_ASUS_HEADSET_MIC), 10585 SND_PCI_QUIRK(0x1043, 0x1662, "ASUS GV301QH", ALC294_FIXUP_ASUS_DUAL_SPK), 10586 SND_PCI_QUIRK(0x1043, 0x1663, "ASUS GU603ZI/ZJ/ZQ/ZU/ZV", ALC285_FIXUP_ASUS_HEADSET_MIC), 10587 SND_PCI_QUIRK(0x1043, 0x1683, "ASUS UM3402YAR", ALC287_FIXUP_CS35L41_I2C_2), 10588 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS UX3402VA", ALC245_FIXUP_CS35L41_SPI_2), 10589 SND_PCI_QUIRK(0x1043, 0x16b2, "ASUS GU603", ALC289_FIXUP_ASUS_GA401), 10590 SND_PCI_QUIRK(0x1043, 0x16d3, "ASUS UX5304VA", ALC245_FIXUP_CS35L41_SPI_2), 10591 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC), 10592 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS UX7602VI/BZ", ALC245_FIXUP_CS35L41_SPI_2), 10593 SND_PCI_QUIRK(0x1043, 0x1740, "ASUS UX430UA", ALC295_FIXUP_ASUS_DACS), 10594 SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_DUAL_SPK), 10595 SND_PCI_QUIRK(0x1043, 0x17f3, "ROG Ally NR2301L/X", ALC294_FIXUP_ASUS_ALLY), 10596 SND_PCI_QUIRK(0x1043, 0x1eb3, "ROG Ally X RC72LA", ALC294_FIXUP_ASUS_ALLY_X), 10597 SND_PCI_QUIRK(0x1043, 0x1863, "ASUS UX6404VI/VV", ALC245_FIXUP_CS35L41_SPI_2), 10598 SND_PCI_QUIRK(0x1043, 0x1881, "ASUS Zephyrus S/M", ALC294_FIXUP_ASUS_GX502_PINS), 10599 SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC), 10600 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS UM3504DA", ALC294_FIXUP_CS35L41_I2C_2), 10601 SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC), 10602 SND_PCI_QUIRK(0x1043, 0x194e, "ASUS UX563FD", ALC294_FIXUP_ASUS_HPE), 10603 SND_PCI_QUIRK(0x1043, 0x1970, "ASUS UX550VE", ALC289_FIXUP_ASUS_GA401), 10604 SND_PCI_QUIRK(0x1043, 0x1982, "ASUS B1400CEPE", ALC256_FIXUP_ASUS_HPE), 10605 SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE), 10606 SND_PCI_QUIRK(0x1043, 0x19e1, "ASUS UX581LV", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE), 10607 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW), 10608 SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC), 10609 SND_PCI_QUIRK(0x1043, 0x1a63, "ASUS UX3405MA", ALC245_FIXUP_CS35L41_SPI_2), 10610 SND_PCI_QUIRK(0x1043, 0x1a83, "ASUS UM5302LA", ALC294_FIXUP_CS35L41_I2C_2), 10611 SND_PCI_QUIRK(0x1043, 0x1a8f, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2), 10612 SND_PCI_QUIRK(0x1043, 0x1b11, "ASUS UX431DA", ALC294_FIXUP_ASUS_COEF_1B), 10613 SND_PCI_QUIRK(0x1043, 0x1b13, "ASUS U41SV/GA403U", ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC), 10614 SND_PCI_QUIRK(0x1043, 0x1b93, "ASUS G614JVR/JIR", ALC245_FIXUP_CS35L41_SPI_2), 10615 SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE), 10616 SND_PCI_QUIRK(0x1043, 0x1c03, "ASUS UM3406HA", ALC287_FIXUP_CS35L41_I2C_2), 10617 SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 10618 SND_PCI_QUIRK(0x1043, 0x1c33, "ASUS UX5304MA", ALC245_FIXUP_CS35L41_SPI_2), 10619 SND_PCI_QUIRK(0x1043, 0x1c43, "ASUS UX8406MA", ALC245_FIXUP_CS35L41_SPI_2), 10620 SND_PCI_QUIRK(0x1043, 0x1c62, "ASUS GU603", ALC289_FIXUP_ASUS_GA401), 10621 SND_PCI_QUIRK(0x1043, 0x1c63, "ASUS GU605M", ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1), 10622 SND_PCI_QUIRK(0x1043, 0x1c92, "ASUS ROG Strix G15", ALC285_FIXUP_ASUS_G533Z_PINS), 10623 SND_PCI_QUIRK(0x1043, 0x1c9f, "ASUS G614JU/JV/JI", ALC285_FIXUP_ASUS_HEADSET_MIC), 10624 SND_PCI_QUIRK(0x1043, 0x1caf, "ASUS G634JY/JZ/JI/JG", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS), 10625 SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC), 10626 SND_PCI_QUIRK(0x1043, 0x1ccf, "ASUS G814JU/JV/JI", ALC245_FIXUP_CS35L41_SPI_2), 10627 SND_PCI_QUIRK(0x1043, 0x1cdf, "ASUS G814JY/JZ/JG", ALC245_FIXUP_CS35L41_SPI_2), 10628 SND_PCI_QUIRK(0x1043, 0x1cef, "ASUS G834JY/JZ/JI/JG", ALC285_FIXUP_ASUS_HEADSET_MIC), 10629 SND_PCI_QUIRK(0x1043, 0x1d1f, "ASUS G713PI/PU/PV/PVN", ALC287_FIXUP_CS35L41_I2C_2), 10630 SND_PCI_QUIRK(0x1043, 0x1d42, "ASUS Zephyrus G14 2022", ALC289_FIXUP_ASUS_GA401), 10631 SND_PCI_QUIRK(0x1043, 0x1d4e, "ASUS TM420", ALC256_FIXUP_ASUS_HPE), 10632 SND_PCI_QUIRK(0x1043, 0x1da2, "ASUS UP6502ZA/ZD", ALC245_FIXUP_CS35L41_SPI_2), 10633 SND_PCI_QUIRK(0x1043, 0x1e02, "ASUS UX3402ZA", ALC245_FIXUP_CS35L41_SPI_2), 10634 SND_PCI_QUIRK(0x1043, 0x1e11, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA502), 10635 SND_PCI_QUIRK(0x1043, 0x1e12, "ASUS UM3402", ALC287_FIXUP_CS35L41_I2C_2), 10636 SND_PCI_QUIRK(0x1043, 0x1e1f, "ASUS Vivobook 15 X1504VAP", ALC2XX_FIXUP_HEADSET_MIC), 10637 SND_PCI_QUIRK(0x1043, 0x1e51, "ASUS Zephyrus M15", ALC294_FIXUP_ASUS_GU502_PINS), 10638 SND_PCI_QUIRK(0x1043, 0x1e5e, "ASUS ROG Strix G513", ALC294_FIXUP_ASUS_G513_PINS), 10639 SND_PCI_QUIRK(0x1043, 0x1e8e, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA401), 10640 SND_PCI_QUIRK(0x1043, 0x1eb3, "ASUS Ally RCLA72", ALC287_FIXUP_TAS2781_I2C), 10641 SND_PCI_QUIRK(0x1043, 0x1ed3, "ASUS HN7306W", ALC287_FIXUP_CS35L41_I2C_2), 10642 SND_PCI_QUIRK(0x1043, 0x1ee2, "ASUS UM6702RA/RC", ALC287_FIXUP_CS35L41_I2C_2), 10643 SND_PCI_QUIRK(0x1043, 0x1c52, "ASUS Zephyrus G15 2022", ALC289_FIXUP_ASUS_GA401), 10644 SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401), 10645 SND_PCI_QUIRK(0x1043, 0x1f12, "ASUS UM5302", ALC287_FIXUP_CS35L41_I2C_2), 10646 SND_PCI_QUIRK(0x1043, 0x1f1f, "ASUS H7604JI/JV/J3D", ALC245_FIXUP_CS35L41_SPI_2), 10647 SND_PCI_QUIRK(0x1043, 0x1f62, "ASUS UX7602ZM", ALC245_FIXUP_CS35L41_SPI_2), 10648 SND_PCI_QUIRK(0x1043, 0x1f92, "ASUS ROG Flow X16", ALC289_FIXUP_ASUS_GA401), 10649 SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2), 10650 SND_PCI_QUIRK(0x1043, 0x3a20, "ASUS G614JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS), 10651 SND_PCI_QUIRK(0x1043, 0x3a30, "ASUS G814JVR/JIR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS), 10652 SND_PCI_QUIRK(0x1043, 0x3a40, "ASUS G814JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS), 10653 SND_PCI_QUIRK(0x1043, 0x3a50, "ASUS G834JYR/JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS), 10654 SND_PCI_QUIRK(0x1043, 0x3a60, "ASUS G634JYR/JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS), 10655 SND_PCI_QUIRK(0x1043, 0x3e30, "ASUS TP3607SA", ALC287_FIXUP_TAS2781_I2C), 10656 SND_PCI_QUIRK(0x1043, 0x3ee0, "ASUS Strix G815_JHR_JMR_JPR", ALC287_FIXUP_TAS2781_I2C), 10657 SND_PCI_QUIRK(0x1043, 0x3ef0, "ASUS Strix G635LR_LW_LX", ALC287_FIXUP_TAS2781_I2C), 10658 SND_PCI_QUIRK(0x1043, 0x3f00, "ASUS Strix G815LH_LM_LP", ALC287_FIXUP_TAS2781_I2C), 10659 SND_PCI_QUIRK(0x1043, 0x3f10, "ASUS Strix G835LR_LW_LX", ALC287_FIXUP_TAS2781_I2C), 10660 SND_PCI_QUIRK(0x1043, 0x3f20, "ASUS Strix G615LR_LW", ALC287_FIXUP_TAS2781_I2C), 10661 SND_PCI_QUIRK(0x1043, 0x3f30, "ASUS Strix G815LR_LW", ALC287_FIXUP_TAS2781_I2C), 10662 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC), 10663 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC), 10664 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC), 10665 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC), 10666 SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101), 10667 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2), 10668 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ), 10669 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ), 10670 SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX), 10671 SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE), 10672 SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE), 10673 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK), 10674 SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT), 10675 SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN), 10676 SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC), 10677 SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN), 10678 SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC), 10679 SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE), 10680 SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE), 10681 SND_PCI_QUIRK(0x10ec, 0x119e, "Positivo SU C1400", ALC269_FIXUP_ASPIRE_HEADSET_MIC), 10682 SND_PCI_QUIRK(0x10ec, 0x11bc, "VAIO VJFE-IL", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 10683 SND_PCI_QUIRK(0x10ec, 0x1230, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 10684 SND_PCI_QUIRK(0x10ec, 0x124c, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 10685 SND_PCI_QUIRK(0x10ec, 0x1252, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 10686 SND_PCI_QUIRK(0x10ec, 0x1254, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 10687 SND_PCI_QUIRK(0x10ec, 0x12cc, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 10688 SND_PCI_QUIRK(0x10ec, 0x12f6, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 10689 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_ASPIRE_HEADSET_MIC), 10690 SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC), 10691 SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_AMP), 10692 SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_AMP), 10693 SND_PCI_QUIRK(0x144d, 0xc189, "Samsung Galaxy Flex Book (NT950QCG-X716)", ALC298_FIXUP_SAMSUNG_AMP), 10694 SND_PCI_QUIRK(0x144d, 0xc18a, "Samsung Galaxy Book Ion (NP930XCJ-K01US)", ALC298_FIXUP_SAMSUNG_AMP), 10695 SND_PCI_QUIRK(0x144d, 0xc1a3, "Samsung Galaxy Book Pro (NP935XDB-KC1SE)", ALC298_FIXUP_SAMSUNG_AMP), 10696 SND_PCI_QUIRK(0x144d, 0xc1a4, "Samsung Galaxy Book Pro 360 (NT935QBD)", ALC298_FIXUP_SAMSUNG_AMP), 10697 SND_PCI_QUIRK(0x144d, 0xc1a6, "Samsung Galaxy Book Pro 360 (NP930QBD)", ALC298_FIXUP_SAMSUNG_AMP), 10698 SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8), 10699 SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_AMP), 10700 SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_AMP), 10701 SND_PCI_QUIRK(0x144d, 0xc832, "Samsung Galaxy Book Flex Alpha (NP730QCJ)", ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), 10702 SND_PCI_QUIRK(0x144d, 0xca03, "Samsung Galaxy Book2 Pro 360 (NP930QED)", ALC298_FIXUP_SAMSUNG_AMP), 10703 SND_PCI_QUIRK(0x144d, 0xc868, "Samsung Galaxy Book2 Pro (NP930XED)", ALC298_FIXUP_SAMSUNG_AMP), 10704 SND_PCI_QUIRK(0x144d, 0xc870, "Samsung Galaxy Book2 Pro (NP950XED)", ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS), 10705 SND_PCI_QUIRK(0x144d, 0xc872, "Samsung Galaxy Book2 Pro (NP950XEE)", ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS), 10706 SND_PCI_QUIRK(0x144d, 0xc886, "Samsung Galaxy Book3 Pro (NP964XFG)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS), 10707 SND_PCI_QUIRK(0x144d, 0xc1ca, "Samsung Galaxy Book3 Pro 360 (NP960QFG)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS), 10708 SND_PCI_QUIRK(0x144d, 0xc1cc, "Samsung Galaxy Book3 Ultra (NT960XFH)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS), 10709 SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC), 10710 SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC), 10711 SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC), 10712 SND_PCI_QUIRK(0x152d, 0x1082, "Quanta NL3", ALC269_FIXUP_LIFEBOOK), 10713 SND_PCI_QUIRK(0x152d, 0x1262, "Huawei NBLB-WAX9N", ALC2XX_FIXUP_HEADSET_MIC), 10714 SND_PCI_QUIRK(0x1558, 0x0353, "Clevo V35[05]SN[CDE]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10715 SND_PCI_QUIRK(0x1558, 0x1323, "Clevo N130ZU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10716 SND_PCI_QUIRK(0x1558, 0x1325, "Clevo N15[01][CW]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10717 SND_PCI_QUIRK(0x1558, 0x1401, "Clevo L140[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10718 SND_PCI_QUIRK(0x1558, 0x1403, "Clevo N140CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10719 SND_PCI_QUIRK(0x1558, 0x1404, "Clevo N150CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10720 SND_PCI_QUIRK(0x1558, 0x14a1, "Clevo L141MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10721 SND_PCI_QUIRK(0x1558, 0x2624, "Clevo L240TU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10722 SND_PCI_QUIRK(0x1558, 0x4018, "Clevo NV40M[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10723 SND_PCI_QUIRK(0x1558, 0x4019, "Clevo NV40MZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10724 SND_PCI_QUIRK(0x1558, 0x4020, "Clevo NV40MB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10725 SND_PCI_QUIRK(0x1558, 0x4041, "Clevo NV4[15]PZ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10726 SND_PCI_QUIRK(0x1558, 0x40a1, "Clevo NL40GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10727 SND_PCI_QUIRK(0x1558, 0x40c1, "Clevo NL40[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10728 SND_PCI_QUIRK(0x1558, 0x40d1, "Clevo NL41DU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10729 SND_PCI_QUIRK(0x1558, 0x5015, "Clevo NH5[58]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10730 SND_PCI_QUIRK(0x1558, 0x5017, "Clevo NH7[79]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10731 SND_PCI_QUIRK(0x1558, 0x50a3, "Clevo NJ51GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10732 SND_PCI_QUIRK(0x1558, 0x50b3, "Clevo NK50S[BEZ]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10733 SND_PCI_QUIRK(0x1558, 0x50b6, "Clevo NK50S5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10734 SND_PCI_QUIRK(0x1558, 0x50b8, "Clevo NK50SZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10735 SND_PCI_QUIRK(0x1558, 0x50d5, "Clevo NP50D5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10736 SND_PCI_QUIRK(0x1558, 0x50e1, "Clevo NH5[58]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10737 SND_PCI_QUIRK(0x1558, 0x50e2, "Clevo NH7[79]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10738 SND_PCI_QUIRK(0x1558, 0x50f0, "Clevo NH50A[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10739 SND_PCI_QUIRK(0x1558, 0x50f2, "Clevo NH50E[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10740 SND_PCI_QUIRK(0x1558, 0x50f3, "Clevo NH58DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10741 SND_PCI_QUIRK(0x1558, 0x50f5, "Clevo NH55EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10742 SND_PCI_QUIRK(0x1558, 0x50f6, "Clevo NH55DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10743 SND_PCI_QUIRK(0x1558, 0x5101, "Clevo S510WU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10744 SND_PCI_QUIRK(0x1558, 0x5157, "Clevo W517GU1", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10745 SND_PCI_QUIRK(0x1558, 0x51a1, "Clevo NS50MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10746 SND_PCI_QUIRK(0x1558, 0x51b1, "Clevo NS50AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10747 SND_PCI_QUIRK(0x1558, 0x51b3, "Clevo NS70AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10748 SND_PCI_QUIRK(0x1558, 0x5630, "Clevo NP50RNJS", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10749 SND_PCI_QUIRK(0x1558, 0x70a1, "Clevo NB70T[HJK]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10750 SND_PCI_QUIRK(0x1558, 0x70b3, "Clevo NK70SB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10751 SND_PCI_QUIRK(0x1558, 0x70f2, "Clevo NH79EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10752 SND_PCI_QUIRK(0x1558, 0x70f3, "Clevo NH77DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10753 SND_PCI_QUIRK(0x1558, 0x70f4, "Clevo NH77EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10754 SND_PCI_QUIRK(0x1558, 0x70f6, "Clevo NH77DPQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10755 SND_PCI_QUIRK(0x1558, 0x7716, "Clevo NS50PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10756 SND_PCI_QUIRK(0x1558, 0x7717, "Clevo NS70PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10757 SND_PCI_QUIRK(0x1558, 0x7718, "Clevo L140PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10758 SND_PCI_QUIRK(0x1558, 0x7724, "Clevo L140AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10759 SND_PCI_QUIRK(0x1558, 0x8228, "Clevo NR40BU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10760 SND_PCI_QUIRK(0x1558, 0x8520, "Clevo NH50D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10761 SND_PCI_QUIRK(0x1558, 0x8521, "Clevo NH77D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10762 SND_PCI_QUIRK(0x1558, 0x8535, "Clevo NH50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10763 SND_PCI_QUIRK(0x1558, 0x8536, "Clevo NH79D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10764 SND_PCI_QUIRK(0x1558, 0x8550, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10765 SND_PCI_QUIRK(0x1558, 0x8551, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10766 SND_PCI_QUIRK(0x1558, 0x8560, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC), 10767 SND_PCI_QUIRK(0x1558, 0x8561, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC), 10768 SND_PCI_QUIRK(0x1558, 0x8562, "Clevo NH[57][0-9]RZ[Q]", ALC269_FIXUP_DMIC), 10769 SND_PCI_QUIRK(0x1558, 0x8668, "Clevo NP50B[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10770 SND_PCI_QUIRK(0x1558, 0x866d, "Clevo NP5[05]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10771 SND_PCI_QUIRK(0x1558, 0x867c, "Clevo NP7[01]PNP", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10772 SND_PCI_QUIRK(0x1558, 0x867d, "Clevo NP7[01]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10773 SND_PCI_QUIRK(0x1558, 0x8680, "Clevo NJ50LU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10774 SND_PCI_QUIRK(0x1558, 0x8686, "Clevo NH50[CZ]U", ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME), 10775 SND_PCI_QUIRK(0x1558, 0x8a20, "Clevo NH55DCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10776 SND_PCI_QUIRK(0x1558, 0x8a51, "Clevo NH70RCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10777 SND_PCI_QUIRK(0x1558, 0x8d50, "Clevo NH55RCQ-M", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10778 SND_PCI_QUIRK(0x1558, 0x951d, "Clevo N950T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10779 SND_PCI_QUIRK(0x1558, 0x9600, "Clevo N960K[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10780 SND_PCI_QUIRK(0x1558, 0x961d, "Clevo N960S[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10781 SND_PCI_QUIRK(0x1558, 0x971d, "Clevo N970T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10782 SND_PCI_QUIRK(0x1558, 0xa500, "Clevo NL5[03]RU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10783 SND_PCI_QUIRK(0x1558, 0xa554, "VAIO VJFH52", ALC269_FIXUP_VAIO_VJFH52_MIC_NO_PRESENCE), 10784 SND_PCI_QUIRK(0x1558, 0xa600, "Clevo NL50NU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10785 SND_PCI_QUIRK(0x1558, 0xa650, "Clevo NP[567]0SN[CD]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10786 SND_PCI_QUIRK(0x1558, 0xa671, "Clevo NP70SN[CDE]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10787 SND_PCI_QUIRK(0x1558, 0xa741, "Clevo V54x_6x_TNE", ALC245_FIXUP_CLEVO_NOISY_MIC), 10788 SND_PCI_QUIRK(0x1558, 0xa763, "Clevo V54x_6x_TU", ALC245_FIXUP_CLEVO_NOISY_MIC), 10789 SND_PCI_QUIRK(0x1558, 0xb018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10790 SND_PCI_QUIRK(0x1558, 0xb019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10791 SND_PCI_QUIRK(0x1558, 0xb022, "Clevo NH77D[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10792 SND_PCI_QUIRK(0x1558, 0xc018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10793 SND_PCI_QUIRK(0x1558, 0xc019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10794 SND_PCI_QUIRK(0x1558, 0xc022, "Clevo NH77[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10795 SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS), 10796 SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340), 10797 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE), 10798 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE), 10799 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE), 10800 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE), 10801 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE), 10802 SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK), 10803 SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST), 10804 SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK), 10805 SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK), 10806 SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK), 10807 SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK), 10808 SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440), 10809 SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK), 10810 SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK), 10811 SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK), 10812 SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK), 10813 SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK), 10814 SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 10815 SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK), 10816 SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK), 10817 SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK), 10818 SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 10819 SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 10820 SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460), 10821 SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460), 10822 SND_PCI_QUIRK(0x17aa, 0x2234, "Thinkpad ICE-1", ALC287_FIXUP_TAS2781_I2C), 10823 SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK), 10824 SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 10825 SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 10826 SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460), 10827 SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 10828 SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 10829 SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 10830 SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 10831 SND_PCI_QUIRK(0x17aa, 0x2292, "Thinkpad X1 Carbon 7th", ALC285_FIXUP_THINKPAD_HEADSET_JACK), 10832 SND_PCI_QUIRK(0x17aa, 0x22be, "Thinkpad X1 Carbon 8th", ALC285_FIXUP_THINKPAD_HEADSET_JACK), 10833 SND_PCI_QUIRK(0x17aa, 0x22c1, "Thinkpad P1 Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK), 10834 SND_PCI_QUIRK(0x17aa, 0x22c2, "Thinkpad X1 Extreme Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK), 10835 SND_PCI_QUIRK(0x17aa, 0x22f1, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 10836 SND_PCI_QUIRK(0x17aa, 0x22f2, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 10837 SND_PCI_QUIRK(0x17aa, 0x22f3, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 10838 SND_PCI_QUIRK(0x17aa, 0x2316, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 10839 SND_PCI_QUIRK(0x17aa, 0x2317, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 10840 SND_PCI_QUIRK(0x17aa, 0x2318, "Thinkpad Z13 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 10841 SND_PCI_QUIRK(0x17aa, 0x2319, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 10842 SND_PCI_QUIRK(0x17aa, 0x231a, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 10843 SND_PCI_QUIRK(0x17aa, 0x231e, "Thinkpad", ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318), 10844 SND_PCI_QUIRK(0x17aa, 0x231f, "Thinkpad", ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318), 10845 SND_PCI_QUIRK(0x17aa, 0x2326, "Hera2", ALC287_FIXUP_TAS2781_I2C), 10846 SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY), 10847 SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY), 10848 SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 10849 SND_PCI_QUIRK(0x17aa, 0x3111, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 10850 SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 10851 SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 10852 SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 10853 SND_PCI_QUIRK(0x17aa, 0x3151, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC), 10854 SND_PCI_QUIRK(0x17aa, 0x3176, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC), 10855 SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC), 10856 SND_PCI_QUIRK(0x17aa, 0x31af, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340), 10857 SND_PCI_QUIRK(0x17aa, 0x334b, "Lenovo ThinkCentre M70 Gen5", ALC283_FIXUP_HEADSET_MIC), 10858 SND_PCI_QUIRK(0x17aa, 0x3801, "Lenovo Yoga9 14IAP7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN), 10859 SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo Yoga Pro 9 14IRP8 / DuetITL 2021", ALC287_FIXUP_LENOVO_14IRP8_DUETITL), 10860 SND_PCI_QUIRK(0x17aa, 0x3813, "Legion 7i 15IMHG05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS), 10861 SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940 / Yoga Duet 7", ALC298_FIXUP_LENOVO_C940_DUET7), 10862 SND_PCI_QUIRK(0x17aa, 0x3819, "Lenovo 13s Gen2 ITL", ALC287_FIXUP_13S_GEN2_SPEAKERS), 10863 SND_PCI_QUIRK(0x17aa, 0x3820, "IdeaPad 330 / Yoga Duet 7", ALC287_FIXUP_LENOVO_SSID_17AA3820), 10864 SND_PCI_QUIRK(0x17aa, 0x3824, "Legion Y9000X 2020", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS), 10865 SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF), 10866 SND_PCI_QUIRK(0x17aa, 0x3834, "Lenovo IdeaPad Slim 9i 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS), 10867 SND_PCI_QUIRK(0x17aa, 0x383d, "Legion Y9000X 2019", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS), 10868 SND_PCI_QUIRK(0x17aa, 0x3843, "Yoga 9i", ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP), 10869 SND_PCI_QUIRK(0x17aa, 0x3847, "Legion 7 16ACHG6", ALC287_FIXUP_LEGION_16ACHG6), 10870 SND_PCI_QUIRK(0x17aa, 0x384a, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS), 10871 SND_PCI_QUIRK(0x17aa, 0x3852, "Lenovo Yoga 7 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS), 10872 SND_PCI_QUIRK(0x17aa, 0x3853, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS), 10873 SND_PCI_QUIRK(0x17aa, 0x3855, "Legion 7 16ITHG6", ALC287_FIXUP_LEGION_16ITHG6), 10874 SND_PCI_QUIRK(0x17aa, 0x3865, "Lenovo 13X", ALC287_FIXUP_CS35L41_I2C_2), 10875 SND_PCI_QUIRK(0x17aa, 0x3866, "Lenovo 13X", ALC287_FIXUP_CS35L41_I2C_2), 10876 SND_PCI_QUIRK(0x17aa, 0x3869, "Lenovo Yoga7 14IAL7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN), 10877 SND_PCI_QUIRK(0x17aa, 0x386e, "Legion Y9000X 2022 IAH7 / Yoga Pro 7 14ARP8", ALC287_FIXUP_LENOVO_14ARP8_LEGION_IAH7), 10878 SND_PCI_QUIRK(0x17aa, 0x386f, "Legion Pro 7/7i", ALC287_FIXUP_LENOVO_LEGION_7), 10879 SND_PCI_QUIRK(0x17aa, 0x3870, "Lenovo Yoga 7 14ARB7", ALC287_FIXUP_YOGA7_14ARB7_I2C), 10880 SND_PCI_QUIRK(0x17aa, 0x3877, "Lenovo Legion 7 Slim 16ARHA7", ALC287_FIXUP_CS35L41_I2C_2), 10881 SND_PCI_QUIRK(0x17aa, 0x3878, "Lenovo Legion 7 Slim 16ARHA7", ALC287_FIXUP_CS35L41_I2C_2), 10882 SND_PCI_QUIRK(0x17aa, 0x387d, "Yoga S780-16 pro Quad AAC", ALC287_FIXUP_TAS2781_I2C), 10883 SND_PCI_QUIRK(0x17aa, 0x387e, "Yoga S780-16 pro Quad YC", ALC287_FIXUP_TAS2781_I2C), 10884 SND_PCI_QUIRK(0x17aa, 0x387f, "Yoga S780-16 pro dual LX", ALC287_FIXUP_TAS2781_I2C), 10885 SND_PCI_QUIRK(0x17aa, 0x3880, "Yoga S780-16 pro dual YC", ALC287_FIXUP_TAS2781_I2C), 10886 SND_PCI_QUIRK(0x17aa, 0x3881, "YB9 dual power mode2 YC", ALC287_FIXUP_TAS2781_I2C), 10887 SND_PCI_QUIRK(0x17aa, 0x3882, "Lenovo Yoga Pro 7 14APH8", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN), 10888 SND_PCI_QUIRK(0x17aa, 0x3884, "Y780 YG DUAL", ALC287_FIXUP_TAS2781_I2C), 10889 SND_PCI_QUIRK(0x17aa, 0x3886, "Y780 VECO DUAL", ALC287_FIXUP_TAS2781_I2C), 10890 SND_PCI_QUIRK(0x17aa, 0x3891, "Lenovo Yoga Pro 7 14AHP9", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN), 10891 SND_PCI_QUIRK(0x17aa, 0x38a5, "Y580P AMD dual", ALC287_FIXUP_TAS2781_I2C), 10892 SND_PCI_QUIRK(0x17aa, 0x38a7, "Y780P AMD YG dual", ALC287_FIXUP_TAS2781_I2C), 10893 SND_PCI_QUIRK(0x17aa, 0x38a8, "Y780P AMD VECO dual", ALC287_FIXUP_TAS2781_I2C), 10894 SND_PCI_QUIRK(0x17aa, 0x38a9, "Thinkbook 16P", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 10895 SND_PCI_QUIRK(0x17aa, 0x38ab, "Thinkbook 16P", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 10896 SND_PCI_QUIRK(0x17aa, 0x38b4, "Legion Slim 7 16IRH8", ALC287_FIXUP_CS35L41_I2C_2), 10897 SND_PCI_QUIRK(0x17aa, 0x38b5, "Legion Slim 7 16IRH8", ALC287_FIXUP_CS35L41_I2C_2), 10898 SND_PCI_QUIRK(0x17aa, 0x38b6, "Legion Slim 7 16APH8", ALC287_FIXUP_CS35L41_I2C_2), 10899 SND_PCI_QUIRK(0x17aa, 0x38b7, "Legion Slim 7 16APH8", ALC287_FIXUP_CS35L41_I2C_2), 10900 SND_PCI_QUIRK(0x17aa, 0x38b8, "Yoga S780-14.5 proX AMD YC Dual", ALC287_FIXUP_TAS2781_I2C), 10901 SND_PCI_QUIRK(0x17aa, 0x38b9, "Yoga S780-14.5 proX AMD LX Dual", ALC287_FIXUP_TAS2781_I2C), 10902 SND_PCI_QUIRK(0x17aa, 0x38ba, "Yoga S780-14.5 Air AMD quad YC", ALC287_FIXUP_TAS2781_I2C), 10903 SND_PCI_QUIRK(0x17aa, 0x38bb, "Yoga S780-14.5 Air AMD quad AAC", ALC287_FIXUP_TAS2781_I2C), 10904 SND_PCI_QUIRK(0x17aa, 0x38be, "Yoga S980-14.5 proX YC Dual", ALC287_FIXUP_TAS2781_I2C), 10905 SND_PCI_QUIRK(0x17aa, 0x38bf, "Yoga S980-14.5 proX LX Dual", ALC287_FIXUP_TAS2781_I2C), 10906 SND_PCI_QUIRK(0x17aa, 0x38c3, "Y980 DUAL", ALC287_FIXUP_TAS2781_I2C), 10907 SND_PCI_QUIRK(0x17aa, 0x38c7, "Thinkbook 13x Gen 4", ALC287_FIXUP_CS35L41_I2C_4), 10908 SND_PCI_QUIRK(0x17aa, 0x38c8, "Thinkbook 13x Gen 4", ALC287_FIXUP_CS35L41_I2C_4), 10909 SND_PCI_QUIRK(0x17aa, 0x38cb, "Y790 YG DUAL", ALC287_FIXUP_TAS2781_I2C), 10910 SND_PCI_QUIRK(0x17aa, 0x38cd, "Y790 VECO DUAL", ALC287_FIXUP_TAS2781_I2C), 10911 SND_PCI_QUIRK(0x17aa, 0x38d2, "Lenovo Yoga 9 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN), 10912 SND_PCI_QUIRK(0x17aa, 0x38d3, "Yoga S990-16 Pro IMH YC Dual", ALC287_FIXUP_TAS2781_I2C), 10913 SND_PCI_QUIRK(0x17aa, 0x38d4, "Yoga S990-16 Pro IMH VECO Dual", ALC287_FIXUP_TAS2781_I2C), 10914 SND_PCI_QUIRK(0x17aa, 0x38d5, "Yoga S990-16 Pro IMH YC Quad", ALC287_FIXUP_TAS2781_I2C), 10915 SND_PCI_QUIRK(0x17aa, 0x38d6, "Yoga S990-16 Pro IMH VECO Quad", ALC287_FIXUP_TAS2781_I2C), 10916 SND_PCI_QUIRK(0x17aa, 0x38d7, "Lenovo Yoga 9 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN), 10917 SND_PCI_QUIRK(0x17aa, 0x38df, "Yoga Y990 Intel YC Dual", ALC287_FIXUP_TAS2781_I2C), 10918 SND_PCI_QUIRK(0x17aa, 0x38e0, "Yoga Y990 Intel VECO Dual", ALC287_FIXUP_TAS2781_I2C), 10919 SND_PCI_QUIRK(0x17aa, 0x38f8, "Yoga Book 9i", ALC287_FIXUP_TAS2781_I2C), 10920 SND_PCI_QUIRK(0x17aa, 0x38df, "Y990 YG DUAL", ALC287_FIXUP_TAS2781_I2C), 10921 SND_PCI_QUIRK(0x17aa, 0x38f9, "Thinkbook 16P Gen5", ALC287_FIXUP_CS35L41_I2C_2), 10922 SND_PCI_QUIRK(0x17aa, 0x38fa, "Thinkbook 16P Gen5", ALC287_FIXUP_CS35L41_I2C_2), 10923 SND_PCI_QUIRK(0x17aa, 0x38fd, "ThinkBook plus Gen5 Hybrid", ALC287_FIXUP_TAS2781_I2C), 10924 SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI), 10925 SND_PCI_QUIRK(0x17aa, 0x3913, "Lenovo 145", ALC236_FIXUP_LENOVO_INV_DMIC), 10926 SND_PCI_QUIRK(0x17aa, 0x391f, "Yoga S990-16 pro Quad YC Quad", ALC287_FIXUP_TAS2781_I2C), 10927 SND_PCI_QUIRK(0x17aa, 0x3920, "Yoga S990-16 pro Quad VECO Quad", ALC287_FIXUP_TAS2781_I2C), 10928 SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC), 10929 SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI), 10930 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K), 10931 SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 10932 SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC), 10933 SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK), 10934 SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 10935 SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK), 10936 SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK), 10937 SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK), 10938 SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK), 10939 SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE), 10940 SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460), 10941 SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460), 10942 SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460), 10943 SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 10944 SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 10945 SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 10946 SND_PCI_QUIRK(0x17aa, 0x508b, "Thinkpad X12 Gen 1", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS), 10947 SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 10948 SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 10949 SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 10950 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD), 10951 SND_PCI_QUIRK(0x17aa, 0x9e56, "Lenovo ZhaoYang CF4620Z", ALC286_FIXUP_SONY_MIC_NO_PRESENCE), 10952 SND_PCI_QUIRK(0x1849, 0x1233, "ASRock NUC Box 1100", ALC233_FIXUP_NO_AUDIO_JACK), 10953 SND_PCI_QUIRK(0x1849, 0xa233, "Positivo Master C6300", ALC269_FIXUP_HEADSET_MIC), 10954 SND_PCI_QUIRK(0x1854, 0x0440, "LG CQ6", ALC256_FIXUP_HEADPHONE_AMP_VOL), 10955 SND_PCI_QUIRK(0x1854, 0x0441, "LG CQ6 AIO", ALC256_FIXUP_HEADPHONE_AMP_VOL), 10956 SND_PCI_QUIRK(0x1854, 0x0488, "LG gram 16 (16Z90R)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS), 10957 SND_PCI_QUIRK(0x1854, 0x048a, "LG gram 17 (17ZD90R)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS), 10958 SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS), 10959 SND_PCI_QUIRK(0x19e5, 0x320f, "Huawei WRT-WX9 ", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE), 10960 SND_PCI_QUIRK(0x19e5, 0x3212, "Huawei KLV-WX9 ", ALC256_FIXUP_ACER_HEADSET_MIC), 10961 SND_PCI_QUIRK(0x1b35, 0x1235, "CZC B20", ALC269_FIXUP_CZC_B20), 10962 SND_PCI_QUIRK(0x1b35, 0x1236, "CZC TMI", ALC269_FIXUP_CZC_TMI), 10963 SND_PCI_QUIRK(0x1b35, 0x1237, "CZC L101", ALC269_FIXUP_CZC_L101), 10964 SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */ 10965 SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802), 10966 SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X), 10967 SND_PCI_QUIRK(0x1c6c, 0x122a, "Positivo N14AP7", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 10968 SND_PCI_QUIRK(0x1c6c, 0x1251, "Positivo N14KP6-TG", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE), 10969 SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_SET_COEF_DEFAULTS), 10970 SND_PCI_QUIRK(0x1d05, 0x1096, "TongFang GMxMRxx", ALC269_FIXUP_NO_SHUTUP), 10971 SND_PCI_QUIRK(0x1d05, 0x1100, "TongFang GKxNRxx", ALC269_FIXUP_NO_SHUTUP), 10972 SND_PCI_QUIRK(0x1d05, 0x1111, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP), 10973 SND_PCI_QUIRK(0x1d05, 0x1119, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP), 10974 SND_PCI_QUIRK(0x1d05, 0x1129, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP), 10975 SND_PCI_QUIRK(0x1d05, 0x1147, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP), 10976 SND_PCI_QUIRK(0x1d05, 0x115c, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP), 10977 SND_PCI_QUIRK(0x1d05, 0x121b, "TongFang GMxAGxx", ALC269_FIXUP_NO_SHUTUP), 10978 SND_PCI_QUIRK(0x1d05, 0x1387, "TongFang GMxIXxx", ALC2XX_FIXUP_HEADSET_MIC), 10979 SND_PCI_QUIRK(0x1d17, 0x3288, "Haier Boyue G42", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS), 10980 SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC), 10981 SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE), 10982 SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC), 10983 SND_PCI_QUIRK(0x1d72, 0x1945, "Redmi G", ALC256_FIXUP_ASUS_HEADSET_MIC), 10984 SND_PCI_QUIRK(0x1d72, 0x1947, "RedmiBook Air", ALC255_FIXUP_XIAOMI_HEADSET_MIC), 10985 SND_PCI_QUIRK(0x2782, 0x0214, "VAIO VJFE-CL", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 10986 SND_PCI_QUIRK(0x2782, 0x0232, "CHUWI CoreBook XPro", ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO), 10987 SND_PCI_QUIRK(0x2782, 0x1707, "Vaio VJFE-ADL", ALC298_FIXUP_SPK_VOLUME), 10988 SND_PCI_QUIRK(0x8086, 0x2074, "Intel NUC 8", ALC233_FIXUP_INTEL_NUC8_DMIC), 10989 SND_PCI_QUIRK(0x8086, 0x2080, "Intel NUC 8 Rugged", ALC256_FIXUP_INTEL_NUC8_RUGGED), 10990 SND_PCI_QUIRK(0x8086, 0x2081, "Intel NUC 10", ALC256_FIXUP_INTEL_NUC10), 10991 SND_PCI_QUIRK(0x8086, 0x3038, "Intel NUC 13", ALC295_FIXUP_CHROME_BOOK), 10992 SND_PCI_QUIRK(0xf111, 0x0001, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE), 10993 SND_PCI_QUIRK(0xf111, 0x0006, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE), 10994 SND_PCI_QUIRK(0xf111, 0x0009, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE), 10995 10996 #if 0 10997 /* Below is a quirk table taken from the old code. 10998 * Basically the device should work as is without the fixup table. 10999 * If BIOS doesn't give a proper info, enable the corresponding 11000 * fixup entry. 11001 */ 11002 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A", 11003 ALC269_FIXUP_AMIC), 11004 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC), 11005 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC), 11006 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC), 11007 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC), 11008 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC), 11009 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC), 11010 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC), 11011 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC), 11012 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC), 11013 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC), 11014 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC), 11015 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC), 11016 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC), 11017 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC), 11018 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC), 11019 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC), 11020 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC), 11021 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC), 11022 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC), 11023 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC), 11024 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC), 11025 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC), 11026 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC), 11027 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC), 11028 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC), 11029 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC), 11030 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC), 11031 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC), 11032 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC), 11033 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC), 11034 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC), 11035 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC), 11036 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC), 11037 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC), 11038 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC), 11039 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC), 11040 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC), 11041 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC), 11042 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC), 11043 #endif 11044 {} 11045 }; 11046 11047 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = { 11048 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC), 11049 SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED), 11050 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO), 11051 SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI), 11052 SND_PCI_QUIRK_VENDOR(0x19e5, "Huawei Matebook", ALC255_FIXUP_MIC_MUTE_LED), 11053 {} 11054 }; 11055 11056 static const struct hda_model_fixup alc269_fixup_models[] = { 11057 {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"}, 11058 {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"}, 11059 {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"}, 11060 {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"}, 11061 {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"}, 11062 {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"}, 11063 {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"}, 11064 {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"}, 11065 {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"}, 11066 {.id = ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, .name = "lenovo-dock-limit-boost"}, 11067 {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"}, 11068 {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"}, 11069 {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"}, 11070 {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"}, 11071 {.id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, .name = "dell-headset3"}, 11072 {.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, .name = "dell-headset4"}, 11073 {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"}, 11074 {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"}, 11075 {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"}, 11076 {.id = ALC292_FIXUP_TPT440, .name = "tpt440"}, 11077 {.id = ALC292_FIXUP_TPT460, .name = "tpt460"}, 11078 {.id = ALC298_FIXUP_TPT470_DOCK_FIX, .name = "tpt470-dock-fix"}, 11079 {.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"}, 11080 {.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"}, 11081 {.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"}, 11082 {.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"}, 11083 {.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"}, 11084 {.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"}, 11085 {.id = ALC269_FIXUP_LENOVO_EAPD, .name = "lenovo-eapd"}, 11086 {.id = ALC275_FIXUP_SONY_HWEQ, .name = "sony-hweq"}, 11087 {.id = ALC269_FIXUP_PCM_44K, .name = "pcm44k"}, 11088 {.id = ALC269_FIXUP_LIFEBOOK, .name = "lifebook"}, 11089 {.id = ALC269_FIXUP_LIFEBOOK_EXTMIC, .name = "lifebook-extmic"}, 11090 {.id = ALC269_FIXUP_LIFEBOOK_HP_PIN, .name = "lifebook-hp-pin"}, 11091 {.id = ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, .name = "lifebook-u7x7"}, 11092 {.id = ALC269VB_FIXUP_AMIC, .name = "alc269vb-amic"}, 11093 {.id = ALC269VB_FIXUP_DMIC, .name = "alc269vb-dmic"}, 11094 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC1, .name = "hp-mute-led-mic1"}, 11095 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC2, .name = "hp-mute-led-mic2"}, 11096 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC3, .name = "hp-mute-led-mic3"}, 11097 {.id = ALC269_FIXUP_HP_GPIO_MIC1_LED, .name = "hp-gpio-mic1"}, 11098 {.id = ALC269_FIXUP_HP_LINE1_MIC1_LED, .name = "hp-line1-mic1"}, 11099 {.id = ALC269_FIXUP_NO_SHUTUP, .name = "noshutup"}, 11100 {.id = ALC286_FIXUP_SONY_MIC_NO_PRESENCE, .name = "sony-nomic"}, 11101 {.id = ALC269_FIXUP_ASPIRE_HEADSET_MIC, .name = "aspire-headset-mic"}, 11102 {.id = ALC269_FIXUP_ASUS_X101, .name = "asus-x101"}, 11103 {.id = ALC271_FIXUP_HP_GATE_MIC_JACK, .name = "acer-ao7xx"}, 11104 {.id = ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, .name = "acer-aspire-e1"}, 11105 {.id = ALC269_FIXUP_ACER_AC700, .name = "acer-ac700"}, 11106 {.id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, .name = "limit-mic-boost"}, 11107 {.id = ALC269VB_FIXUP_ASUS_ZENBOOK, .name = "asus-zenbook"}, 11108 {.id = ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, .name = "asus-zenbook-ux31a"}, 11109 {.id = ALC269VB_FIXUP_ORDISSIMO_EVE2, .name = "ordissimo"}, 11110 {.id = ALC282_FIXUP_ASUS_TX300, .name = "asus-tx300"}, 11111 {.id = ALC283_FIXUP_INT_MIC, .name = "alc283-int-mic"}, 11112 {.id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, .name = "mono-speakers"}, 11113 {.id = ALC290_FIXUP_SUBWOOFER_HSJACK, .name = "alc290-subwoofer"}, 11114 {.id = ALC269_FIXUP_THINKPAD_ACPI, .name = "thinkpad"}, 11115 {.id = ALC269_FIXUP_DMIC_THINKPAD_ACPI, .name = "dmic-thinkpad"}, 11116 {.id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, .name = "alc255-acer"}, 11117 {.id = ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc255-asus"}, 11118 {.id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc255-dell1"}, 11119 {.id = ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "alc255-dell2"}, 11120 {.id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc293-dell1"}, 11121 {.id = ALC283_FIXUP_HEADSET_MIC, .name = "alc283-headset"}, 11122 {.id = ALC255_FIXUP_MIC_MUTE_LED, .name = "alc255-dell-mute"}, 11123 {.id = ALC282_FIXUP_ASPIRE_V5_PINS, .name = "aspire-v5"}, 11124 {.id = ALC269VB_FIXUP_ASPIRE_E1_COEF, .name = "aspire-e1-coef"}, 11125 {.id = ALC280_FIXUP_HP_GPIO4, .name = "hp-gpio4"}, 11126 {.id = ALC286_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"}, 11127 {.id = ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, .name = "hp-gpio2-hotkey"}, 11128 {.id = ALC280_FIXUP_HP_DOCK_PINS, .name = "hp-dock-pins"}, 11129 {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic"}, 11130 {.id = ALC280_FIXUP_HP_9480M, .name = "hp-9480m"}, 11131 {.id = ALC288_FIXUP_DELL_HEADSET_MODE, .name = "alc288-dell-headset"}, 11132 {.id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc288-dell1"}, 11133 {.id = ALC288_FIXUP_DELL_XPS_13, .name = "alc288-dell-xps13"}, 11134 {.id = ALC292_FIXUP_DELL_E7X, .name = "dell-e7x"}, 11135 {.id = ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, .name = "alc293-dell"}, 11136 {.id = ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc298-dell1"}, 11137 {.id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, .name = "alc298-dell-aio"}, 11138 {.id = ALC275_FIXUP_DELL_XPS, .name = "alc275-dell-xps"}, 11139 {.id = ALC293_FIXUP_LENOVO_SPK_NOISE, .name = "lenovo-spk-noise"}, 11140 {.id = ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, .name = "lenovo-hotkey"}, 11141 {.id = ALC255_FIXUP_DELL_SPK_NOISE, .name = "dell-spk-noise"}, 11142 {.id = ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc225-dell1"}, 11143 {.id = ALC295_FIXUP_DISABLE_DAC3, .name = "alc295-disable-dac3"}, 11144 {.id = ALC285_FIXUP_SPEAKER2_TO_DAC1, .name = "alc285-speaker2-to-dac1"}, 11145 {.id = ALC280_FIXUP_HP_HEADSET_MIC, .name = "alc280-hp-headset"}, 11146 {.id = ALC221_FIXUP_HP_FRONT_MIC, .name = "alc221-hp-mic"}, 11147 {.id = ALC298_FIXUP_SPK_VOLUME, .name = "alc298-spk-volume"}, 11148 {.id = ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, .name = "dell-inspiron-7559"}, 11149 {.id = ALC269_FIXUP_ATIV_BOOK_8, .name = "ativ-book"}, 11150 {.id = ALC221_FIXUP_HP_MIC_NO_PRESENCE, .name = "alc221-hp-mic"}, 11151 {.id = ALC256_FIXUP_ASUS_HEADSET_MODE, .name = "alc256-asus-headset"}, 11152 {.id = ALC256_FIXUP_ASUS_MIC, .name = "alc256-asus-mic"}, 11153 {.id = ALC256_FIXUP_ASUS_AIO_GPIO2, .name = "alc256-asus-aio"}, 11154 {.id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc233-asus"}, 11155 {.id = ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, .name = "alc233-eapd"}, 11156 {.id = ALC294_FIXUP_LENOVO_MIC_LOCATION, .name = "alc294-lenovo-mic"}, 11157 {.id = ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, .name = "alc225-wyse"}, 11158 {.id = ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, .name = "alc274-dell-aio"}, 11159 {.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"}, 11160 {.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"}, 11161 {.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"}, 11162 {.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"}, 11163 {.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"}, 11164 {.id = ALC256_FIXUP_CHROME_BOOK, .name = "alc-2024y-chromebook"}, 11165 {.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"}, 11166 {.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"}, 11167 {.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"}, 11168 {.id = ALC298_FIXUP_SAMSUNG_AMP, .name = "alc298-samsung-amp"}, 11169 {.id = ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS, .name = "alc298-samsung-amp-v2-2-amps"}, 11170 {.id = ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS, .name = "alc298-samsung-amp-v2-4-amps"}, 11171 {.id = ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc256-samsung-headphone"}, 11172 {.id = ALC255_FIXUP_XIAOMI_HEADSET_MIC, .name = "alc255-xiaomi-headset"}, 11173 {.id = ALC274_FIXUP_HP_MIC, .name = "alc274-hp-mic-detect"}, 11174 {.id = ALC245_FIXUP_HP_X360_AMP, .name = "alc245-hp-x360-amp"}, 11175 {.id = ALC295_FIXUP_HP_OMEN, .name = "alc295-hp-omen"}, 11176 {.id = ALC285_FIXUP_HP_SPECTRE_X360, .name = "alc285-hp-spectre-x360"}, 11177 {.id = ALC285_FIXUP_HP_SPECTRE_X360_EB1, .name = "alc285-hp-spectre-x360-eb1"}, 11178 {.id = ALC285_FIXUP_HP_ENVY_X360, .name = "alc285-hp-envy-x360"}, 11179 {.id = ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, .name = "alc287-ideapad-bass-spk-amp"}, 11180 {.id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN, .name = "alc287-yoga9-bass-spk-pin"}, 11181 {.id = ALC623_FIXUP_LENOVO_THINKSTATION_P340, .name = "alc623-lenovo-thinkstation-p340"}, 11182 {.id = ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, .name = "alc255-acer-headphone-and-mic"}, 11183 {.id = ALC285_FIXUP_HP_GPIO_AMP_INIT, .name = "alc285-hp-amp-init"}, 11184 {.id = ALC236_FIXUP_LENOVO_INV_DMIC, .name = "alc236-fixup-lenovo-inv-mic"}, 11185 {} 11186 }; 11187 #define ALC225_STANDARD_PINS \ 11188 {0x21, 0x04211020} 11189 11190 #define ALC256_STANDARD_PINS \ 11191 {0x12, 0x90a60140}, \ 11192 {0x14, 0x90170110}, \ 11193 {0x21, 0x02211020} 11194 11195 #define ALC282_STANDARD_PINS \ 11196 {0x14, 0x90170110} 11197 11198 #define ALC290_STANDARD_PINS \ 11199 {0x12, 0x99a30130} 11200 11201 #define ALC292_STANDARD_PINS \ 11202 {0x14, 0x90170110}, \ 11203 {0x15, 0x0221401f} 11204 11205 #define ALC295_STANDARD_PINS \ 11206 {0x12, 0xb7a60130}, \ 11207 {0x14, 0x90170110}, \ 11208 {0x21, 0x04211020} 11209 11210 #define ALC298_STANDARD_PINS \ 11211 {0x12, 0x90a60130}, \ 11212 {0x21, 0x03211020} 11213 11214 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = { 11215 SND_HDA_PIN_QUIRK(0x10ec0221, 0x103c, "HP Workstation", ALC221_FIXUP_HP_HEADSET_MIC, 11216 {0x14, 0x01014020}, 11217 {0x17, 0x90170110}, 11218 {0x18, 0x02a11030}, 11219 {0x19, 0x0181303F}, 11220 {0x21, 0x0221102f}), 11221 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE, 11222 {0x12, 0x90a601c0}, 11223 {0x14, 0x90171120}, 11224 {0x21, 0x02211030}), 11225 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, 11226 {0x14, 0x90170110}, 11227 {0x1b, 0x90a70130}, 11228 {0x21, 0x03211020}), 11229 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, 11230 {0x1a, 0x90a70130}, 11231 {0x1b, 0x90170110}, 11232 {0x21, 0x03211020}), 11233 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 11234 ALC225_STANDARD_PINS, 11235 {0x12, 0xb7a60130}, 11236 {0x14, 0x901701a0}), 11237 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 11238 ALC225_STANDARD_PINS, 11239 {0x12, 0xb7a60130}, 11240 {0x14, 0x901701b0}), 11241 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 11242 ALC225_STANDARD_PINS, 11243 {0x12, 0xb7a60150}, 11244 {0x14, 0x901701a0}), 11245 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 11246 ALC225_STANDARD_PINS, 11247 {0x12, 0xb7a60150}, 11248 {0x14, 0x901701b0}), 11249 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 11250 ALC225_STANDARD_PINS, 11251 {0x12, 0xb7a60130}, 11252 {0x1b, 0x90170110}), 11253 SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 11254 {0x1b, 0x01111010}, 11255 {0x1e, 0x01451130}, 11256 {0x21, 0x02211020}), 11257 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, 11258 {0x12, 0x90a60140}, 11259 {0x14, 0x90170110}, 11260 {0x19, 0x02a11030}, 11261 {0x21, 0x02211020}), 11262 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION, 11263 {0x14, 0x90170110}, 11264 {0x19, 0x02a11030}, 11265 {0x1a, 0x02a11040}, 11266 {0x1b, 0x01014020}, 11267 {0x21, 0x0221101f}), 11268 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION, 11269 {0x14, 0x90170110}, 11270 {0x19, 0x02a11030}, 11271 {0x1a, 0x02a11040}, 11272 {0x1b, 0x01011020}, 11273 {0x21, 0x0221101f}), 11274 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION, 11275 {0x14, 0x90170110}, 11276 {0x19, 0x02a11020}, 11277 {0x1a, 0x02a11030}, 11278 {0x21, 0x0221101f}), 11279 SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC, 11280 {0x21, 0x02211010}), 11281 SND_HDA_PIN_QUIRK(0x10ec0236, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC, 11282 {0x14, 0x90170110}, 11283 {0x19, 0x02a11020}, 11284 {0x21, 0x02211030}), 11285 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, 11286 {0x14, 0x90170110}, 11287 {0x21, 0x02211020}), 11288 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11289 {0x14, 0x90170130}, 11290 {0x21, 0x02211040}), 11291 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11292 {0x12, 0x90a60140}, 11293 {0x14, 0x90170110}, 11294 {0x21, 0x02211020}), 11295 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11296 {0x12, 0x90a60160}, 11297 {0x14, 0x90170120}, 11298 {0x21, 0x02211030}), 11299 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11300 {0x14, 0x90170110}, 11301 {0x1b, 0x02011020}, 11302 {0x21, 0x0221101f}), 11303 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11304 {0x14, 0x90170110}, 11305 {0x1b, 0x01011020}, 11306 {0x21, 0x0221101f}), 11307 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11308 {0x14, 0x90170130}, 11309 {0x1b, 0x01014020}, 11310 {0x21, 0x0221103f}), 11311 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11312 {0x14, 0x90170130}, 11313 {0x1b, 0x01011020}, 11314 {0x21, 0x0221103f}), 11315 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11316 {0x14, 0x90170130}, 11317 {0x1b, 0x02011020}, 11318 {0x21, 0x0221103f}), 11319 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11320 {0x14, 0x90170150}, 11321 {0x1b, 0x02011020}, 11322 {0x21, 0x0221105f}), 11323 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11324 {0x14, 0x90170110}, 11325 {0x1b, 0x01014020}, 11326 {0x21, 0x0221101f}), 11327 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11328 {0x12, 0x90a60160}, 11329 {0x14, 0x90170120}, 11330 {0x17, 0x90170140}, 11331 {0x21, 0x0321102f}), 11332 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11333 {0x12, 0x90a60160}, 11334 {0x14, 0x90170130}, 11335 {0x21, 0x02211040}), 11336 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11337 {0x12, 0x90a60160}, 11338 {0x14, 0x90170140}, 11339 {0x21, 0x02211050}), 11340 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11341 {0x12, 0x90a60170}, 11342 {0x14, 0x90170120}, 11343 {0x21, 0x02211030}), 11344 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11345 {0x12, 0x90a60170}, 11346 {0x14, 0x90170130}, 11347 {0x21, 0x02211040}), 11348 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11349 {0x12, 0x90a60170}, 11350 {0x14, 0x90171130}, 11351 {0x21, 0x02211040}), 11352 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11353 {0x12, 0x90a60170}, 11354 {0x14, 0x90170140}, 11355 {0x21, 0x02211050}), 11356 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11357 {0x12, 0x90a60180}, 11358 {0x14, 0x90170130}, 11359 {0x21, 0x02211040}), 11360 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11361 {0x12, 0x90a60180}, 11362 {0x14, 0x90170120}, 11363 {0x21, 0x02211030}), 11364 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11365 {0x1b, 0x01011020}, 11366 {0x21, 0x02211010}), 11367 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC, 11368 {0x14, 0x90170110}, 11369 {0x1b, 0x90a70130}, 11370 {0x21, 0x04211020}), 11371 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC, 11372 {0x14, 0x90170110}, 11373 {0x1b, 0x90a70130}, 11374 {0x21, 0x03211020}), 11375 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE, 11376 {0x12, 0x90a60130}, 11377 {0x14, 0x90170110}, 11378 {0x21, 0x03211020}), 11379 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE, 11380 {0x12, 0x90a60130}, 11381 {0x14, 0x90170110}, 11382 {0x21, 0x04211020}), 11383 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE, 11384 {0x1a, 0x90a70130}, 11385 {0x1b, 0x90170110}, 11386 {0x21, 0x03211020}), 11387 SND_HDA_PIN_QUIRK(0x10ec0256, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC, 11388 {0x14, 0x90170110}, 11389 {0x19, 0x02a11020}, 11390 {0x21, 0x0221101f}), 11391 SND_HDA_PIN_QUIRK(0x10ec0274, 0x103c, "HP", ALC274_FIXUP_HP_HEADSET_MIC, 11392 {0x17, 0x90170110}, 11393 {0x19, 0x03a11030}, 11394 {0x21, 0x03211020}), 11395 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4, 11396 {0x12, 0x90a60130}, 11397 {0x14, 0x90170110}, 11398 {0x15, 0x0421101f}, 11399 {0x1a, 0x04a11020}), 11400 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED, 11401 {0x12, 0x90a60140}, 11402 {0x14, 0x90170110}, 11403 {0x15, 0x0421101f}, 11404 {0x18, 0x02811030}, 11405 {0x1a, 0x04a1103f}, 11406 {0x1b, 0x02011020}), 11407 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1, 11408 ALC282_STANDARD_PINS, 11409 {0x12, 0x99a30130}, 11410 {0x19, 0x03a11020}, 11411 {0x21, 0x0321101f}), 11412 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 11413 ALC282_STANDARD_PINS, 11414 {0x12, 0x99a30130}, 11415 {0x19, 0x03a11020}, 11416 {0x21, 0x03211040}), 11417 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 11418 ALC282_STANDARD_PINS, 11419 {0x12, 0x99a30130}, 11420 {0x19, 0x03a11030}, 11421 {0x21, 0x03211020}), 11422 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 11423 ALC282_STANDARD_PINS, 11424 {0x12, 0x99a30130}, 11425 {0x19, 0x04a11020}, 11426 {0x21, 0x0421101f}), 11427 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED, 11428 ALC282_STANDARD_PINS, 11429 {0x12, 0x90a60140}, 11430 {0x19, 0x04a11030}, 11431 {0x21, 0x04211020}), 11432 SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT, 11433 ALC282_STANDARD_PINS, 11434 {0x12, 0x90a609c0}, 11435 {0x18, 0x03a11830}, 11436 {0x19, 0x04a19831}, 11437 {0x1a, 0x0481303f}, 11438 {0x1b, 0x04211020}, 11439 {0x21, 0x0321101f}), 11440 SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT, 11441 ALC282_STANDARD_PINS, 11442 {0x12, 0x90a60940}, 11443 {0x18, 0x03a11830}, 11444 {0x19, 0x04a19831}, 11445 {0x1a, 0x0481303f}, 11446 {0x1b, 0x04211020}, 11447 {0x21, 0x0321101f}), 11448 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 11449 ALC282_STANDARD_PINS, 11450 {0x12, 0x90a60130}, 11451 {0x21, 0x0321101f}), 11452 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 11453 {0x12, 0x90a60160}, 11454 {0x14, 0x90170120}, 11455 {0x21, 0x02211030}), 11456 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 11457 ALC282_STANDARD_PINS, 11458 {0x12, 0x90a60130}, 11459 {0x19, 0x03a11020}, 11460 {0x21, 0x0321101f}), 11461 SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE, 11462 {0x12, 0x90a60130}, 11463 {0x14, 0x90170110}, 11464 {0x19, 0x04a11040}, 11465 {0x21, 0x04211020}), 11466 SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE, 11467 {0x14, 0x90170110}, 11468 {0x19, 0x04a11040}, 11469 {0x1d, 0x40600001}, 11470 {0x21, 0x04211020}), 11471 SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK, 11472 {0x14, 0x90170110}, 11473 {0x19, 0x04a11040}, 11474 {0x21, 0x04211020}), 11475 SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_HEADSET_JACK, 11476 {0x14, 0x90170110}, 11477 {0x17, 0x90170111}, 11478 {0x19, 0x03a11030}, 11479 {0x21, 0x03211020}), 11480 SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK, 11481 {0x17, 0x90170110}, 11482 {0x19, 0x03a11030}, 11483 {0x21, 0x03211020}), 11484 SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK, 11485 {0x17, 0x90170110}, /* 0x231f with RTK I2S AMP */ 11486 {0x19, 0x04a11040}, 11487 {0x21, 0x04211020}), 11488 SND_HDA_PIN_QUIRK(0x10ec0286, 0x1025, "Acer", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE, 11489 {0x12, 0x90a60130}, 11490 {0x17, 0x90170110}, 11491 {0x21, 0x02211020}), 11492 SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, 11493 {0x12, 0x90a60120}, 11494 {0x14, 0x90170110}, 11495 {0x21, 0x0321101f}), 11496 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 11497 ALC290_STANDARD_PINS, 11498 {0x15, 0x04211040}, 11499 {0x18, 0x90170112}, 11500 {0x1a, 0x04a11020}), 11501 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 11502 ALC290_STANDARD_PINS, 11503 {0x15, 0x04211040}, 11504 {0x18, 0x90170110}, 11505 {0x1a, 0x04a11020}), 11506 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 11507 ALC290_STANDARD_PINS, 11508 {0x15, 0x0421101f}, 11509 {0x1a, 0x04a11020}), 11510 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 11511 ALC290_STANDARD_PINS, 11512 {0x15, 0x04211020}, 11513 {0x1a, 0x04a11040}), 11514 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 11515 ALC290_STANDARD_PINS, 11516 {0x14, 0x90170110}, 11517 {0x15, 0x04211020}, 11518 {0x1a, 0x04a11040}), 11519 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 11520 ALC290_STANDARD_PINS, 11521 {0x14, 0x90170110}, 11522 {0x15, 0x04211020}, 11523 {0x1a, 0x04a11020}), 11524 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 11525 ALC290_STANDARD_PINS, 11526 {0x14, 0x90170110}, 11527 {0x15, 0x0421101f}, 11528 {0x1a, 0x04a11020}), 11529 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, 11530 ALC292_STANDARD_PINS, 11531 {0x12, 0x90a60140}, 11532 {0x16, 0x01014020}, 11533 {0x19, 0x01a19030}), 11534 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, 11535 ALC292_STANDARD_PINS, 11536 {0x12, 0x90a60140}, 11537 {0x16, 0x01014020}, 11538 {0x18, 0x02a19031}, 11539 {0x19, 0x01a1903e}), 11540 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, 11541 ALC292_STANDARD_PINS, 11542 {0x12, 0x90a60140}), 11543 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, 11544 ALC292_STANDARD_PINS, 11545 {0x13, 0x90a60140}, 11546 {0x16, 0x21014020}, 11547 {0x19, 0x21a19030}), 11548 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, 11549 ALC292_STANDARD_PINS, 11550 {0x13, 0x90a60140}), 11551 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_HPE, 11552 {0x17, 0x90170110}, 11553 {0x21, 0x04211020}), 11554 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC, 11555 {0x14, 0x90170110}, 11556 {0x1b, 0x90a70130}, 11557 {0x21, 0x04211020}), 11558 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK, 11559 {0x12, 0x90a60130}, 11560 {0x17, 0x90170110}, 11561 {0x21, 0x03211020}), 11562 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK, 11563 {0x12, 0x90a60130}, 11564 {0x17, 0x90170110}, 11565 {0x21, 0x04211020}), 11566 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK, 11567 {0x12, 0x90a60130}, 11568 {0x17, 0x90170110}, 11569 {0x21, 0x03211020}), 11570 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, 11571 {0x12, 0x90a60120}, 11572 {0x17, 0x90170110}, 11573 {0x21, 0x04211030}), 11574 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, 11575 {0x12, 0x90a60130}, 11576 {0x17, 0x90170110}, 11577 {0x21, 0x03211020}), 11578 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, 11579 {0x12, 0x90a60130}, 11580 {0x17, 0x90170110}, 11581 {0x21, 0x03211020}), 11582 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 11583 ALC298_STANDARD_PINS, 11584 {0x17, 0x90170110}), 11585 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 11586 ALC298_STANDARD_PINS, 11587 {0x17, 0x90170140}), 11588 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 11589 ALC298_STANDARD_PINS, 11590 {0x17, 0x90170150}), 11591 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME, 11592 {0x12, 0xb7a60140}, 11593 {0x13, 0xb7a60150}, 11594 {0x17, 0x90170110}, 11595 {0x1a, 0x03011020}, 11596 {0x21, 0x03211030}), 11597 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE, 11598 {0x12, 0xb7a60140}, 11599 {0x17, 0x90170110}, 11600 {0x1a, 0x03a11030}, 11601 {0x21, 0x03211020}), 11602 SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 11603 ALC225_STANDARD_PINS, 11604 {0x12, 0xb7a60130}, 11605 {0x17, 0x90170110}), 11606 SND_HDA_PIN_QUIRK(0x10ec0623, 0x17aa, "Lenovo", ALC283_FIXUP_HEADSET_MIC, 11607 {0x14, 0x01014010}, 11608 {0x17, 0x90170120}, 11609 {0x18, 0x02a11030}, 11610 {0x19, 0x02a1103f}, 11611 {0x21, 0x0221101f}), 11612 {} 11613 }; 11614 11615 /* This is the fallback pin_fixup_tbl for alc269 family, to make the tbl match 11616 * more machines, don't need to match all valid pins, just need to match 11617 * all the pins defined in the tbl. Just because of this reason, it is possible 11618 * that a single machine matches multiple tbls, so there is one limitation: 11619 * at most one tbl is allowed to define for the same vendor and same codec 11620 */ 11621 static const struct snd_hda_pin_quirk alc269_fallback_pin_fixup_tbl[] = { 11622 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1025, "Acer", ALC2XX_FIXUP_HEADSET_MIC, 11623 {0x19, 0x40000000}), 11624 SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 11625 {0x19, 0x40000000}, 11626 {0x1b, 0x40000000}), 11627 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 11628 {0x19, 0x40000000}, 11629 {0x1b, 0x40000000}), 11630 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11631 {0x19, 0x40000000}, 11632 {0x1a, 0x40000000}), 11633 SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11634 {0x19, 0x40000000}, 11635 {0x1a, 0x40000000}), 11636 SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, 11637 {0x19, 0x40000000}, 11638 {0x1a, 0x40000000}), 11639 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC2XX_FIXUP_HEADSET_MIC, 11640 {0x19, 0x40000000}), 11641 {} 11642 }; 11643 11644 static void alc269_fill_coef(struct hda_codec *codec) 11645 { 11646 struct alc_spec *spec = codec->spec; 11647 int val; 11648 11649 if (spec->codec_variant != ALC269_TYPE_ALC269VB) 11650 return; 11651 11652 if ((alc_get_coef0(codec) & 0x00ff) < 0x015) { 11653 alc_write_coef_idx(codec, 0xf, 0x960b); 11654 alc_write_coef_idx(codec, 0xe, 0x8817); 11655 } 11656 11657 if ((alc_get_coef0(codec) & 0x00ff) == 0x016) { 11658 alc_write_coef_idx(codec, 0xf, 0x960b); 11659 alc_write_coef_idx(codec, 0xe, 0x8814); 11660 } 11661 11662 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) { 11663 /* Power up output pin */ 11664 alc_update_coef_idx(codec, 0x04, 0, 1<<11); 11665 } 11666 11667 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) { 11668 val = alc_read_coef_idx(codec, 0xd); 11669 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) { 11670 /* Capless ramp up clock control */ 11671 alc_write_coef_idx(codec, 0xd, val | (1<<10)); 11672 } 11673 val = alc_read_coef_idx(codec, 0x17); 11674 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) { 11675 /* Class D power on reset */ 11676 alc_write_coef_idx(codec, 0x17, val | (1<<7)); 11677 } 11678 } 11679 11680 /* HP */ 11681 alc_update_coef_idx(codec, 0x4, 0, 1<<11); 11682 } 11683 11684 /* 11685 */ 11686 static int patch_alc269(struct hda_codec *codec) 11687 { 11688 struct alc_spec *spec; 11689 int err; 11690 11691 err = alc_alloc_spec(codec, 0x0b); 11692 if (err < 0) 11693 return err; 11694 11695 spec = codec->spec; 11696 spec->gen.shared_mic_vref_pin = 0x18; 11697 codec->power_save_node = 0; 11698 spec->en_3kpull_low = true; 11699 11700 codec->patch_ops.suspend = alc269_suspend; 11701 codec->patch_ops.resume = alc269_resume; 11702 spec->shutup = alc_default_shutup; 11703 spec->init_hook = alc_default_init; 11704 11705 switch (codec->core.vendor_id) { 11706 case 0x10ec0269: 11707 spec->codec_variant = ALC269_TYPE_ALC269VA; 11708 switch (alc_get_coef0(codec) & 0x00f0) { 11709 case 0x0010: 11710 if (codec->bus->pci && 11711 codec->bus->pci->subsystem_vendor == 0x1025 && 11712 spec->cdefine.platform_type == 1) 11713 err = alc_codec_rename(codec, "ALC271X"); 11714 spec->codec_variant = ALC269_TYPE_ALC269VB; 11715 break; 11716 case 0x0020: 11717 if (codec->bus->pci && 11718 codec->bus->pci->subsystem_vendor == 0x17aa && 11719 codec->bus->pci->subsystem_device == 0x21f3) 11720 err = alc_codec_rename(codec, "ALC3202"); 11721 spec->codec_variant = ALC269_TYPE_ALC269VC; 11722 break; 11723 case 0x0030: 11724 spec->codec_variant = ALC269_TYPE_ALC269VD; 11725 break; 11726 default: 11727 alc_fix_pll_init(codec, 0x20, 0x04, 15); 11728 } 11729 if (err < 0) 11730 goto error; 11731 spec->shutup = alc269_shutup; 11732 spec->init_hook = alc269_fill_coef; 11733 alc269_fill_coef(codec); 11734 break; 11735 11736 case 0x10ec0280: 11737 case 0x10ec0290: 11738 spec->codec_variant = ALC269_TYPE_ALC280; 11739 break; 11740 case 0x10ec0282: 11741 spec->codec_variant = ALC269_TYPE_ALC282; 11742 spec->shutup = alc282_shutup; 11743 spec->init_hook = alc282_init; 11744 break; 11745 case 0x10ec0233: 11746 case 0x10ec0283: 11747 spec->codec_variant = ALC269_TYPE_ALC283; 11748 spec->shutup = alc283_shutup; 11749 spec->init_hook = alc283_init; 11750 break; 11751 case 0x10ec0284: 11752 case 0x10ec0292: 11753 spec->codec_variant = ALC269_TYPE_ALC284; 11754 break; 11755 case 0x10ec0293: 11756 spec->codec_variant = ALC269_TYPE_ALC293; 11757 break; 11758 case 0x10ec0286: 11759 case 0x10ec0288: 11760 spec->codec_variant = ALC269_TYPE_ALC286; 11761 break; 11762 case 0x10ec0298: 11763 spec->codec_variant = ALC269_TYPE_ALC298; 11764 break; 11765 case 0x10ec0235: 11766 case 0x10ec0255: 11767 spec->codec_variant = ALC269_TYPE_ALC255; 11768 spec->shutup = alc256_shutup; 11769 spec->init_hook = alc256_init; 11770 break; 11771 case 0x10ec0230: 11772 case 0x10ec0236: 11773 case 0x10ec0256: 11774 case 0x19e58326: 11775 spec->codec_variant = ALC269_TYPE_ALC256; 11776 spec->shutup = alc256_shutup; 11777 spec->init_hook = alc256_init; 11778 spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */ 11779 if (codec->core.vendor_id == 0x10ec0236 && 11780 codec->bus->pci->vendor != PCI_VENDOR_ID_AMD) 11781 spec->en_3kpull_low = false; 11782 break; 11783 case 0x10ec0257: 11784 spec->codec_variant = ALC269_TYPE_ALC257; 11785 spec->shutup = alc256_shutup; 11786 spec->init_hook = alc256_init; 11787 spec->gen.mixer_nid = 0; 11788 spec->en_3kpull_low = false; 11789 break; 11790 case 0x10ec0215: 11791 case 0x10ec0245: 11792 case 0x10ec0285: 11793 case 0x10ec0289: 11794 if (alc_get_coef0(codec) & 0x0010) 11795 spec->codec_variant = ALC269_TYPE_ALC245; 11796 else 11797 spec->codec_variant = ALC269_TYPE_ALC215; 11798 spec->shutup = alc225_shutup; 11799 spec->init_hook = alc225_init; 11800 spec->gen.mixer_nid = 0; 11801 break; 11802 case 0x10ec0225: 11803 case 0x10ec0295: 11804 case 0x10ec0299: 11805 spec->codec_variant = ALC269_TYPE_ALC225; 11806 spec->shutup = alc225_shutup; 11807 spec->init_hook = alc225_init; 11808 spec->gen.mixer_nid = 0; /* no loopback on ALC225, ALC295 and ALC299 */ 11809 break; 11810 case 0x10ec0287: 11811 spec->codec_variant = ALC269_TYPE_ALC287; 11812 spec->shutup = alc225_shutup; 11813 spec->init_hook = alc225_init; 11814 spec->gen.mixer_nid = 0; /* no loopback on ALC287 */ 11815 break; 11816 case 0x10ec0234: 11817 case 0x10ec0274: 11818 case 0x10ec0294: 11819 spec->codec_variant = ALC269_TYPE_ALC294; 11820 spec->gen.mixer_nid = 0; /* ALC2x4 does not have any loopback mixer path */ 11821 alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3)); /* UAJ MIC Vref control by verb */ 11822 spec->init_hook = alc294_init; 11823 break; 11824 case 0x10ec0300: 11825 spec->codec_variant = ALC269_TYPE_ALC300; 11826 spec->gen.mixer_nid = 0; /* no loopback on ALC300 */ 11827 break; 11828 case 0x10ec0623: 11829 spec->codec_variant = ALC269_TYPE_ALC623; 11830 break; 11831 case 0x10ec0700: 11832 case 0x10ec0701: 11833 case 0x10ec0703: 11834 case 0x10ec0711: 11835 spec->codec_variant = ALC269_TYPE_ALC700; 11836 spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */ 11837 alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */ 11838 spec->init_hook = alc294_init; 11839 break; 11840 11841 } 11842 11843 if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) { 11844 spec->has_alc5505_dsp = 1; 11845 spec->init_hook = alc5505_dsp_init; 11846 } 11847 11848 alc_pre_init(codec); 11849 11850 snd_hda_pick_fixup(codec, alc269_fixup_models, 11851 alc269_fixup_tbl, alc269_fixups); 11852 /* FIXME: both TX300 and ROG Strix G17 have the same SSID, and 11853 * the quirk breaks the latter (bko#214101). 11854 * Clear the wrong entry. 11855 */ 11856 if (codec->fixup_id == ALC282_FIXUP_ASUS_TX300 && 11857 codec->core.vendor_id == 0x10ec0294) { 11858 codec_dbg(codec, "Clear wrong fixup for ASUS ROG Strix G17\n"); 11859 codec->fixup_id = HDA_FIXUP_ID_NOT_SET; 11860 } 11861 11862 snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups, true); 11863 snd_hda_pick_pin_fixup(codec, alc269_fallback_pin_fixup_tbl, alc269_fixups, false); 11864 snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl, 11865 alc269_fixups); 11866 11867 /* 11868 * Check whether ACPI describes companion amplifiers that require 11869 * component binding 11870 */ 11871 find_cirrus_companion_amps(codec); 11872 11873 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 11874 11875 alc_auto_parse_customize_define(codec); 11876 11877 if (has_cdefine_beep(codec)) 11878 spec->gen.beep_nid = 0x01; 11879 11880 /* automatic parse from the BIOS config */ 11881 err = alc269_parse_auto_config(codec); 11882 if (err < 0) 11883 goto error; 11884 11885 if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) { 11886 err = set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT); 11887 if (err < 0) 11888 goto error; 11889 } 11890 11891 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 11892 11893 return 0; 11894 11895 error: 11896 alc_free(codec); 11897 return err; 11898 } 11899 11900 /* 11901 * ALC861 11902 */ 11903 11904 static int alc861_parse_auto_config(struct hda_codec *codec) 11905 { 11906 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 }; 11907 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 }; 11908 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids); 11909 } 11910 11911 /* Pin config fixes */ 11912 enum { 11913 ALC861_FIXUP_FSC_AMILO_PI1505, 11914 ALC861_FIXUP_AMP_VREF_0F, 11915 ALC861_FIXUP_NO_JACK_DETECT, 11916 ALC861_FIXUP_ASUS_A6RP, 11917 ALC660_FIXUP_ASUS_W7J, 11918 }; 11919 11920 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */ 11921 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec, 11922 const struct hda_fixup *fix, int action) 11923 { 11924 struct alc_spec *spec = codec->spec; 11925 unsigned int val; 11926 11927 if (action != HDA_FIXUP_ACT_INIT) 11928 return; 11929 val = snd_hda_codec_get_pin_target(codec, 0x0f); 11930 if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))) 11931 val |= AC_PINCTL_IN_EN; 11932 val |= AC_PINCTL_VREF_50; 11933 snd_hda_set_pin_ctl(codec, 0x0f, val); 11934 spec->gen.keep_vref_in_automute = 1; 11935 } 11936 11937 /* suppress the jack-detection */ 11938 static void alc_fixup_no_jack_detect(struct hda_codec *codec, 11939 const struct hda_fixup *fix, int action) 11940 { 11941 if (action == HDA_FIXUP_ACT_PRE_PROBE) 11942 codec->no_jack_detect = 1; 11943 } 11944 11945 static const struct hda_fixup alc861_fixups[] = { 11946 [ALC861_FIXUP_FSC_AMILO_PI1505] = { 11947 .type = HDA_FIXUP_PINS, 11948 .v.pins = (const struct hda_pintbl[]) { 11949 { 0x0b, 0x0221101f }, /* HP */ 11950 { 0x0f, 0x90170310 }, /* speaker */ 11951 { } 11952 } 11953 }, 11954 [ALC861_FIXUP_AMP_VREF_0F] = { 11955 .type = HDA_FIXUP_FUNC, 11956 .v.func = alc861_fixup_asus_amp_vref_0f, 11957 }, 11958 [ALC861_FIXUP_NO_JACK_DETECT] = { 11959 .type = HDA_FIXUP_FUNC, 11960 .v.func = alc_fixup_no_jack_detect, 11961 }, 11962 [ALC861_FIXUP_ASUS_A6RP] = { 11963 .type = HDA_FIXUP_FUNC, 11964 .v.func = alc861_fixup_asus_amp_vref_0f, 11965 .chained = true, 11966 .chain_id = ALC861_FIXUP_NO_JACK_DETECT, 11967 }, 11968 [ALC660_FIXUP_ASUS_W7J] = { 11969 .type = HDA_FIXUP_VERBS, 11970 .v.verbs = (const struct hda_verb[]) { 11971 /* ASUS W7J needs a magic pin setup on unused NID 0x10 11972 * for enabling outputs 11973 */ 11974 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 11975 { } 11976 }, 11977 } 11978 }; 11979 11980 static const struct snd_pci_quirk alc861_fixup_tbl[] = { 11981 SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J), 11982 SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J), 11983 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP), 11984 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F), 11985 SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT), 11986 SND_PCI_QUIRK_VENDOR(0x1584, "Haier/Uniwill", ALC861_FIXUP_AMP_VREF_0F), 11987 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505), 11988 {} 11989 }; 11990 11991 /* 11992 */ 11993 static int patch_alc861(struct hda_codec *codec) 11994 { 11995 struct alc_spec *spec; 11996 int err; 11997 11998 err = alc_alloc_spec(codec, 0x15); 11999 if (err < 0) 12000 return err; 12001 12002 spec = codec->spec; 12003 if (has_cdefine_beep(codec)) 12004 spec->gen.beep_nid = 0x23; 12005 12006 spec->power_hook = alc_power_eapd; 12007 12008 alc_pre_init(codec); 12009 12010 snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups); 12011 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 12012 12013 /* automatic parse from the BIOS config */ 12014 err = alc861_parse_auto_config(codec); 12015 if (err < 0) 12016 goto error; 12017 12018 if (!spec->gen.no_analog) { 12019 err = set_beep_amp(spec, 0x23, 0, HDA_OUTPUT); 12020 if (err < 0) 12021 goto error; 12022 } 12023 12024 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 12025 12026 return 0; 12027 12028 error: 12029 alc_free(codec); 12030 return err; 12031 } 12032 12033 /* 12034 * ALC861-VD support 12035 * 12036 * Based on ALC882 12037 * 12038 * In addition, an independent DAC 12039 */ 12040 static int alc861vd_parse_auto_config(struct hda_codec *codec) 12041 { 12042 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 }; 12043 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 12044 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids); 12045 } 12046 12047 enum { 12048 ALC660VD_FIX_ASUS_GPIO1, 12049 ALC861VD_FIX_DALLAS, 12050 }; 12051 12052 /* exclude VREF80 */ 12053 static void alc861vd_fixup_dallas(struct hda_codec *codec, 12054 const struct hda_fixup *fix, int action) 12055 { 12056 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 12057 snd_hda_override_pin_caps(codec, 0x18, 0x00000734); 12058 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c); 12059 } 12060 } 12061 12062 /* reset GPIO1 */ 12063 static void alc660vd_fixup_asus_gpio1(struct hda_codec *codec, 12064 const struct hda_fixup *fix, int action) 12065 { 12066 struct alc_spec *spec = codec->spec; 12067 12068 if (action == HDA_FIXUP_ACT_PRE_PROBE) 12069 spec->gpio_mask |= 0x02; 12070 alc_fixup_gpio(codec, action, 0x01); 12071 } 12072 12073 static const struct hda_fixup alc861vd_fixups[] = { 12074 [ALC660VD_FIX_ASUS_GPIO1] = { 12075 .type = HDA_FIXUP_FUNC, 12076 .v.func = alc660vd_fixup_asus_gpio1, 12077 }, 12078 [ALC861VD_FIX_DALLAS] = { 12079 .type = HDA_FIXUP_FUNC, 12080 .v.func = alc861vd_fixup_dallas, 12081 }, 12082 }; 12083 12084 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = { 12085 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS), 12086 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1), 12087 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS), 12088 {} 12089 }; 12090 12091 /* 12092 */ 12093 static int patch_alc861vd(struct hda_codec *codec) 12094 { 12095 struct alc_spec *spec; 12096 int err; 12097 12098 err = alc_alloc_spec(codec, 0x0b); 12099 if (err < 0) 12100 return err; 12101 12102 spec = codec->spec; 12103 if (has_cdefine_beep(codec)) 12104 spec->gen.beep_nid = 0x23; 12105 12106 spec->shutup = alc_eapd_shutup; 12107 12108 alc_pre_init(codec); 12109 12110 snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups); 12111 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 12112 12113 /* automatic parse from the BIOS config */ 12114 err = alc861vd_parse_auto_config(codec); 12115 if (err < 0) 12116 goto error; 12117 12118 if (!spec->gen.no_analog) { 12119 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 12120 if (err < 0) 12121 goto error; 12122 } 12123 12124 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 12125 12126 return 0; 12127 12128 error: 12129 alc_free(codec); 12130 return err; 12131 } 12132 12133 /* 12134 * ALC662 support 12135 * 12136 * ALC662 is almost identical with ALC880 but has cleaner and more flexible 12137 * configuration. Each pin widget can choose any input DACs and a mixer. 12138 * Each ADC is connected from a mixer of all inputs. This makes possible 12139 * 6-channel independent captures. 12140 * 12141 * In addition, an independent DAC for the multi-playback (not used in this 12142 * driver yet). 12143 */ 12144 12145 /* 12146 * BIOS auto configuration 12147 */ 12148 12149 static int alc662_parse_auto_config(struct hda_codec *codec) 12150 { 12151 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 }; 12152 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 }; 12153 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 12154 const hda_nid_t *ssids; 12155 12156 if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 || 12157 codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 || 12158 codec->core.vendor_id == 0x10ec0671) 12159 ssids = alc663_ssids; 12160 else 12161 ssids = alc662_ssids; 12162 return alc_parse_auto_config(codec, alc662_ignore, ssids); 12163 } 12164 12165 static void alc272_fixup_mario(struct hda_codec *codec, 12166 const struct hda_fixup *fix, int action) 12167 { 12168 if (action != HDA_FIXUP_ACT_PRE_PROBE) 12169 return; 12170 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT, 12171 (0x3b << AC_AMPCAP_OFFSET_SHIFT) | 12172 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) | 12173 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) | 12174 (0 << AC_AMPCAP_MUTE_SHIFT))) 12175 codec_warn(codec, "failed to override amp caps for NID 0x2\n"); 12176 } 12177 12178 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = { 12179 { .channels = 2, 12180 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } }, 12181 { .channels = 4, 12182 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, 12183 SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */ 12184 { } 12185 }; 12186 12187 /* override the 2.1 chmap */ 12188 static void alc_fixup_bass_chmap(struct hda_codec *codec, 12189 const struct hda_fixup *fix, int action) 12190 { 12191 if (action == HDA_FIXUP_ACT_BUILD) { 12192 struct alc_spec *spec = codec->spec; 12193 spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps; 12194 } 12195 } 12196 12197 /* avoid D3 for keeping GPIO up */ 12198 static unsigned int gpio_led_power_filter(struct hda_codec *codec, 12199 hda_nid_t nid, 12200 unsigned int power_state) 12201 { 12202 struct alc_spec *spec = codec->spec; 12203 if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_data) 12204 return AC_PWRST_D0; 12205 return power_state; 12206 } 12207 12208 static void alc662_fixup_led_gpio1(struct hda_codec *codec, 12209 const struct hda_fixup *fix, int action) 12210 { 12211 struct alc_spec *spec = codec->spec; 12212 12213 alc_fixup_hp_gpio_led(codec, action, 0x01, 0); 12214 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 12215 spec->mute_led_polarity = 1; 12216 codec->power_filter = gpio_led_power_filter; 12217 } 12218 } 12219 12220 static void alc662_usi_automute_hook(struct hda_codec *codec, 12221 struct hda_jack_callback *jack) 12222 { 12223 struct alc_spec *spec = codec->spec; 12224 int vref; 12225 msleep(200); 12226 snd_hda_gen_hp_automute(codec, jack); 12227 12228 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0; 12229 msleep(100); 12230 snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 12231 vref); 12232 } 12233 12234 static void alc662_fixup_usi_headset_mic(struct hda_codec *codec, 12235 const struct hda_fixup *fix, int action) 12236 { 12237 struct alc_spec *spec = codec->spec; 12238 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 12239 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 12240 spec->gen.hp_automute_hook = alc662_usi_automute_hook; 12241 } 12242 } 12243 12244 static void alc662_aspire_ethos_mute_speakers(struct hda_codec *codec, 12245 struct hda_jack_callback *cb) 12246 { 12247 /* surround speakers at 0x1b already get muted automatically when 12248 * headphones are plugged in, but we have to mute/unmute the remaining 12249 * channels manually: 12250 * 0x15 - front left/front right 12251 * 0x18 - front center/ LFE 12252 */ 12253 if (snd_hda_jack_detect_state(codec, 0x1b) == HDA_JACK_PRESENT) { 12254 snd_hda_set_pin_ctl_cache(codec, 0x15, 0); 12255 snd_hda_set_pin_ctl_cache(codec, 0x18, 0); 12256 } else { 12257 snd_hda_set_pin_ctl_cache(codec, 0x15, PIN_OUT); 12258 snd_hda_set_pin_ctl_cache(codec, 0x18, PIN_OUT); 12259 } 12260 } 12261 12262 static void alc662_fixup_aspire_ethos_hp(struct hda_codec *codec, 12263 const struct hda_fixup *fix, int action) 12264 { 12265 /* Pin 0x1b: shared headphones jack and surround speakers */ 12266 if (!is_jack_detectable(codec, 0x1b)) 12267 return; 12268 12269 switch (action) { 12270 case HDA_FIXUP_ACT_PRE_PROBE: 12271 snd_hda_jack_detect_enable_callback(codec, 0x1b, 12272 alc662_aspire_ethos_mute_speakers); 12273 /* subwoofer needs an extra GPIO setting to become audible */ 12274 alc_setup_gpio(codec, 0x02); 12275 break; 12276 case HDA_FIXUP_ACT_INIT: 12277 /* Make sure to start in a correct state, i.e. if 12278 * headphones have been plugged in before powering up the system 12279 */ 12280 alc662_aspire_ethos_mute_speakers(codec, NULL); 12281 break; 12282 } 12283 } 12284 12285 static void alc671_fixup_hp_headset_mic2(struct hda_codec *codec, 12286 const struct hda_fixup *fix, int action) 12287 { 12288 struct alc_spec *spec = codec->spec; 12289 12290 static const struct hda_pintbl pincfgs[] = { 12291 { 0x19, 0x02a11040 }, /* use as headset mic, with its own jack detect */ 12292 { 0x1b, 0x0181304f }, 12293 { } 12294 }; 12295 12296 switch (action) { 12297 case HDA_FIXUP_ACT_PRE_PROBE: 12298 spec->gen.mixer_nid = 0; 12299 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 12300 snd_hda_apply_pincfgs(codec, pincfgs); 12301 break; 12302 case HDA_FIXUP_ACT_INIT: 12303 alc_write_coef_idx(codec, 0x19, 0xa054); 12304 break; 12305 } 12306 } 12307 12308 static void alc897_hp_automute_hook(struct hda_codec *codec, 12309 struct hda_jack_callback *jack) 12310 { 12311 struct alc_spec *spec = codec->spec; 12312 int vref; 12313 12314 snd_hda_gen_hp_automute(codec, jack); 12315 vref = spec->gen.hp_jack_present ? (PIN_HP | AC_PINCTL_VREF_100) : PIN_HP; 12316 snd_hda_set_pin_ctl(codec, 0x1b, vref); 12317 } 12318 12319 static void alc897_fixup_lenovo_headset_mic(struct hda_codec *codec, 12320 const struct hda_fixup *fix, int action) 12321 { 12322 struct alc_spec *spec = codec->spec; 12323 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 12324 spec->gen.hp_automute_hook = alc897_hp_automute_hook; 12325 spec->no_shutup_pins = 1; 12326 } 12327 if (action == HDA_FIXUP_ACT_PROBE) { 12328 snd_hda_set_pin_ctl_cache(codec, 0x1a, PIN_IN | AC_PINCTL_VREF_100); 12329 } 12330 } 12331 12332 static void alc897_fixup_lenovo_headset_mode(struct hda_codec *codec, 12333 const struct hda_fixup *fix, int action) 12334 { 12335 struct alc_spec *spec = codec->spec; 12336 12337 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 12338 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 12339 spec->gen.hp_automute_hook = alc897_hp_automute_hook; 12340 } 12341 } 12342 12343 static const struct coef_fw alc668_coefs[] = { 12344 WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03, 0x0), 12345 WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06, 0x0), WRITE_COEF(0x07, 0x0f80), 12346 WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b, 0x0), 12347 WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f), 12348 WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001), 12349 WRITE_COEF(0x13, 0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940), 12350 WRITE_COEF(0x19, 0x0), WRITE_COEF(0x1a, 0x0), WRITE_COEF(0x1b, 0x0), 12351 WRITE_COEF(0x1c, 0x0), WRITE_COEF(0x1d, 0x0), WRITE_COEF(0x1e, 0x7418), 12352 WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468), 12353 WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418), 12354 WRITE_COEF(0x27, 0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00), 12355 WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000), 12356 WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac, 0x0), 12357 WRITE_COEF(0xad, 0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480), 12358 WRITE_COEF(0xb0, 0x0), WRITE_COEF(0xb1, 0x0), WRITE_COEF(0xb2, 0x0), 12359 WRITE_COEF(0xb3, 0x0), WRITE_COEF(0xb4, 0x0), WRITE_COEF(0xb5, 0x1040), 12360 WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697), 12361 WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab), 12362 WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02), 12363 WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6), 12364 {} 12365 }; 12366 12367 static void alc668_restore_default_value(struct hda_codec *codec) 12368 { 12369 alc_process_coef_fw(codec, alc668_coefs); 12370 } 12371 12372 enum { 12373 ALC662_FIXUP_ASPIRE, 12374 ALC662_FIXUP_LED_GPIO1, 12375 ALC662_FIXUP_IDEAPAD, 12376 ALC272_FIXUP_MARIO, 12377 ALC662_FIXUP_CZC_ET26, 12378 ALC662_FIXUP_CZC_P10T, 12379 ALC662_FIXUP_SKU_IGNORE, 12380 ALC662_FIXUP_HP_RP5800, 12381 ALC662_FIXUP_ASUS_MODE1, 12382 ALC662_FIXUP_ASUS_MODE2, 12383 ALC662_FIXUP_ASUS_MODE3, 12384 ALC662_FIXUP_ASUS_MODE4, 12385 ALC662_FIXUP_ASUS_MODE5, 12386 ALC662_FIXUP_ASUS_MODE6, 12387 ALC662_FIXUP_ASUS_MODE7, 12388 ALC662_FIXUP_ASUS_MODE8, 12389 ALC662_FIXUP_NO_JACK_DETECT, 12390 ALC662_FIXUP_ZOTAC_Z68, 12391 ALC662_FIXUP_INV_DMIC, 12392 ALC662_FIXUP_DELL_MIC_NO_PRESENCE, 12393 ALC668_FIXUP_DELL_MIC_NO_PRESENCE, 12394 ALC662_FIXUP_HEADSET_MODE, 12395 ALC668_FIXUP_HEADSET_MODE, 12396 ALC662_FIXUP_BASS_MODE4_CHMAP, 12397 ALC662_FIXUP_BASS_16, 12398 ALC662_FIXUP_BASS_1A, 12399 ALC662_FIXUP_BASS_CHMAP, 12400 ALC668_FIXUP_AUTO_MUTE, 12401 ALC668_FIXUP_DELL_DISABLE_AAMIX, 12402 ALC668_FIXUP_DELL_XPS13, 12403 ALC662_FIXUP_ASUS_Nx50, 12404 ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE, 12405 ALC668_FIXUP_ASUS_Nx51, 12406 ALC668_FIXUP_MIC_COEF, 12407 ALC668_FIXUP_ASUS_G751, 12408 ALC891_FIXUP_HEADSET_MODE, 12409 ALC891_FIXUP_DELL_MIC_NO_PRESENCE, 12410 ALC662_FIXUP_ACER_VERITON, 12411 ALC892_FIXUP_ASROCK_MOBO, 12412 ALC662_FIXUP_USI_FUNC, 12413 ALC662_FIXUP_USI_HEADSET_MODE, 12414 ALC662_FIXUP_LENOVO_MULTI_CODECS, 12415 ALC669_FIXUP_ACER_ASPIRE_ETHOS, 12416 ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET, 12417 ALC671_FIXUP_HP_HEADSET_MIC2, 12418 ALC662_FIXUP_ACER_X2660G_HEADSET_MODE, 12419 ALC662_FIXUP_ACER_NITRO_HEADSET_MODE, 12420 ALC668_FIXUP_ASUS_NO_HEADSET_MIC, 12421 ALC668_FIXUP_HEADSET_MIC, 12422 ALC668_FIXUP_MIC_DET_COEF, 12423 ALC897_FIXUP_LENOVO_HEADSET_MIC, 12424 ALC897_FIXUP_HEADSET_MIC_PIN, 12425 ALC897_FIXUP_HP_HSMIC_VERB, 12426 ALC897_FIXUP_LENOVO_HEADSET_MODE, 12427 ALC897_FIXUP_HEADSET_MIC_PIN2, 12428 ALC897_FIXUP_UNIS_H3C_X500S, 12429 ALC897_FIXUP_HEADSET_MIC_PIN3, 12430 }; 12431 12432 static const struct hda_fixup alc662_fixups[] = { 12433 [ALC662_FIXUP_ASPIRE] = { 12434 .type = HDA_FIXUP_PINS, 12435 .v.pins = (const struct hda_pintbl[]) { 12436 { 0x15, 0x99130112 }, /* subwoofer */ 12437 { } 12438 } 12439 }, 12440 [ALC662_FIXUP_LED_GPIO1] = { 12441 .type = HDA_FIXUP_FUNC, 12442 .v.func = alc662_fixup_led_gpio1, 12443 }, 12444 [ALC662_FIXUP_IDEAPAD] = { 12445 .type = HDA_FIXUP_PINS, 12446 .v.pins = (const struct hda_pintbl[]) { 12447 { 0x17, 0x99130112 }, /* subwoofer */ 12448 { } 12449 }, 12450 .chained = true, 12451 .chain_id = ALC662_FIXUP_LED_GPIO1, 12452 }, 12453 [ALC272_FIXUP_MARIO] = { 12454 .type = HDA_FIXUP_FUNC, 12455 .v.func = alc272_fixup_mario, 12456 }, 12457 [ALC662_FIXUP_CZC_ET26] = { 12458 .type = HDA_FIXUP_PINS, 12459 .v.pins = (const struct hda_pintbl[]) { 12460 {0x12, 0x403cc000}, 12461 {0x14, 0x90170110}, /* speaker */ 12462 {0x15, 0x411111f0}, 12463 {0x16, 0x411111f0}, 12464 {0x18, 0x01a19030}, /* mic */ 12465 {0x19, 0x90a7013f}, /* int-mic */ 12466 {0x1a, 0x01014020}, 12467 {0x1b, 0x0121401f}, 12468 {0x1c, 0x411111f0}, 12469 {0x1d, 0x411111f0}, 12470 {0x1e, 0x40478e35}, 12471 {} 12472 }, 12473 .chained = true, 12474 .chain_id = ALC662_FIXUP_SKU_IGNORE 12475 }, 12476 [ALC662_FIXUP_CZC_P10T] = { 12477 .type = HDA_FIXUP_VERBS, 12478 .v.verbs = (const struct hda_verb[]) { 12479 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0}, 12480 {} 12481 } 12482 }, 12483 [ALC662_FIXUP_SKU_IGNORE] = { 12484 .type = HDA_FIXUP_FUNC, 12485 .v.func = alc_fixup_sku_ignore, 12486 }, 12487 [ALC662_FIXUP_HP_RP5800] = { 12488 .type = HDA_FIXUP_PINS, 12489 .v.pins = (const struct hda_pintbl[]) { 12490 { 0x14, 0x0221201f }, /* HP out */ 12491 { } 12492 }, 12493 .chained = true, 12494 .chain_id = ALC662_FIXUP_SKU_IGNORE 12495 }, 12496 [ALC662_FIXUP_ASUS_MODE1] = { 12497 .type = HDA_FIXUP_PINS, 12498 .v.pins = (const struct hda_pintbl[]) { 12499 { 0x14, 0x99130110 }, /* speaker */ 12500 { 0x18, 0x01a19c20 }, /* mic */ 12501 { 0x19, 0x99a3092f }, /* int-mic */ 12502 { 0x21, 0x0121401f }, /* HP out */ 12503 { } 12504 }, 12505 .chained = true, 12506 .chain_id = ALC662_FIXUP_SKU_IGNORE 12507 }, 12508 [ALC662_FIXUP_ASUS_MODE2] = { 12509 .type = HDA_FIXUP_PINS, 12510 .v.pins = (const struct hda_pintbl[]) { 12511 { 0x14, 0x99130110 }, /* speaker */ 12512 { 0x18, 0x01a19820 }, /* mic */ 12513 { 0x19, 0x99a3092f }, /* int-mic */ 12514 { 0x1b, 0x0121401f }, /* HP out */ 12515 { } 12516 }, 12517 .chained = true, 12518 .chain_id = ALC662_FIXUP_SKU_IGNORE 12519 }, 12520 [ALC662_FIXUP_ASUS_MODE3] = { 12521 .type = HDA_FIXUP_PINS, 12522 .v.pins = (const struct hda_pintbl[]) { 12523 { 0x14, 0x99130110 }, /* speaker */ 12524 { 0x15, 0x0121441f }, /* HP */ 12525 { 0x18, 0x01a19840 }, /* mic */ 12526 { 0x19, 0x99a3094f }, /* int-mic */ 12527 { 0x21, 0x01211420 }, /* HP2 */ 12528 { } 12529 }, 12530 .chained = true, 12531 .chain_id = ALC662_FIXUP_SKU_IGNORE 12532 }, 12533 [ALC662_FIXUP_ASUS_MODE4] = { 12534 .type = HDA_FIXUP_PINS, 12535 .v.pins = (const struct hda_pintbl[]) { 12536 { 0x14, 0x99130110 }, /* speaker */ 12537 { 0x16, 0x99130111 }, /* speaker */ 12538 { 0x18, 0x01a19840 }, /* mic */ 12539 { 0x19, 0x99a3094f }, /* int-mic */ 12540 { 0x21, 0x0121441f }, /* HP */ 12541 { } 12542 }, 12543 .chained = true, 12544 .chain_id = ALC662_FIXUP_SKU_IGNORE 12545 }, 12546 [ALC662_FIXUP_ASUS_MODE5] = { 12547 .type = HDA_FIXUP_PINS, 12548 .v.pins = (const struct hda_pintbl[]) { 12549 { 0x14, 0x99130110 }, /* speaker */ 12550 { 0x15, 0x0121441f }, /* HP */ 12551 { 0x16, 0x99130111 }, /* speaker */ 12552 { 0x18, 0x01a19840 }, /* mic */ 12553 { 0x19, 0x99a3094f }, /* int-mic */ 12554 { } 12555 }, 12556 .chained = true, 12557 .chain_id = ALC662_FIXUP_SKU_IGNORE 12558 }, 12559 [ALC662_FIXUP_ASUS_MODE6] = { 12560 .type = HDA_FIXUP_PINS, 12561 .v.pins = (const struct hda_pintbl[]) { 12562 { 0x14, 0x99130110 }, /* speaker */ 12563 { 0x15, 0x01211420 }, /* HP2 */ 12564 { 0x18, 0x01a19840 }, /* mic */ 12565 { 0x19, 0x99a3094f }, /* int-mic */ 12566 { 0x1b, 0x0121441f }, /* HP */ 12567 { } 12568 }, 12569 .chained = true, 12570 .chain_id = ALC662_FIXUP_SKU_IGNORE 12571 }, 12572 [ALC662_FIXUP_ASUS_MODE7] = { 12573 .type = HDA_FIXUP_PINS, 12574 .v.pins = (const struct hda_pintbl[]) { 12575 { 0x14, 0x99130110 }, /* speaker */ 12576 { 0x17, 0x99130111 }, /* speaker */ 12577 { 0x18, 0x01a19840 }, /* mic */ 12578 { 0x19, 0x99a3094f }, /* int-mic */ 12579 { 0x1b, 0x01214020 }, /* HP */ 12580 { 0x21, 0x0121401f }, /* HP */ 12581 { } 12582 }, 12583 .chained = true, 12584 .chain_id = ALC662_FIXUP_SKU_IGNORE 12585 }, 12586 [ALC662_FIXUP_ASUS_MODE8] = { 12587 .type = HDA_FIXUP_PINS, 12588 .v.pins = (const struct hda_pintbl[]) { 12589 { 0x14, 0x99130110 }, /* speaker */ 12590 { 0x12, 0x99a30970 }, /* int-mic */ 12591 { 0x15, 0x01214020 }, /* HP */ 12592 { 0x17, 0x99130111 }, /* speaker */ 12593 { 0x18, 0x01a19840 }, /* mic */ 12594 { 0x21, 0x0121401f }, /* HP */ 12595 { } 12596 }, 12597 .chained = true, 12598 .chain_id = ALC662_FIXUP_SKU_IGNORE 12599 }, 12600 [ALC662_FIXUP_NO_JACK_DETECT] = { 12601 .type = HDA_FIXUP_FUNC, 12602 .v.func = alc_fixup_no_jack_detect, 12603 }, 12604 [ALC662_FIXUP_ZOTAC_Z68] = { 12605 .type = HDA_FIXUP_PINS, 12606 .v.pins = (const struct hda_pintbl[]) { 12607 { 0x1b, 0x02214020 }, /* Front HP */ 12608 { } 12609 } 12610 }, 12611 [ALC662_FIXUP_INV_DMIC] = { 12612 .type = HDA_FIXUP_FUNC, 12613 .v.func = alc_fixup_inv_dmic, 12614 }, 12615 [ALC668_FIXUP_DELL_XPS13] = { 12616 .type = HDA_FIXUP_FUNC, 12617 .v.func = alc_fixup_dell_xps13, 12618 .chained = true, 12619 .chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX 12620 }, 12621 [ALC668_FIXUP_DELL_DISABLE_AAMIX] = { 12622 .type = HDA_FIXUP_FUNC, 12623 .v.func = alc_fixup_disable_aamix, 12624 .chained = true, 12625 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE 12626 }, 12627 [ALC668_FIXUP_AUTO_MUTE] = { 12628 .type = HDA_FIXUP_FUNC, 12629 .v.func = alc_fixup_auto_mute_via_amp, 12630 .chained = true, 12631 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE 12632 }, 12633 [ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = { 12634 .type = HDA_FIXUP_PINS, 12635 .v.pins = (const struct hda_pintbl[]) { 12636 { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */ 12637 /* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */ 12638 { } 12639 }, 12640 .chained = true, 12641 .chain_id = ALC662_FIXUP_HEADSET_MODE 12642 }, 12643 [ALC662_FIXUP_HEADSET_MODE] = { 12644 .type = HDA_FIXUP_FUNC, 12645 .v.func = alc_fixup_headset_mode_alc662, 12646 }, 12647 [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = { 12648 .type = HDA_FIXUP_PINS, 12649 .v.pins = (const struct hda_pintbl[]) { 12650 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */ 12651 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */ 12652 { } 12653 }, 12654 .chained = true, 12655 .chain_id = ALC668_FIXUP_HEADSET_MODE 12656 }, 12657 [ALC668_FIXUP_HEADSET_MODE] = { 12658 .type = HDA_FIXUP_FUNC, 12659 .v.func = alc_fixup_headset_mode_alc668, 12660 }, 12661 [ALC662_FIXUP_BASS_MODE4_CHMAP] = { 12662 .type = HDA_FIXUP_FUNC, 12663 .v.func = alc_fixup_bass_chmap, 12664 .chained = true, 12665 .chain_id = ALC662_FIXUP_ASUS_MODE4 12666 }, 12667 [ALC662_FIXUP_BASS_16] = { 12668 .type = HDA_FIXUP_PINS, 12669 .v.pins = (const struct hda_pintbl[]) { 12670 {0x16, 0x80106111}, /* bass speaker */ 12671 {} 12672 }, 12673 .chained = true, 12674 .chain_id = ALC662_FIXUP_BASS_CHMAP, 12675 }, 12676 [ALC662_FIXUP_BASS_1A] = { 12677 .type = HDA_FIXUP_PINS, 12678 .v.pins = (const struct hda_pintbl[]) { 12679 {0x1a, 0x80106111}, /* bass speaker */ 12680 {} 12681 }, 12682 .chained = true, 12683 .chain_id = ALC662_FIXUP_BASS_CHMAP, 12684 }, 12685 [ALC662_FIXUP_BASS_CHMAP] = { 12686 .type = HDA_FIXUP_FUNC, 12687 .v.func = alc_fixup_bass_chmap, 12688 }, 12689 [ALC662_FIXUP_ASUS_Nx50] = { 12690 .type = HDA_FIXUP_FUNC, 12691 .v.func = alc_fixup_auto_mute_via_amp, 12692 .chained = true, 12693 .chain_id = ALC662_FIXUP_BASS_1A 12694 }, 12695 [ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = { 12696 .type = HDA_FIXUP_FUNC, 12697 .v.func = alc_fixup_headset_mode_alc668, 12698 .chain_id = ALC662_FIXUP_BASS_CHMAP 12699 }, 12700 [ALC668_FIXUP_ASUS_Nx51] = { 12701 .type = HDA_FIXUP_PINS, 12702 .v.pins = (const struct hda_pintbl[]) { 12703 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */ 12704 { 0x1a, 0x90170151 }, /* bass speaker */ 12705 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */ 12706 {} 12707 }, 12708 .chained = true, 12709 .chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE, 12710 }, 12711 [ALC668_FIXUP_MIC_COEF] = { 12712 .type = HDA_FIXUP_VERBS, 12713 .v.verbs = (const struct hda_verb[]) { 12714 { 0x20, AC_VERB_SET_COEF_INDEX, 0xc3 }, 12715 { 0x20, AC_VERB_SET_PROC_COEF, 0x4000 }, 12716 {} 12717 }, 12718 }, 12719 [ALC668_FIXUP_ASUS_G751] = { 12720 .type = HDA_FIXUP_PINS, 12721 .v.pins = (const struct hda_pintbl[]) { 12722 { 0x16, 0x0421101f }, /* HP */ 12723 {} 12724 }, 12725 .chained = true, 12726 .chain_id = ALC668_FIXUP_MIC_COEF 12727 }, 12728 [ALC891_FIXUP_HEADSET_MODE] = { 12729 .type = HDA_FIXUP_FUNC, 12730 .v.func = alc_fixup_headset_mode, 12731 }, 12732 [ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = { 12733 .type = HDA_FIXUP_PINS, 12734 .v.pins = (const struct hda_pintbl[]) { 12735 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */ 12736 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */ 12737 { } 12738 }, 12739 .chained = true, 12740 .chain_id = ALC891_FIXUP_HEADSET_MODE 12741 }, 12742 [ALC662_FIXUP_ACER_VERITON] = { 12743 .type = HDA_FIXUP_PINS, 12744 .v.pins = (const struct hda_pintbl[]) { 12745 { 0x15, 0x50170120 }, /* no internal speaker */ 12746 { } 12747 } 12748 }, 12749 [ALC892_FIXUP_ASROCK_MOBO] = { 12750 .type = HDA_FIXUP_PINS, 12751 .v.pins = (const struct hda_pintbl[]) { 12752 { 0x15, 0x40f000f0 }, /* disabled */ 12753 { 0x16, 0x40f000f0 }, /* disabled */ 12754 { } 12755 } 12756 }, 12757 [ALC662_FIXUP_USI_FUNC] = { 12758 .type = HDA_FIXUP_FUNC, 12759 .v.func = alc662_fixup_usi_headset_mic, 12760 }, 12761 [ALC662_FIXUP_USI_HEADSET_MODE] = { 12762 .type = HDA_FIXUP_PINS, 12763 .v.pins = (const struct hda_pintbl[]) { 12764 { 0x19, 0x02a1913c }, /* use as headset mic, without its own jack detect */ 12765 { 0x18, 0x01a1903d }, 12766 { } 12767 }, 12768 .chained = true, 12769 .chain_id = ALC662_FIXUP_USI_FUNC 12770 }, 12771 [ALC662_FIXUP_LENOVO_MULTI_CODECS] = { 12772 .type = HDA_FIXUP_FUNC, 12773 .v.func = alc233_alc662_fixup_lenovo_dual_codecs, 12774 }, 12775 [ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET] = { 12776 .type = HDA_FIXUP_FUNC, 12777 .v.func = alc662_fixup_aspire_ethos_hp, 12778 }, 12779 [ALC669_FIXUP_ACER_ASPIRE_ETHOS] = { 12780 .type = HDA_FIXUP_PINS, 12781 .v.pins = (const struct hda_pintbl[]) { 12782 { 0x15, 0x92130110 }, /* front speakers */ 12783 { 0x18, 0x99130111 }, /* center/subwoofer */ 12784 { 0x1b, 0x11130012 }, /* surround plus jack for HP */ 12785 { } 12786 }, 12787 .chained = true, 12788 .chain_id = ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET 12789 }, 12790 [ALC671_FIXUP_HP_HEADSET_MIC2] = { 12791 .type = HDA_FIXUP_FUNC, 12792 .v.func = alc671_fixup_hp_headset_mic2, 12793 }, 12794 [ALC662_FIXUP_ACER_X2660G_HEADSET_MODE] = { 12795 .type = HDA_FIXUP_PINS, 12796 .v.pins = (const struct hda_pintbl[]) { 12797 { 0x1a, 0x02a1113c }, /* use as headset mic, without its own jack detect */ 12798 { } 12799 }, 12800 .chained = true, 12801 .chain_id = ALC662_FIXUP_USI_FUNC 12802 }, 12803 [ALC662_FIXUP_ACER_NITRO_HEADSET_MODE] = { 12804 .type = HDA_FIXUP_PINS, 12805 .v.pins = (const struct hda_pintbl[]) { 12806 { 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */ 12807 { 0x1b, 0x0221144f }, 12808 { } 12809 }, 12810 .chained = true, 12811 .chain_id = ALC662_FIXUP_USI_FUNC 12812 }, 12813 [ALC668_FIXUP_ASUS_NO_HEADSET_MIC] = { 12814 .type = HDA_FIXUP_PINS, 12815 .v.pins = (const struct hda_pintbl[]) { 12816 { 0x1b, 0x04a1112c }, 12817 { } 12818 }, 12819 .chained = true, 12820 .chain_id = ALC668_FIXUP_HEADSET_MIC 12821 }, 12822 [ALC668_FIXUP_HEADSET_MIC] = { 12823 .type = HDA_FIXUP_FUNC, 12824 .v.func = alc269_fixup_headset_mic, 12825 .chained = true, 12826 .chain_id = ALC668_FIXUP_MIC_DET_COEF 12827 }, 12828 [ALC668_FIXUP_MIC_DET_COEF] = { 12829 .type = HDA_FIXUP_VERBS, 12830 .v.verbs = (const struct hda_verb[]) { 12831 { 0x20, AC_VERB_SET_COEF_INDEX, 0x15 }, 12832 { 0x20, AC_VERB_SET_PROC_COEF, 0x0d60 }, 12833 {} 12834 }, 12835 }, 12836 [ALC897_FIXUP_LENOVO_HEADSET_MIC] = { 12837 .type = HDA_FIXUP_FUNC, 12838 .v.func = alc897_fixup_lenovo_headset_mic, 12839 }, 12840 [ALC897_FIXUP_HEADSET_MIC_PIN] = { 12841 .type = HDA_FIXUP_PINS, 12842 .v.pins = (const struct hda_pintbl[]) { 12843 { 0x1a, 0x03a11050 }, 12844 { } 12845 }, 12846 .chained = true, 12847 .chain_id = ALC897_FIXUP_LENOVO_HEADSET_MIC 12848 }, 12849 [ALC897_FIXUP_HP_HSMIC_VERB] = { 12850 .type = HDA_FIXUP_PINS, 12851 .v.pins = (const struct hda_pintbl[]) { 12852 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 12853 { } 12854 }, 12855 }, 12856 [ALC897_FIXUP_LENOVO_HEADSET_MODE] = { 12857 .type = HDA_FIXUP_FUNC, 12858 .v.func = alc897_fixup_lenovo_headset_mode, 12859 }, 12860 [ALC897_FIXUP_HEADSET_MIC_PIN2] = { 12861 .type = HDA_FIXUP_PINS, 12862 .v.pins = (const struct hda_pintbl[]) { 12863 { 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */ 12864 { } 12865 }, 12866 .chained = true, 12867 .chain_id = ALC897_FIXUP_LENOVO_HEADSET_MODE 12868 }, 12869 [ALC897_FIXUP_UNIS_H3C_X500S] = { 12870 .type = HDA_FIXUP_VERBS, 12871 .v.verbs = (const struct hda_verb[]) { 12872 { 0x14, AC_VERB_SET_EAPD_BTLENABLE, 0 }, 12873 {} 12874 }, 12875 }, 12876 [ALC897_FIXUP_HEADSET_MIC_PIN3] = { 12877 .type = HDA_FIXUP_PINS, 12878 .v.pins = (const struct hda_pintbl[]) { 12879 { 0x19, 0x03a11050 }, /* use as headset mic */ 12880 { } 12881 }, 12882 }, 12883 }; 12884 12885 static const struct snd_pci_quirk alc662_fixup_tbl[] = { 12886 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2), 12887 SND_PCI_QUIRK(0x1019, 0x9859, "JP-IK LEAP W502", ALC897_FIXUP_HEADSET_MIC_PIN3), 12888 SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC), 12889 SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC), 12890 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE), 12891 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE), 12892 SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC), 12893 SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC), 12894 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE), 12895 SND_PCI_QUIRK(0x1025, 0x0566, "Acer Aspire Ethos 8951G", ALC669_FIXUP_ACER_ASPIRE_ETHOS), 12896 SND_PCI_QUIRK(0x1025, 0x123c, "Acer Nitro N50-600", ALC662_FIXUP_ACER_NITRO_HEADSET_MODE), 12897 SND_PCI_QUIRK(0x1025, 0x124e, "Acer 2660G", ALC662_FIXUP_ACER_X2660G_HEADSET_MODE), 12898 SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 12899 SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 12900 SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13), 12901 SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13), 12902 SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13), 12903 SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 12904 SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 12905 SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 12906 SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 12907 SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 12908 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800), 12909 SND_PCI_QUIRK(0x103c, 0x870c, "HP", ALC897_FIXUP_HP_HSMIC_VERB), 12910 SND_PCI_QUIRK(0x103c, 0x8719, "HP", ALC897_FIXUP_HP_HSMIC_VERB), 12911 SND_PCI_QUIRK(0x103c, 0x872b, "HP", ALC897_FIXUP_HP_HSMIC_VERB), 12912 SND_PCI_QUIRK(0x103c, 0x873e, "HP", ALC671_FIXUP_HP_HEADSET_MIC2), 12913 SND_PCI_QUIRK(0x103c, 0x8768, "HP Slim Desktop S01", ALC671_FIXUP_HP_HEADSET_MIC2), 12914 SND_PCI_QUIRK(0x103c, 0x877e, "HP 288 Pro G6", ALC671_FIXUP_HP_HEADSET_MIC2), 12915 SND_PCI_QUIRK(0x103c, 0x885f, "HP 288 Pro G8", ALC671_FIXUP_HP_HEADSET_MIC2), 12916 SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE), 12917 SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50), 12918 SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50), 12919 SND_PCI_QUIRK(0x1043, 0x12ff, "ASUS G751", ALC668_FIXUP_ASUS_G751), 12920 SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A), 12921 SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP), 12922 SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16), 12923 SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51), 12924 SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51), 12925 SND_PCI_QUIRK(0x1043, 0x185d, "ASUS G551JW", ALC668_FIXUP_ASUS_NO_HEADSET_MIC), 12926 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8), 12927 SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16), 12928 SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP), 12929 SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT), 12930 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2), 12931 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD), 12932 SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE), 12933 SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS), 12934 SND_PCI_QUIRK(0x17aa, 0x1057, "Lenovo P360", ALC897_FIXUP_HEADSET_MIC_PIN), 12935 SND_PCI_QUIRK(0x17aa, 0x1064, "Lenovo P3 Tower", ALC897_FIXUP_HEADSET_MIC_PIN), 12936 SND_PCI_QUIRK(0x17aa, 0x32ca, "Lenovo ThinkCentre M80", ALC897_FIXUP_HEADSET_MIC_PIN), 12937 SND_PCI_QUIRK(0x17aa, 0x32cb, "Lenovo ThinkCentre M70", ALC897_FIXUP_HEADSET_MIC_PIN), 12938 SND_PCI_QUIRK(0x17aa, 0x32cf, "Lenovo ThinkCentre M950", ALC897_FIXUP_HEADSET_MIC_PIN), 12939 SND_PCI_QUIRK(0x17aa, 0x32f7, "Lenovo ThinkCentre M90", ALC897_FIXUP_HEADSET_MIC_PIN), 12940 SND_PCI_QUIRK(0x17aa, 0x3321, "Lenovo ThinkCentre M70 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN), 12941 SND_PCI_QUIRK(0x17aa, 0x331b, "Lenovo ThinkCentre M90 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN), 12942 SND_PCI_QUIRK(0x17aa, 0x3364, "Lenovo ThinkCentre M90 Gen5", ALC897_FIXUP_HEADSET_MIC_PIN), 12943 SND_PCI_QUIRK(0x17aa, 0x3742, "Lenovo TianYi510Pro-14IOB", ALC897_FIXUP_HEADSET_MIC_PIN2), 12944 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD), 12945 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD), 12946 SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO), 12947 SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68), 12948 SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON), 12949 SND_PCI_QUIRK(0x1b35, 0x1234, "CZC ET26", ALC662_FIXUP_CZC_ET26), 12950 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T), 12951 SND_PCI_QUIRK(0x1c6c, 0x1239, "Compaq N14JP6-V2", ALC897_FIXUP_HP_HSMIC_VERB), 12952 12953 #if 0 12954 /* Below is a quirk table taken from the old code. 12955 * Basically the device should work as is without the fixup table. 12956 * If BIOS doesn't give a proper info, enable the corresponding 12957 * fixup entry. 12958 */ 12959 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1), 12960 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3), 12961 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1), 12962 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3), 12963 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 12964 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 12965 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 12966 SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1), 12967 SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1), 12968 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 12969 SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7), 12970 SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7), 12971 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8), 12972 SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3), 12973 SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1), 12974 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 12975 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2), 12976 SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1), 12977 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 12978 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6), 12979 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6), 12980 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 12981 SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1), 12982 SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3), 12983 SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2), 12984 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 12985 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5), 12986 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6), 12987 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 12988 SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1), 12989 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 12990 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 12991 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3), 12992 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3), 12993 SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1), 12994 SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1), 12995 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1), 12996 SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1), 12997 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1), 12998 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 12999 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2), 13000 SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1), 13001 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 13002 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3), 13003 SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1), 13004 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1), 13005 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1), 13006 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2), 13007 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 13008 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4), 13009 #endif 13010 {} 13011 }; 13012 13013 static const struct hda_model_fixup alc662_fixup_models[] = { 13014 {.id = ALC662_FIXUP_ASPIRE, .name = "aspire"}, 13015 {.id = ALC662_FIXUP_IDEAPAD, .name = "ideapad"}, 13016 {.id = ALC272_FIXUP_MARIO, .name = "mario"}, 13017 {.id = ALC662_FIXUP_HP_RP5800, .name = "hp-rp5800"}, 13018 {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"}, 13019 {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"}, 13020 {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"}, 13021 {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"}, 13022 {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"}, 13023 {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"}, 13024 {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"}, 13025 {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"}, 13026 {.id = ALC662_FIXUP_ZOTAC_Z68, .name = "zotac-z68"}, 13027 {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"}, 13028 {.id = ALC662_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc662-headset-multi"}, 13029 {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"}, 13030 {.id = ALC662_FIXUP_HEADSET_MODE, .name = "alc662-headset"}, 13031 {.id = ALC668_FIXUP_HEADSET_MODE, .name = "alc668-headset"}, 13032 {.id = ALC662_FIXUP_BASS_16, .name = "bass16"}, 13033 {.id = ALC662_FIXUP_BASS_1A, .name = "bass1a"}, 13034 {.id = ALC668_FIXUP_AUTO_MUTE, .name = "automute"}, 13035 {.id = ALC668_FIXUP_DELL_XPS13, .name = "dell-xps13"}, 13036 {.id = ALC662_FIXUP_ASUS_Nx50, .name = "asus-nx50"}, 13037 {.id = ALC668_FIXUP_ASUS_Nx51, .name = "asus-nx51"}, 13038 {.id = ALC668_FIXUP_ASUS_G751, .name = "asus-g751"}, 13039 {.id = ALC891_FIXUP_HEADSET_MODE, .name = "alc891-headset"}, 13040 {.id = ALC891_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc891-headset-multi"}, 13041 {.id = ALC662_FIXUP_ACER_VERITON, .name = "acer-veriton"}, 13042 {.id = ALC892_FIXUP_ASROCK_MOBO, .name = "asrock-mobo"}, 13043 {.id = ALC662_FIXUP_USI_HEADSET_MODE, .name = "usi-headset"}, 13044 {.id = ALC662_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"}, 13045 {.id = ALC669_FIXUP_ACER_ASPIRE_ETHOS, .name = "aspire-ethos"}, 13046 {.id = ALC897_FIXUP_UNIS_H3C_X500S, .name = "unis-h3c-x500s"}, 13047 {} 13048 }; 13049 13050 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = { 13051 SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE, 13052 {0x17, 0x02211010}, 13053 {0x18, 0x01a19030}, 13054 {0x1a, 0x01813040}, 13055 {0x21, 0x01014020}), 13056 SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE, 13057 {0x16, 0x01813030}, 13058 {0x17, 0x02211010}, 13059 {0x18, 0x01a19040}, 13060 {0x21, 0x01014020}), 13061 SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE, 13062 {0x14, 0x01014010}, 13063 {0x18, 0x01a19020}, 13064 {0x1a, 0x0181302f}, 13065 {0x1b, 0x0221401f}), 13066 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE, 13067 {0x12, 0x99a30130}, 13068 {0x14, 0x90170110}, 13069 {0x15, 0x0321101f}, 13070 {0x16, 0x03011020}), 13071 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE, 13072 {0x12, 0x99a30140}, 13073 {0x14, 0x90170110}, 13074 {0x15, 0x0321101f}, 13075 {0x16, 0x03011020}), 13076 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE, 13077 {0x12, 0x99a30150}, 13078 {0x14, 0x90170110}, 13079 {0x15, 0x0321101f}, 13080 {0x16, 0x03011020}), 13081 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE, 13082 {0x14, 0x90170110}, 13083 {0x15, 0x0321101f}, 13084 {0x16, 0x03011020}), 13085 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE, 13086 {0x12, 0x90a60130}, 13087 {0x14, 0x90170110}, 13088 {0x15, 0x0321101f}), 13089 SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2, 13090 {0x14, 0x01014010}, 13091 {0x17, 0x90170150}, 13092 {0x19, 0x02a11060}, 13093 {0x1b, 0x01813030}, 13094 {0x21, 0x02211020}), 13095 SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2, 13096 {0x14, 0x01014010}, 13097 {0x18, 0x01a19040}, 13098 {0x1b, 0x01813030}, 13099 {0x21, 0x02211020}), 13100 SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2, 13101 {0x14, 0x01014020}, 13102 {0x17, 0x90170110}, 13103 {0x18, 0x01a19050}, 13104 {0x1b, 0x01813040}, 13105 {0x21, 0x02211030}), 13106 {} 13107 }; 13108 13109 /* 13110 */ 13111 static int patch_alc662(struct hda_codec *codec) 13112 { 13113 struct alc_spec *spec; 13114 int err; 13115 13116 err = alc_alloc_spec(codec, 0x0b); 13117 if (err < 0) 13118 return err; 13119 13120 spec = codec->spec; 13121 13122 spec->shutup = alc_eapd_shutup; 13123 13124 /* handle multiple HPs as is */ 13125 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 13126 13127 alc_fix_pll_init(codec, 0x20, 0x04, 15); 13128 13129 switch (codec->core.vendor_id) { 13130 case 0x10ec0668: 13131 spec->init_hook = alc668_restore_default_value; 13132 break; 13133 } 13134 13135 alc_pre_init(codec); 13136 13137 snd_hda_pick_fixup(codec, alc662_fixup_models, 13138 alc662_fixup_tbl, alc662_fixups); 13139 snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups, true); 13140 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 13141 13142 alc_auto_parse_customize_define(codec); 13143 13144 if (has_cdefine_beep(codec)) 13145 spec->gen.beep_nid = 0x01; 13146 13147 if ((alc_get_coef0(codec) & (1 << 14)) && 13148 codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 && 13149 spec->cdefine.platform_type == 1) { 13150 err = alc_codec_rename(codec, "ALC272X"); 13151 if (err < 0) 13152 goto error; 13153 } 13154 13155 /* automatic parse from the BIOS config */ 13156 err = alc662_parse_auto_config(codec); 13157 if (err < 0) 13158 goto error; 13159 13160 if (!spec->gen.no_analog && spec->gen.beep_nid) { 13161 switch (codec->core.vendor_id) { 13162 case 0x10ec0662: 13163 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 13164 break; 13165 case 0x10ec0272: 13166 case 0x10ec0663: 13167 case 0x10ec0665: 13168 case 0x10ec0668: 13169 err = set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT); 13170 break; 13171 case 0x10ec0273: 13172 err = set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT); 13173 break; 13174 } 13175 if (err < 0) 13176 goto error; 13177 } 13178 13179 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 13180 13181 return 0; 13182 13183 error: 13184 alc_free(codec); 13185 return err; 13186 } 13187 13188 /* 13189 * ALC680 support 13190 */ 13191 13192 static int alc680_parse_auto_config(struct hda_codec *codec) 13193 { 13194 return alc_parse_auto_config(codec, NULL, NULL); 13195 } 13196 13197 /* 13198 */ 13199 static int patch_alc680(struct hda_codec *codec) 13200 { 13201 int err; 13202 13203 /* ALC680 has no aa-loopback mixer */ 13204 err = alc_alloc_spec(codec, 0); 13205 if (err < 0) 13206 return err; 13207 13208 /* automatic parse from the BIOS config */ 13209 err = alc680_parse_auto_config(codec); 13210 if (err < 0) { 13211 alc_free(codec); 13212 return err; 13213 } 13214 13215 return 0; 13216 } 13217 13218 /* 13219 * patch entries 13220 */ 13221 static const struct hda_device_id snd_hda_id_realtek[] = { 13222 HDA_CODEC_ENTRY(0x10ec0215, "ALC215", patch_alc269), 13223 HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269), 13224 HDA_CODEC_ENTRY(0x10ec0222, "ALC222", patch_alc269), 13225 HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269), 13226 HDA_CODEC_ENTRY(0x10ec0230, "ALC236", patch_alc269), 13227 HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269), 13228 HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269), 13229 HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269), 13230 HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269), 13231 HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269), 13232 HDA_CODEC_ENTRY(0x10ec0245, "ALC245", patch_alc269), 13233 HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269), 13234 HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269), 13235 HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269), 13236 HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260), 13237 HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262), 13238 HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268), 13239 HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268), 13240 HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269), 13241 HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269), 13242 HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662), 13243 HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269), 13244 HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269), 13245 HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269), 13246 HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269), 13247 HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269), 13248 HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269), 13249 HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269), 13250 HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269), 13251 HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269), 13252 HDA_CODEC_ENTRY(0x10ec0287, "ALC287", patch_alc269), 13253 HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269), 13254 HDA_CODEC_ENTRY(0x10ec0289, "ALC289", patch_alc269), 13255 HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269), 13256 HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269), 13257 HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269), 13258 HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269), 13259 HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269), 13260 HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269), 13261 HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269), 13262 HDA_CODEC_ENTRY(0x10ec0300, "ALC300", patch_alc269), 13263 HDA_CODEC_ENTRY(0x10ec0623, "ALC623", patch_alc269), 13264 HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861), 13265 HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd), 13266 HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861), 13267 HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd), 13268 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882), 13269 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662), 13270 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662), 13271 HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662), 13272 HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662), 13273 HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662), 13274 HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662), 13275 HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662), 13276 HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662), 13277 HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680), 13278 HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269), 13279 HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269), 13280 HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269), 13281 HDA_CODEC_ENTRY(0x10ec0711, "ALC711", patch_alc269), 13282 HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662), 13283 HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880), 13284 HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882), 13285 HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882), 13286 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882), 13287 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882), 13288 HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882), 13289 HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882), 13290 HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882), 13291 HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882), 13292 HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882), 13293 HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662), 13294 HDA_CODEC_ENTRY(0x10ec0897, "ALC897", patch_alc662), 13295 HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882), 13296 HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882), 13297 HDA_CODEC_ENTRY(0x10ec0b00, "ALCS1200A", patch_alc882), 13298 HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882), 13299 HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882), 13300 HDA_CODEC_ENTRY(0x19e58326, "HW8326", patch_alc269), 13301 {} /* terminator */ 13302 }; 13303 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek); 13304 13305 MODULE_LICENSE("GPL"); 13306 MODULE_DESCRIPTION("Realtek HD-audio codec"); 13307 MODULE_IMPORT_NS(SND_HDA_SCODEC_COMPONENT); 13308 13309 static struct hda_codec_driver realtek_driver = { 13310 .id = snd_hda_id_realtek, 13311 }; 13312 13313 module_hda_codec_driver(realtek_driver); 13314