1 // SPDX-License-Identifier: GPL-2.0-or-later 2 // 3 // Realtek ALC269 and compatible codecs 4 // 5 6 #include <linux/init.h> 7 #include <linux/module.h> 8 #include "realtek.h" 9 10 /* keep halting ALC5505 DSP, for power saving */ 11 #define HALT_REALTEK_ALC5505 12 13 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = { 14 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */ 15 }; 16 17 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = { 18 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */ 19 }; 20 21 /* different alc269-variants */ 22 enum { 23 ALC269_TYPE_ALC269VA, 24 ALC269_TYPE_ALC269VB, 25 ALC269_TYPE_ALC269VC, 26 ALC269_TYPE_ALC269VD, 27 ALC269_TYPE_ALC280, 28 ALC269_TYPE_ALC282, 29 ALC269_TYPE_ALC283, 30 ALC269_TYPE_ALC284, 31 ALC269_TYPE_ALC293, 32 ALC269_TYPE_ALC286, 33 ALC269_TYPE_ALC298, 34 ALC269_TYPE_ALC255, 35 ALC269_TYPE_ALC256, 36 ALC269_TYPE_ALC257, 37 ALC269_TYPE_ALC215, 38 ALC269_TYPE_ALC225, 39 ALC269_TYPE_ALC245, 40 ALC269_TYPE_ALC287, 41 ALC269_TYPE_ALC294, 42 ALC269_TYPE_ALC300, 43 ALC269_TYPE_ALC623, 44 ALC269_TYPE_ALC700, 45 }; 46 47 /* 48 * BIOS auto configuration 49 */ 50 static int alc269_parse_auto_config(struct hda_codec *codec) 51 { 52 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 }; 53 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 }; 54 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 55 struct alc_spec *spec = codec->spec; 56 const hda_nid_t *ssids; 57 58 switch (spec->codec_variant) { 59 case ALC269_TYPE_ALC269VA: 60 case ALC269_TYPE_ALC269VC: 61 case ALC269_TYPE_ALC280: 62 case ALC269_TYPE_ALC284: 63 case ALC269_TYPE_ALC293: 64 ssids = alc269va_ssids; 65 break; 66 case ALC269_TYPE_ALC269VB: 67 case ALC269_TYPE_ALC269VD: 68 case ALC269_TYPE_ALC282: 69 case ALC269_TYPE_ALC283: 70 case ALC269_TYPE_ALC286: 71 case ALC269_TYPE_ALC298: 72 case ALC269_TYPE_ALC255: 73 case ALC269_TYPE_ALC256: 74 case ALC269_TYPE_ALC257: 75 case ALC269_TYPE_ALC215: 76 case ALC269_TYPE_ALC225: 77 case ALC269_TYPE_ALC245: 78 case ALC269_TYPE_ALC287: 79 case ALC269_TYPE_ALC294: 80 case ALC269_TYPE_ALC300: 81 case ALC269_TYPE_ALC623: 82 case ALC269_TYPE_ALC700: 83 ssids = alc269_ssids; 84 break; 85 default: 86 ssids = alc269_ssids; 87 break; 88 } 89 90 return alc_parse_auto_config(codec, alc269_ignore, ssids); 91 } 92 93 static const struct hda_jack_keymap alc_headset_btn_keymap[] = { 94 { SND_JACK_BTN_0, KEY_PLAYPAUSE }, 95 { SND_JACK_BTN_1, KEY_VOICECOMMAND }, 96 { SND_JACK_BTN_2, KEY_VOLUMEUP }, 97 { SND_JACK_BTN_3, KEY_VOLUMEDOWN }, 98 {} 99 }; 100 101 static void alc_headset_btn_callback(struct hda_codec *codec, 102 struct hda_jack_callback *jack) 103 { 104 int report = 0; 105 106 if (jack->unsol_res & (7 << 13)) 107 report |= SND_JACK_BTN_0; 108 109 if (jack->unsol_res & (1 << 16 | 3 << 8)) 110 report |= SND_JACK_BTN_1; 111 112 /* Volume up key */ 113 if (jack->unsol_res & (7 << 23)) 114 report |= SND_JACK_BTN_2; 115 116 /* Volume down key */ 117 if (jack->unsol_res & (7 << 10)) 118 report |= SND_JACK_BTN_3; 119 120 snd_hda_jack_set_button_state(codec, jack->nid, report); 121 } 122 123 static void alc_disable_headset_jack_key(struct hda_codec *codec) 124 { 125 struct alc_spec *spec = codec->spec; 126 127 if (!spec->has_hs_key) 128 return; 129 130 switch (codec->core.vendor_id) { 131 case 0x10ec0215: 132 case 0x10ec0225: 133 case 0x10ec0285: 134 case 0x10ec0287: 135 case 0x10ec0295: 136 case 0x10ec0289: 137 case 0x10ec0299: 138 alc_write_coef_idx(codec, 0x48, 0x0); 139 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0); 140 alc_update_coef_idx(codec, 0x44, 0x0045 << 8, 0x0); 141 break; 142 case 0x10ec0230: 143 case 0x10ec0236: 144 case 0x10ec0256: 145 case 0x10ec0257: 146 case 0x19e58326: 147 alc_write_coef_idx(codec, 0x48, 0x0); 148 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0); 149 break; 150 } 151 } 152 153 static void alc_enable_headset_jack_key(struct hda_codec *codec) 154 { 155 struct alc_spec *spec = codec->spec; 156 157 if (!spec->has_hs_key) 158 return; 159 160 switch (codec->core.vendor_id) { 161 case 0x10ec0215: 162 case 0x10ec0225: 163 case 0x10ec0285: 164 case 0x10ec0287: 165 case 0x10ec0295: 166 case 0x10ec0289: 167 case 0x10ec0299: 168 alc_write_coef_idx(codec, 0x48, 0xd011); 169 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045); 170 alc_update_coef_idx(codec, 0x44, 0x007f << 8, 0x0045 << 8); 171 break; 172 case 0x10ec0230: 173 case 0x10ec0236: 174 case 0x10ec0256: 175 case 0x10ec0257: 176 case 0x19e58326: 177 alc_write_coef_idx(codec, 0x48, 0xd011); 178 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045); 179 break; 180 } 181 } 182 183 static void alc_fixup_headset_jack(struct hda_codec *codec, 184 const struct hda_fixup *fix, int action) 185 { 186 struct alc_spec *spec = codec->spec; 187 hda_nid_t hp_pin; 188 189 switch (action) { 190 case HDA_FIXUP_ACT_PRE_PROBE: 191 spec->has_hs_key = 1; 192 snd_hda_jack_detect_enable_callback(codec, 0x55, 193 alc_headset_btn_callback); 194 break; 195 case HDA_FIXUP_ACT_BUILD: 196 hp_pin = alc_get_hp_pin(spec); 197 if (!hp_pin || snd_hda_jack_bind_keymap(codec, 0x55, 198 alc_headset_btn_keymap, 199 hp_pin)) 200 snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack", 201 false, SND_JACK_HEADSET, 202 alc_headset_btn_keymap); 203 204 alc_enable_headset_jack_key(codec); 205 break; 206 } 207 } 208 209 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up) 210 { 211 alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0); 212 } 213 214 static void alc269_shutup(struct hda_codec *codec) 215 { 216 struct alc_spec *spec = codec->spec; 217 218 if (spec->codec_variant == ALC269_TYPE_ALC269VB) 219 alc269vb_toggle_power_output(codec, 0); 220 if (spec->codec_variant == ALC269_TYPE_ALC269VB && 221 (alc_get_coef0(codec) & 0x00ff) == 0x018) { 222 msleep(150); 223 } 224 alc_shutup_pins(codec); 225 } 226 227 static const struct coef_fw alc282_coefs[] = { 228 WRITE_COEF(0x03, 0x0002), /* Power Down Control */ 229 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */ 230 WRITE_COEF(0x07, 0x0200), /* DMIC control */ 231 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */ 232 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */ 233 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */ 234 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */ 235 WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */ 236 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */ 237 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */ 238 WRITE_COEF(0x6f, 0x0), /* Class D test 4 */ 239 UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */ 240 WRITE_COEF(0x34, 0xa0c0), /* ANC */ 241 UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */ 242 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */ 243 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */ 244 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */ 245 WRITE_COEF(0x63, 0x2902), /* PLL */ 246 WRITE_COEF(0x68, 0xa080), /* capless control 2 */ 247 WRITE_COEF(0x69, 0x3400), /* capless control 3 */ 248 WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */ 249 WRITE_COEF(0x6b, 0x0), /* capless control 5 */ 250 UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */ 251 WRITE_COEF(0x6e, 0x110a), /* class D test 3 */ 252 UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */ 253 WRITE_COEF(0x71, 0x0014), /* class D test 6 */ 254 WRITE_COEF(0x72, 0xc2ba), /* classD OCP */ 255 UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */ 256 WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */ 257 {} 258 }; 259 260 static void alc282_restore_default_value(struct hda_codec *codec) 261 { 262 alc_process_coef_fw(codec, alc282_coefs); 263 } 264 265 static void alc282_init(struct hda_codec *codec) 266 { 267 struct alc_spec *spec = codec->spec; 268 hda_nid_t hp_pin = alc_get_hp_pin(spec); 269 bool hp_pin_sense; 270 int coef78; 271 272 alc282_restore_default_value(codec); 273 274 if (!hp_pin) 275 return; 276 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 277 coef78 = alc_read_coef_idx(codec, 0x78); 278 279 /* Index 0x78 Direct Drive HP AMP LPM Control 1 */ 280 /* Headphone capless set to high power mode */ 281 alc_write_coef_idx(codec, 0x78, 0x9004); 282 283 if (hp_pin_sense) 284 msleep(2); 285 286 snd_hda_codec_write(codec, hp_pin, 0, 287 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 288 289 if (hp_pin_sense) 290 msleep(85); 291 292 snd_hda_codec_write(codec, hp_pin, 0, 293 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 294 295 if (hp_pin_sense) 296 msleep(100); 297 298 /* Headphone capless set to normal mode */ 299 if (coef78 != -1) 300 alc_write_coef_idx(codec, 0x78, coef78); 301 } 302 303 static void alc282_shutup(struct hda_codec *codec) 304 { 305 struct alc_spec *spec = codec->spec; 306 hda_nid_t hp_pin = alc_get_hp_pin(spec); 307 bool hp_pin_sense; 308 int coef78; 309 310 if (!hp_pin) { 311 alc269_shutup(codec); 312 return; 313 } 314 315 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 316 coef78 = alc_read_coef_idx(codec, 0x78); 317 alc_write_coef_idx(codec, 0x78, 0x9004); 318 319 if (hp_pin_sense) 320 msleep(2); 321 322 snd_hda_codec_write(codec, hp_pin, 0, 323 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 324 325 if (hp_pin_sense) 326 msleep(85); 327 328 if (!spec->no_shutup_pins) 329 snd_hda_codec_write(codec, hp_pin, 0, 330 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 331 332 if (hp_pin_sense) 333 msleep(100); 334 335 alc_auto_setup_eapd(codec, false); 336 alc_shutup_pins(codec); 337 if (coef78 != -1) 338 alc_write_coef_idx(codec, 0x78, coef78); 339 } 340 341 static const struct coef_fw alc283_coefs[] = { 342 WRITE_COEF(0x03, 0x0002), /* Power Down Control */ 343 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */ 344 WRITE_COEF(0x07, 0x0200), /* DMIC control */ 345 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */ 346 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */ 347 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */ 348 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */ 349 WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */ 350 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */ 351 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */ 352 WRITE_COEF(0x3a, 0x0), /* Class D test 4 */ 353 UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */ 354 WRITE_COEF(0x22, 0xa0c0), /* ANC */ 355 UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */ 356 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */ 357 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */ 358 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */ 359 WRITE_COEF(0x2e, 0x2902), /* PLL */ 360 WRITE_COEF(0x33, 0xa080), /* capless control 2 */ 361 WRITE_COEF(0x34, 0x3400), /* capless control 3 */ 362 WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */ 363 WRITE_COEF(0x36, 0x0), /* capless control 5 */ 364 UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */ 365 WRITE_COEF(0x39, 0x110a), /* class D test 3 */ 366 UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */ 367 WRITE_COEF(0x3c, 0x0014), /* class D test 6 */ 368 WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */ 369 UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */ 370 WRITE_COEF(0x49, 0x0), /* test mode */ 371 UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */ 372 UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */ 373 WRITE_COEF(0x37, 0xfc06), /* Class D amp control */ 374 UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */ 375 {} 376 }; 377 378 static void alc283_restore_default_value(struct hda_codec *codec) 379 { 380 alc_process_coef_fw(codec, alc283_coefs); 381 } 382 383 static void alc283_init(struct hda_codec *codec) 384 { 385 struct alc_spec *spec = codec->spec; 386 hda_nid_t hp_pin = alc_get_hp_pin(spec); 387 bool hp_pin_sense; 388 389 alc283_restore_default_value(codec); 390 391 if (!hp_pin) 392 return; 393 394 msleep(30); 395 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 396 397 /* Index 0x43 Direct Drive HP AMP LPM Control 1 */ 398 /* Headphone capless set to high power mode */ 399 alc_write_coef_idx(codec, 0x43, 0x9004); 400 401 snd_hda_codec_write(codec, hp_pin, 0, 402 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 403 404 if (hp_pin_sense) 405 msleep(85); 406 407 snd_hda_codec_write(codec, hp_pin, 0, 408 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 409 410 if (hp_pin_sense) 411 msleep(85); 412 /* Index 0x46 Combo jack auto switch control 2 */ 413 /* 3k pull low control for Headset jack. */ 414 alc_update_coef_idx(codec, 0x46, 3 << 12, 0); 415 /* Headphone capless set to normal mode */ 416 alc_write_coef_idx(codec, 0x43, 0x9614); 417 } 418 419 static void alc283_shutup(struct hda_codec *codec) 420 { 421 struct alc_spec *spec = codec->spec; 422 hda_nid_t hp_pin = alc_get_hp_pin(spec); 423 bool hp_pin_sense; 424 425 if (!hp_pin) { 426 alc269_shutup(codec); 427 return; 428 } 429 430 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 431 432 alc_write_coef_idx(codec, 0x43, 0x9004); 433 434 /*depop hp during suspend*/ 435 alc_write_coef_idx(codec, 0x06, 0x2100); 436 437 snd_hda_codec_write(codec, hp_pin, 0, 438 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 439 440 if (hp_pin_sense) 441 msleep(100); 442 443 if (!spec->no_shutup_pins) 444 snd_hda_codec_write(codec, hp_pin, 0, 445 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 446 447 alc_update_coef_idx(codec, 0x46, 0, 3 << 12); 448 449 if (hp_pin_sense) 450 msleep(100); 451 alc_auto_setup_eapd(codec, false); 452 alc_shutup_pins(codec); 453 alc_write_coef_idx(codec, 0x43, 0x9614); 454 } 455 456 static void alc256_init(struct hda_codec *codec) 457 { 458 struct alc_spec *spec = codec->spec; 459 hda_nid_t hp_pin = alc_get_hp_pin(spec); 460 bool hp_pin_sense; 461 462 if (spec->ultra_low_power) { 463 alc_update_coef_idx(codec, 0x03, 1<<1, 1<<1); 464 alc_update_coef_idx(codec, 0x08, 3<<2, 3<<2); 465 alc_update_coef_idx(codec, 0x08, 7<<4, 0); 466 alc_update_coef_idx(codec, 0x3b, 1<<15, 0); 467 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6); 468 msleep(30); 469 } 470 471 if (!hp_pin) 472 hp_pin = 0x21; 473 474 msleep(30); 475 476 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 477 478 if (hp_pin_sense) { 479 msleep(2); 480 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */ 481 482 snd_hda_codec_write(codec, hp_pin, 0, 483 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 484 485 msleep(75); 486 487 snd_hda_codec_write(codec, hp_pin, 0, 488 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 489 490 msleep(75); 491 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */ 492 } 493 alc_update_coef_idx(codec, 0x46, 3 << 12, 0); 494 alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15); /* Clear bit */ 495 alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15); 496 /* 497 * Expose headphone mic (or possibly Line In on some machines) instead 498 * of PC Beep on 1Ah, and disable 1Ah loopback for all outputs. See 499 * Documentation/sound/hd-audio/realtek-pc-beep.rst for details of 500 * this register. 501 */ 502 alc_write_coef_idx(codec, 0x36, 0x5757); 503 } 504 505 static void alc256_shutup(struct hda_codec *codec) 506 { 507 struct alc_spec *spec = codec->spec; 508 hda_nid_t hp_pin = alc_get_hp_pin(spec); 509 bool hp_pin_sense; 510 511 if (!hp_pin) 512 hp_pin = 0x21; 513 514 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */ 515 516 /* 3k pull low control for Headset jack. */ 517 /* NOTE: call this before clearing the pin, otherwise codec stalls */ 518 /* If disable 3k pulldown control for alc257, the Mic detection will not work correctly 519 * when booting with headset plugged. So skip setting it for the codec alc257 520 */ 521 if (spec->en_3kpull_low) 522 alc_update_coef_idx(codec, 0x46, 0, 3 << 12); 523 524 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 525 526 if (hp_pin_sense) { 527 msleep(2); 528 529 snd_hda_codec_write(codec, hp_pin, 0, 530 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 531 532 msleep(75); 533 534 if (!spec->no_shutup_pins) 535 snd_hda_codec_write(codec, hp_pin, 0, 536 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 537 538 msleep(75); 539 } 540 541 alc_auto_setup_eapd(codec, false); 542 alc_shutup_pins(codec); 543 if (spec->ultra_low_power) { 544 msleep(50); 545 alc_update_coef_idx(codec, 0x03, 1<<1, 0); 546 alc_update_coef_idx(codec, 0x08, 7<<4, 7<<4); 547 alc_update_coef_idx(codec, 0x08, 3<<2, 0); 548 alc_update_coef_idx(codec, 0x3b, 1<<15, 1<<15); 549 alc_update_coef_idx(codec, 0x0e, 7<<6, 0); 550 msleep(30); 551 } 552 } 553 554 static void alc285_hp_init(struct hda_codec *codec) 555 { 556 struct alc_spec *spec = codec->spec; 557 hda_nid_t hp_pin = alc_get_hp_pin(spec); 558 int i, val; 559 int coef38, coef0d, coef36; 560 561 alc_write_coefex_idx(codec, 0x58, 0x00, 0x1888); /* write default value */ 562 alc_update_coef_idx(codec, 0x4a, 1<<15, 1<<15); /* Reset HP JD */ 563 coef38 = alc_read_coef_idx(codec, 0x38); /* Amp control */ 564 coef0d = alc_read_coef_idx(codec, 0x0d); /* Digital Misc control */ 565 coef36 = alc_read_coef_idx(codec, 0x36); /* Passthrough Control */ 566 alc_update_coef_idx(codec, 0x38, 1<<4, 0x0); 567 alc_update_coef_idx(codec, 0x0d, 0x110, 0x0); 568 569 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000); 570 571 if (hp_pin) 572 snd_hda_codec_write(codec, hp_pin, 0, 573 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 574 575 msleep(130); 576 alc_update_coef_idx(codec, 0x36, 1<<14, 1<<14); 577 alc_update_coef_idx(codec, 0x36, 1<<13, 0x0); 578 579 if (hp_pin) 580 snd_hda_codec_write(codec, hp_pin, 0, 581 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 582 msleep(10); 583 alc_write_coef_idx(codec, 0x67, 0x0); /* Set HP depop to manual mode */ 584 alc_write_coefex_idx(codec, 0x58, 0x00, 0x7880); 585 alc_write_coefex_idx(codec, 0x58, 0x0f, 0xf049); 586 alc_update_coefex_idx(codec, 0x58, 0x03, 0x00f0, 0x00c0); 587 588 alc_write_coefex_idx(codec, 0x58, 0x00, 0xf888); /* HP depop procedure start */ 589 val = alc_read_coefex_idx(codec, 0x58, 0x00); 590 for (i = 0; i < 20 && val != -1 && val & 0x8000; i++) { 591 msleep(50); 592 val = alc_read_coefex_idx(codec, 0x58, 0x00); 593 } /* Wait for depop procedure finish */ 594 595 if (val != -1) 596 alc_write_coefex_idx(codec, 0x58, 0x00, val); /* write back the result */ 597 if (coef38 != -1) 598 alc_update_coef_idx(codec, 0x38, 1<<4, coef38); 599 if (coef0d != -1) 600 alc_update_coef_idx(codec, 0x0d, 0x110, coef0d); 601 if (coef36 != -1) 602 alc_update_coef_idx(codec, 0x36, 3<<13, coef36); 603 604 msleep(50); 605 alc_update_coef_idx(codec, 0x4a, 1<<15, 0); 606 } 607 608 static void alc225_init(struct hda_codec *codec) 609 { 610 struct alc_spec *spec = codec->spec; 611 hda_nid_t hp_pin = alc_get_hp_pin(spec); 612 bool hp1_pin_sense, hp2_pin_sense; 613 614 if (spec->ultra_low_power) { 615 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 3<<2); 616 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6); 617 alc_update_coef_idx(codec, 0x33, 1<<11, 0); 618 msleep(30); 619 } 620 621 if (spec->codec_variant != ALC269_TYPE_ALC287 && 622 spec->codec_variant != ALC269_TYPE_ALC245) 623 /* required only at boot or S3 and S4 resume time */ 624 if (!spec->done_hp_init || 625 is_s3_resume(codec) || 626 is_s4_resume(codec)) { 627 alc285_hp_init(codec); 628 spec->done_hp_init = true; 629 } 630 631 if (!hp_pin) 632 hp_pin = 0x21; 633 msleep(30); 634 635 hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin); 636 hp2_pin_sense = snd_hda_jack_detect(codec, 0x16); 637 638 if (hp1_pin_sense || hp2_pin_sense) { 639 msleep(2); 640 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */ 641 642 if (hp1_pin_sense) 643 snd_hda_codec_write(codec, hp_pin, 0, 644 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 645 if (hp2_pin_sense) 646 snd_hda_codec_write(codec, 0x16, 0, 647 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 648 msleep(75); 649 650 if (hp1_pin_sense) 651 snd_hda_codec_write(codec, hp_pin, 0, 652 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 653 if (hp2_pin_sense) 654 snd_hda_codec_write(codec, 0x16, 0, 655 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 656 657 msleep(75); 658 alc_update_coef_idx(codec, 0x4a, 3 << 10, 0); 659 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */ 660 } 661 } 662 663 static void alc225_shutup(struct hda_codec *codec) 664 { 665 struct alc_spec *spec = codec->spec; 666 hda_nid_t hp_pin = alc_get_hp_pin(spec); 667 bool hp1_pin_sense, hp2_pin_sense; 668 669 if (!hp_pin) 670 hp_pin = 0x21; 671 672 hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin); 673 hp2_pin_sense = snd_hda_jack_detect(codec, 0x16); 674 675 if (hp1_pin_sense || hp2_pin_sense) { 676 alc_disable_headset_jack_key(codec); 677 /* 3k pull low control for Headset jack. */ 678 alc_update_coef_idx(codec, 0x4a, 0, 3 << 10); 679 msleep(2); 680 681 if (hp1_pin_sense) 682 snd_hda_codec_write(codec, hp_pin, 0, 683 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 684 if (hp2_pin_sense) 685 snd_hda_codec_write(codec, 0x16, 0, 686 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 687 688 msleep(75); 689 690 if (hp1_pin_sense) 691 snd_hda_codec_write(codec, hp_pin, 0, 692 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 693 if (hp2_pin_sense) 694 snd_hda_codec_write(codec, 0x16, 0, 695 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 696 697 msleep(75); 698 alc_update_coef_idx(codec, 0x4a, 3 << 10, 0); 699 alc_enable_headset_jack_key(codec); 700 } 701 alc_auto_setup_eapd(codec, false); 702 alc_shutup_pins(codec); 703 if (spec->ultra_low_power) { 704 msleep(50); 705 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 0x0c << 2); 706 alc_update_coef_idx(codec, 0x0e, 7<<6, 0); 707 alc_update_coef_idx(codec, 0x33, 1<<11, 1<<11); 708 alc_update_coef_idx(codec, 0x4a, 3<<4, 2<<4); 709 msleep(30); 710 } 711 } 712 713 static void alc222_init(struct hda_codec *codec) 714 { 715 struct alc_spec *spec = codec->spec; 716 hda_nid_t hp_pin = alc_get_hp_pin(spec); 717 bool hp1_pin_sense, hp2_pin_sense; 718 719 if (!hp_pin) 720 return; 721 722 msleep(30); 723 724 hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin); 725 hp2_pin_sense = snd_hda_jack_detect(codec, 0x14); 726 727 if (hp1_pin_sense || hp2_pin_sense) { 728 msleep(2); 729 730 if (hp1_pin_sense) 731 snd_hda_codec_write(codec, hp_pin, 0, 732 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 733 if (hp2_pin_sense) 734 snd_hda_codec_write(codec, 0x14, 0, 735 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 736 msleep(75); 737 738 if (hp1_pin_sense) 739 snd_hda_codec_write(codec, hp_pin, 0, 740 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 741 if (hp2_pin_sense) 742 snd_hda_codec_write(codec, 0x14, 0, 743 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 744 745 msleep(75); 746 } 747 } 748 749 static void alc222_shutup(struct hda_codec *codec) 750 { 751 struct alc_spec *spec = codec->spec; 752 hda_nid_t hp_pin = alc_get_hp_pin(spec); 753 bool hp1_pin_sense, hp2_pin_sense; 754 755 if (!hp_pin) 756 hp_pin = 0x21; 757 758 hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin); 759 hp2_pin_sense = snd_hda_jack_detect(codec, 0x14); 760 761 if (hp1_pin_sense || hp2_pin_sense) { 762 msleep(2); 763 764 if (hp1_pin_sense) 765 snd_hda_codec_write(codec, hp_pin, 0, 766 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 767 if (hp2_pin_sense) 768 snd_hda_codec_write(codec, 0x14, 0, 769 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 770 771 msleep(75); 772 773 if (hp1_pin_sense) 774 snd_hda_codec_write(codec, hp_pin, 0, 775 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 776 if (hp2_pin_sense) 777 snd_hda_codec_write(codec, 0x14, 0, 778 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 779 780 msleep(75); 781 } 782 alc_auto_setup_eapd(codec, false); 783 alc_shutup_pins(codec); 784 } 785 786 static void alc_default_init(struct hda_codec *codec) 787 { 788 struct alc_spec *spec = codec->spec; 789 hda_nid_t hp_pin = alc_get_hp_pin(spec); 790 bool hp_pin_sense; 791 792 if (!hp_pin) 793 return; 794 795 msleep(30); 796 797 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 798 799 if (hp_pin_sense) { 800 msleep(2); 801 802 snd_hda_codec_write(codec, hp_pin, 0, 803 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 804 805 msleep(75); 806 807 snd_hda_codec_write(codec, hp_pin, 0, 808 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 809 msleep(75); 810 } 811 } 812 813 static void alc_default_shutup(struct hda_codec *codec) 814 { 815 struct alc_spec *spec = codec->spec; 816 hda_nid_t hp_pin = alc_get_hp_pin(spec); 817 bool hp_pin_sense; 818 819 if (!hp_pin) { 820 alc269_shutup(codec); 821 return; 822 } 823 824 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 825 826 if (hp_pin_sense) { 827 msleep(2); 828 829 snd_hda_codec_write(codec, hp_pin, 0, 830 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 831 832 msleep(75); 833 834 if (!spec->no_shutup_pins) 835 snd_hda_codec_write(codec, hp_pin, 0, 836 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 837 838 msleep(75); 839 } 840 alc_auto_setup_eapd(codec, false); 841 alc_shutup_pins(codec); 842 } 843 844 static void alc294_hp_init(struct hda_codec *codec) 845 { 846 struct alc_spec *spec = codec->spec; 847 hda_nid_t hp_pin = alc_get_hp_pin(spec); 848 int i, val; 849 850 if (!hp_pin) 851 return; 852 853 snd_hda_codec_write(codec, hp_pin, 0, 854 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 855 856 msleep(100); 857 858 if (!spec->no_shutup_pins) 859 snd_hda_codec_write(codec, hp_pin, 0, 860 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 861 862 alc_update_coef_idx(codec, 0x6f, 0x000f, 0);/* Set HP depop to manual mode */ 863 alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000); /* HP depop procedure start */ 864 865 /* Wait for depop procedure finish */ 866 val = alc_read_coefex_idx(codec, 0x58, 0x01); 867 for (i = 0; i < 20 && val != -1 && val & 0x0080; i++) { 868 msleep(50); 869 val = alc_read_coefex_idx(codec, 0x58, 0x01); 870 } 871 /* Set HP depop to auto mode */ 872 alc_update_coef_idx(codec, 0x6f, 0x000f, 0x000b); 873 msleep(50); 874 } 875 876 static void alc294_init(struct hda_codec *codec) 877 { 878 struct alc_spec *spec = codec->spec; 879 880 /* required only at boot or S4 resume time */ 881 if (!spec->done_hp_init || is_s4_resume(codec)) { 882 alc294_hp_init(codec); 883 spec->done_hp_init = true; 884 } 885 alc_default_init(codec); 886 } 887 888 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg, 889 unsigned int val) 890 { 891 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1); 892 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */ 893 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */ 894 } 895 896 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg) 897 { 898 unsigned int val; 899 900 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1); 901 val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0) 902 & 0xffff; 903 val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0) 904 << 16; 905 return val; 906 } 907 908 static void alc5505_dsp_halt(struct hda_codec *codec) 909 { 910 unsigned int val; 911 912 alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */ 913 alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */ 914 alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */ 915 alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */ 916 alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */ 917 alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */ 918 alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */ 919 val = alc5505_coef_get(codec, 0x6220); 920 alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */ 921 } 922 923 static void alc5505_dsp_back_from_halt(struct hda_codec *codec) 924 { 925 alc5505_coef_set(codec, 0x61b8, 0x04133302); 926 alc5505_coef_set(codec, 0x61b0, 0x00005b16); 927 alc5505_coef_set(codec, 0x61b4, 0x040a2b02); 928 alc5505_coef_set(codec, 0x6230, 0xf80d4011); 929 alc5505_coef_set(codec, 0x6220, 0x2002010f); 930 alc5505_coef_set(codec, 0x880c, 0x00000004); 931 } 932 933 static void alc5505_dsp_init(struct hda_codec *codec) 934 { 935 unsigned int val; 936 937 alc5505_dsp_halt(codec); 938 alc5505_dsp_back_from_halt(codec); 939 alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */ 940 alc5505_coef_set(codec, 0x61b0, 0x5b16); 941 alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */ 942 alc5505_coef_set(codec, 0x61b4, 0x04132b02); 943 alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/ 944 alc5505_coef_set(codec, 0x61b8, 0x041f3302); 945 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */ 946 alc5505_coef_set(codec, 0x61b8, 0x041b3302); 947 alc5505_coef_set(codec, 0x61b8, 0x04173302); 948 alc5505_coef_set(codec, 0x61b8, 0x04163302); 949 alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */ 950 alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */ 951 alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */ 952 953 val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */ 954 if (val <= 3) 955 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */ 956 else 957 alc5505_coef_set(codec, 0x6220, 0x6002018f); 958 959 alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/ 960 alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */ 961 alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */ 962 alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */ 963 alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */ 964 alc5505_coef_set(codec, 0x880c, 0x00000003); 965 alc5505_coef_set(codec, 0x880c, 0x00000010); 966 967 #ifdef HALT_REALTEK_ALC5505 968 alc5505_dsp_halt(codec); 969 #endif 970 } 971 972 #ifdef HALT_REALTEK_ALC5505 973 #define alc5505_dsp_suspend(codec) do { } while (0) /* NOP */ 974 #define alc5505_dsp_resume(codec) do { } while (0) /* NOP */ 975 #else 976 #define alc5505_dsp_suspend(codec) alc5505_dsp_halt(codec) 977 #define alc5505_dsp_resume(codec) alc5505_dsp_back_from_halt(codec) 978 #endif 979 980 static int alc269_suspend(struct hda_codec *codec) 981 { 982 struct alc_spec *spec = codec->spec; 983 984 if (spec->has_alc5505_dsp) 985 alc5505_dsp_suspend(codec); 986 987 return alc_suspend(codec); 988 } 989 990 static int alc269_resume(struct hda_codec *codec) 991 { 992 struct alc_spec *spec = codec->spec; 993 994 if (spec->codec_variant == ALC269_TYPE_ALC269VB) 995 alc269vb_toggle_power_output(codec, 0); 996 if (spec->codec_variant == ALC269_TYPE_ALC269VB && 997 (alc_get_coef0(codec) & 0x00ff) == 0x018) { 998 msleep(150); 999 } 1000 1001 snd_hda_codec_init(codec); 1002 1003 if (spec->codec_variant == ALC269_TYPE_ALC269VB) 1004 alc269vb_toggle_power_output(codec, 1); 1005 if (spec->codec_variant == ALC269_TYPE_ALC269VB && 1006 (alc_get_coef0(codec) & 0x00ff) == 0x017) { 1007 msleep(200); 1008 } 1009 1010 snd_hda_regmap_sync(codec); 1011 hda_call_check_power_status(codec, 0x01); 1012 1013 if (spec->has_alc5505_dsp) 1014 alc5505_dsp_resume(codec); 1015 1016 return 0; 1017 } 1018 1019 #define ALC233_STARFIGHTER_SPK_PIN 0x1b 1020 #define ALC233_STARFIGHTER_GPIO2 0x04 1021 1022 static void alc233_starfighter_update_amp(struct hda_codec *codec, bool on) 1023 { 1024 snd_hda_codec_write(codec, ALC233_STARFIGHTER_SPK_PIN, 0, 1025 AC_VERB_SET_EAPD_BTLENABLE, 1026 on ? AC_EAPDBTL_EAPD : 0); 1027 alc_update_gpio_data(codec, ALC233_STARFIGHTER_GPIO2, on); 1028 } 1029 1030 static void alc233_starfighter_pcm_hook(struct hda_pcm_stream *hinfo, 1031 struct hda_codec *codec, 1032 struct snd_pcm_substream *substream, 1033 int action) 1034 { 1035 switch (action) { 1036 case HDA_GEN_PCM_ACT_PREPARE: 1037 alc233_starfighter_update_amp(codec, true); 1038 break; 1039 case HDA_GEN_PCM_ACT_CLEANUP: 1040 alc233_starfighter_update_amp(codec, false); 1041 break; 1042 } 1043 } 1044 1045 static void alc233_fixup_starlabs_starfighter(struct hda_codec *codec, 1046 const struct hda_fixup *fix, 1047 int action) 1048 { 1049 struct alc_spec *spec = codec->spec; 1050 1051 switch (action) { 1052 case HDA_FIXUP_ACT_PRE_PROBE: 1053 spec->gpio_mask |= ALC233_STARFIGHTER_GPIO2; 1054 spec->gpio_dir |= ALC233_STARFIGHTER_GPIO2; 1055 spec->gpio_data &= ~ALC233_STARFIGHTER_GPIO2; 1056 break; 1057 case HDA_FIXUP_ACT_PROBE: 1058 spec->gen.pcm_playback_hook = alc233_starfighter_pcm_hook; 1059 break; 1060 } 1061 } 1062 1063 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec, 1064 const struct hda_fixup *fix, int action) 1065 { 1066 struct alc_spec *spec = codec->spec; 1067 1068 if (action == HDA_FIXUP_ACT_PRE_PROBE) 1069 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 1070 } 1071 1072 static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec, 1073 const struct hda_fixup *fix, 1074 int action) 1075 { 1076 unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21); 1077 unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19); 1078 1079 if (cfg_headphone && cfg_headset_mic == 0x411111f0) 1080 snd_hda_codec_set_pincfg(codec, 0x19, 1081 (cfg_headphone & ~AC_DEFCFG_DEVICE) | 1082 (AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT)); 1083 } 1084 1085 static void alc269_fixup_hweq(struct hda_codec *codec, 1086 const struct hda_fixup *fix, int action) 1087 { 1088 if (action == HDA_FIXUP_ACT_INIT) 1089 alc_update_coef_idx(codec, 0x1e, 0, 0x80); 1090 } 1091 1092 static void alc271_fixup_dmic(struct hda_codec *codec, 1093 const struct hda_fixup *fix, int action) 1094 { 1095 static const struct hda_verb verbs[] = { 1096 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d}, 1097 {0x20, AC_VERB_SET_PROC_COEF, 0x4000}, 1098 {} 1099 }; 1100 unsigned int cfg; 1101 1102 if (strcmp(codec->core.chip_name, "ALC271X") && 1103 strcmp(codec->core.chip_name, "ALC269VB")) 1104 return; 1105 cfg = snd_hda_codec_get_pincfg(codec, 0x12); 1106 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED) 1107 snd_hda_sequence_write(codec, verbs); 1108 } 1109 1110 /* Fix the speaker amp after resume, etc */ 1111 static void alc269vb_fixup_aspire_e1_coef(struct hda_codec *codec, 1112 const struct hda_fixup *fix, 1113 int action) 1114 { 1115 if (action == HDA_FIXUP_ACT_INIT) 1116 alc_update_coef_idx(codec, 0x0d, 0x6000, 0x6000); 1117 } 1118 1119 static void alc269_fixup_pcm_44k(struct hda_codec *codec, 1120 const struct hda_fixup *fix, int action) 1121 { 1122 struct alc_spec *spec = codec->spec; 1123 1124 if (action != HDA_FIXUP_ACT_PROBE) 1125 return; 1126 1127 /* Due to a hardware problem on Lenovo Ideadpad, we need to 1128 * fix the sample rate of analog I/O to 44.1kHz 1129 */ 1130 spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback; 1131 spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture; 1132 } 1133 1134 static void alc269_fixup_stereo_dmic(struct hda_codec *codec, 1135 const struct hda_fixup *fix, int action) 1136 { 1137 /* The digital-mic unit sends PDM (differential signal) instead of 1138 * the standard PCM, thus you can't record a valid mono stream as is. 1139 * Below is a workaround specific to ALC269 to control the dmic 1140 * signal source as mono. 1141 */ 1142 if (action == HDA_FIXUP_ACT_INIT) 1143 alc_update_coef_idx(codec, 0x07, 0, 0x80); 1144 } 1145 1146 static void alc269_quanta_automute(struct hda_codec *codec) 1147 { 1148 snd_hda_gen_update_outputs(codec); 1149 1150 alc_write_coef_idx(codec, 0x0c, 0x680); 1151 alc_write_coef_idx(codec, 0x0c, 0x480); 1152 } 1153 1154 static void alc269_fixup_quanta_mute(struct hda_codec *codec, 1155 const struct hda_fixup *fix, int action) 1156 { 1157 struct alc_spec *spec = codec->spec; 1158 if (action != HDA_FIXUP_ACT_PROBE) 1159 return; 1160 spec->gen.automute_hook = alc269_quanta_automute; 1161 } 1162 1163 static void alc269_x101_hp_automute_hook(struct hda_codec *codec, 1164 struct hda_jack_callback *jack) 1165 { 1166 struct alc_spec *spec = codec->spec; 1167 int vref; 1168 msleep(200); 1169 snd_hda_gen_hp_automute(codec, jack); 1170 1171 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0; 1172 msleep(100); 1173 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 1174 vref); 1175 msleep(500); 1176 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 1177 vref); 1178 } 1179 1180 /* 1181 * Magic sequence to make Huawei Matebook X right speaker working (bko#197801) 1182 */ 1183 struct hda_alc298_mbxinit { 1184 unsigned char value_0x23; 1185 unsigned char value_0x25; 1186 }; 1187 1188 static void alc298_huawei_mbx_stereo_seq(struct hda_codec *codec, 1189 const struct hda_alc298_mbxinit *initval, 1190 bool first) 1191 { 1192 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x0); 1193 alc_write_coef_idx(codec, 0x26, 0xb000); 1194 1195 if (first) 1196 snd_hda_codec_write(codec, 0x21, 0, AC_VERB_GET_PIN_SENSE, 0x0); 1197 1198 snd_hda_codec_write(codec, 0x6, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80); 1199 alc_write_coef_idx(codec, 0x26, 0xf000); 1200 alc_write_coef_idx(codec, 0x23, initval->value_0x23); 1201 1202 if (initval->value_0x23 != 0x1e) 1203 alc_write_coef_idx(codec, 0x25, initval->value_0x25); 1204 1205 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26); 1206 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010); 1207 } 1208 1209 static void alc298_fixup_huawei_mbx_stereo(struct hda_codec *codec, 1210 const struct hda_fixup *fix, 1211 int action) 1212 { 1213 /* Initialization magic */ 1214 static const struct hda_alc298_mbxinit dac_init[] = { 1215 {0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00}, 1216 {0x10, 0x00}, {0x1a, 0x40}, {0x1b, 0x82}, {0x1c, 0x00}, 1217 {0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00}, 1218 {0x20, 0xc2}, {0x21, 0xc8}, {0x22, 0x26}, {0x23, 0x24}, 1219 {0x27, 0xff}, {0x28, 0xff}, {0x29, 0xff}, {0x2a, 0x8f}, 1220 {0x2b, 0x02}, {0x2c, 0x48}, {0x2d, 0x34}, {0x2e, 0x00}, 1221 {0x2f, 0x00}, 1222 {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00}, 1223 {0x34, 0x00}, {0x35, 0x01}, {0x36, 0x93}, {0x37, 0x0c}, 1224 {0x38, 0x00}, {0x39, 0x00}, {0x3a, 0xf8}, {0x38, 0x80}, 1225 {} 1226 }; 1227 const struct hda_alc298_mbxinit *seq; 1228 1229 if (action != HDA_FIXUP_ACT_INIT) 1230 return; 1231 1232 /* Start */ 1233 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x00); 1234 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80); 1235 alc_write_coef_idx(codec, 0x26, 0xf000); 1236 alc_write_coef_idx(codec, 0x22, 0x31); 1237 alc_write_coef_idx(codec, 0x23, 0x0b); 1238 alc_write_coef_idx(codec, 0x25, 0x00); 1239 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26); 1240 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010); 1241 1242 for (seq = dac_init; seq->value_0x23; seq++) 1243 alc298_huawei_mbx_stereo_seq(codec, seq, seq == dac_init); 1244 } 1245 1246 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec, 1247 const struct hda_fixup *fix, int action) 1248 { 1249 struct alc_spec *spec = codec->spec; 1250 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1251 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 1252 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook; 1253 } 1254 } 1255 1256 static void alc_update_vref_led(struct hda_codec *codec, hda_nid_t pin, 1257 bool polarity, bool on) 1258 { 1259 unsigned int pinval; 1260 1261 if (!pin) 1262 return; 1263 if (polarity) 1264 on = !on; 1265 pinval = snd_hda_codec_get_pin_target(codec, pin); 1266 pinval &= ~AC_PINCTL_VREFEN; 1267 pinval |= on ? AC_PINCTL_VREF_80 : AC_PINCTL_VREF_HIZ; 1268 /* temporarily power up/down for setting VREF */ 1269 CLASS(snd_hda_power_pm, pm)(codec); 1270 snd_hda_set_pin_ctl_cache(codec, pin, pinval); 1271 } 1272 1273 /* update mute-LED according to the speaker mute state via mic VREF pin */ 1274 static int vref_mute_led_set(struct led_classdev *led_cdev, 1275 enum led_brightness brightness) 1276 { 1277 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 1278 struct alc_spec *spec = codec->spec; 1279 1280 alc_update_vref_led(codec, spec->mute_led_nid, 1281 spec->mute_led_polarity, brightness); 1282 return 0; 1283 } 1284 1285 /* Make sure the led works even in runtime suspend */ 1286 static unsigned int led_power_filter(struct hda_codec *codec, 1287 hda_nid_t nid, 1288 unsigned int power_state) 1289 { 1290 struct alc_spec *spec = codec->spec; 1291 1292 if (power_state != AC_PWRST_D3 || nid == 0 || 1293 (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid)) 1294 return power_state; 1295 1296 /* Set pin ctl again, it might have just been set to 0 */ 1297 snd_hda_set_pin_ctl(codec, nid, 1298 snd_hda_codec_get_pin_target(codec, nid)); 1299 1300 return snd_hda_gen_path_power_filter(codec, nid, power_state); 1301 } 1302 1303 static void alc269_fixup_hp_mute_led(struct hda_codec *codec, 1304 const struct hda_fixup *fix, int action) 1305 { 1306 struct alc_spec *spec = codec->spec; 1307 const struct dmi_device *dev = NULL; 1308 1309 if (action != HDA_FIXUP_ACT_PRE_PROBE) 1310 return; 1311 1312 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) { 1313 int pol, pin; 1314 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2) 1315 continue; 1316 if (pin < 0x0a || pin >= 0x10) 1317 break; 1318 spec->mute_led_polarity = pol; 1319 spec->mute_led_nid = pin - 0x0a + 0x18; 1320 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set); 1321 codec->power_filter = led_power_filter; 1322 codec_dbg(codec, 1323 "Detected mute LED for %x:%d\n", spec->mute_led_nid, 1324 spec->mute_led_polarity); 1325 break; 1326 } 1327 } 1328 1329 static void alc269_fixup_hp_mute_led_micx(struct hda_codec *codec, 1330 const struct hda_fixup *fix, 1331 int action, hda_nid_t pin) 1332 { 1333 struct alc_spec *spec = codec->spec; 1334 1335 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1336 spec->mute_led_polarity = 0; 1337 spec->mute_led_nid = pin; 1338 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set); 1339 codec->power_filter = led_power_filter; 1340 } 1341 } 1342 1343 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec, 1344 const struct hda_fixup *fix, int action) 1345 { 1346 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x18); 1347 } 1348 1349 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec, 1350 const struct hda_fixup *fix, int action) 1351 { 1352 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x19); 1353 } 1354 1355 static void alc269_fixup_hp_mute_led_mic3(struct hda_codec *codec, 1356 const struct hda_fixup *fix, int action) 1357 { 1358 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1b); 1359 } 1360 1361 static void alc236_fixup_hp_gpio_led(struct hda_codec *codec, 1362 const struct hda_fixup *fix, int action) 1363 { 1364 alc_fixup_hp_gpio_led(codec, action, 0x02, 0x01); 1365 } 1366 1367 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec, 1368 const struct hda_fixup *fix, int action) 1369 { 1370 alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10); 1371 } 1372 1373 /* 1374 * HP Laptop 15-fd0xxx (SSID 103c:8bb6) Speaker Mute LED fix 1375 * 1376 * The speaker mute LED is controlled via VREF100 on NID 0x1a. 1377 * This pin must remain powered (D0) even during suspend, otherwise 1378 * the LED state is lost and the pin defaults to Hi-Z on resume, 1379 * causing the LED to stop responding to mute toggles. 1380 * Windows keeps this pin powered unconditionally, so matching that 1381 * behavior ensures consistent LED operation across suspend/resume. 1382 * The mic-mute LED is controlled via GPIO 0 with active-low polarity. 1383 */ 1384 static unsigned int hp_8bb6_power_filter(struct hda_codec *codec, 1385 hda_nid_t nid, 1386 unsigned int power_state) 1387 { 1388 if (nid == 0x1a) 1389 return AC_PWRST_D0; 1390 return snd_hda_gen_path_power_filter(codec, nid, power_state); 1391 } 1392 1393 static int hp_8bb6_speaker_mute_led_set(struct led_classdev *led_cdev, 1394 enum led_brightness brightness) 1395 { 1396 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 1397 unsigned int val = (brightness == LED_OFF) ? PIN_IN : PIN_VREF100; 1398 1399 snd_hda_set_pin_ctl_cache(codec, 0x1a, val); 1400 return 0; 1401 } 1402 1403 static void alc236_fixup_hp_15_fd0xxx(struct hda_codec *codec, 1404 const struct hda_fixup *fix, 1405 int action) 1406 { 1407 struct alc_spec *spec = codec->spec; 1408 1409 switch (action) { 1410 case HDA_FIXUP_ACT_PRE_PROBE: 1411 spec->micmute_led_polarity = 1; 1412 alc_fixup_hp_gpio_led(codec, action, 0x00, 0x01); 1413 1414 spec->mute_led_polarity = 0; 1415 snd_hda_gen_add_mute_led_cdev(codec, hp_8bb6_speaker_mute_led_set); 1416 1417 codec->power_filter = hp_8bb6_power_filter; 1418 spec->no_shutup_pins = 1; 1419 break; 1420 1421 case HDA_FIXUP_ACT_INIT: 1422 if (spec->gen.vmaster_mute.hook) 1423 snd_hda_sync_vmaster_hook(&spec->gen.vmaster_mute); 1424 break; 1425 } 1426 } 1427 1428 static void alc285_fixup_hp_gpio_led(struct hda_codec *codec, 1429 const struct hda_fixup *fix, int action) 1430 { 1431 alc_fixup_hp_gpio_led(codec, action, 0x04, 0x01); 1432 } 1433 1434 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec, 1435 const struct hda_fixup *fix, int action) 1436 { 1437 alc_fixup_hp_gpio_led(codec, action, 0x02, 0x20); 1438 } 1439 1440 static void alc287_fixup_hp_gpio_led(struct hda_codec *codec, 1441 const struct hda_fixup *fix, int action) 1442 { 1443 alc_fixup_hp_gpio_led(codec, action, 0x10, 0); 1444 } 1445 1446 static void alc245_fixup_hp_gpio_led(struct hda_codec *codec, 1447 const struct hda_fixup *fix, int action) 1448 { 1449 struct alc_spec *spec = codec->spec; 1450 1451 if (action == HDA_FIXUP_ACT_PRE_PROBE) 1452 spec->micmute_led_polarity = 1; 1453 alc_fixup_hp_gpio_led(codec, action, 0, 0x04); 1454 } 1455 1456 static void alc245_fixup_minisforum_jack_detect(struct hda_codec *codec, 1457 const struct hda_fixup *fix, 1458 int action) 1459 { 1460 if (action == HDA_FIXUP_ACT_INIT) 1461 /* Clear Reset HP JD while preserving the other coefficient bits. */ 1462 alc_update_coef_idx(codec, 0x4a, BIT(15), 0); 1463 } 1464 1465 /* turn on/off mic-mute LED per capture hook via VREF change */ 1466 static int vref_micmute_led_set(struct led_classdev *led_cdev, 1467 enum led_brightness brightness) 1468 { 1469 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 1470 struct alc_spec *spec = codec->spec; 1471 1472 alc_update_vref_led(codec, spec->cap_mute_led_nid, 1473 spec->micmute_led_polarity, brightness); 1474 return 0; 1475 } 1476 1477 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec, 1478 const struct hda_fixup *fix, int action) 1479 { 1480 struct alc_spec *spec = codec->spec; 1481 1482 alc_fixup_hp_gpio_led(codec, action, 0x08, 0); 1483 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1484 /* Like hp_gpio_mic1_led, but also needs GPIO4 low to 1485 * enable headphone amp 1486 */ 1487 spec->gpio_mask |= 0x10; 1488 spec->gpio_dir |= 0x10; 1489 spec->cap_mute_led_nid = 0x18; 1490 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set); 1491 codec->power_filter = led_power_filter; 1492 } 1493 } 1494 1495 static void alc280_fixup_hp_gpio4(struct hda_codec *codec, 1496 const struct hda_fixup *fix, int action) 1497 { 1498 struct alc_spec *spec = codec->spec; 1499 1500 alc_fixup_hp_gpio_led(codec, action, 0x08, 0); 1501 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1502 spec->cap_mute_led_nid = 0x18; 1503 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set); 1504 codec->power_filter = led_power_filter; 1505 } 1506 } 1507 1508 /* HP Spectre x360 14 model needs a unique workaround for enabling the amp; 1509 * it needs to toggle the GPIO0 once on and off at each time (bko#210633) 1510 */ 1511 static void alc245_fixup_hp_x360_amp(struct hda_codec *codec, 1512 const struct hda_fixup *fix, int action) 1513 { 1514 struct alc_spec *spec = codec->spec; 1515 1516 switch (action) { 1517 case HDA_FIXUP_ACT_PRE_PROBE: 1518 spec->gpio_mask |= 0x01; 1519 spec->gpio_dir |= 0x01; 1520 break; 1521 case HDA_FIXUP_ACT_INIT: 1522 /* need to toggle GPIO to enable the amp */ 1523 alc_update_gpio_data(codec, 0x01, true); 1524 msleep(100); 1525 alc_update_gpio_data(codec, 0x01, false); 1526 break; 1527 } 1528 } 1529 1530 /* toggle GPIO2 at each time stream is started; we use PREPARE state instead */ 1531 static void alc274_hp_envy_pcm_hook(struct hda_pcm_stream *hinfo, 1532 struct hda_codec *codec, 1533 struct snd_pcm_substream *substream, 1534 int action) 1535 { 1536 switch (action) { 1537 case HDA_GEN_PCM_ACT_PREPARE: 1538 alc_update_gpio_data(codec, 0x04, true); 1539 break; 1540 case HDA_GEN_PCM_ACT_CLEANUP: 1541 alc_update_gpio_data(codec, 0x04, false); 1542 break; 1543 } 1544 } 1545 1546 static void alc274_fixup_hp_envy_gpio(struct hda_codec *codec, 1547 const struct hda_fixup *fix, 1548 int action) 1549 { 1550 struct alc_spec *spec = codec->spec; 1551 1552 if (action == HDA_FIXUP_ACT_PROBE) { 1553 spec->gpio_mask |= 0x04; 1554 spec->gpio_dir |= 0x04; 1555 spec->gen.pcm_playback_hook = alc274_hp_envy_pcm_hook; 1556 } 1557 } 1558 1559 static void alc_update_coef_led(struct hda_codec *codec, 1560 struct alc_coef_led *led, 1561 bool polarity, bool on) 1562 { 1563 if (polarity) 1564 on = !on; 1565 /* temporarily power up/down for setting COEF bit */ 1566 alc_update_coef_idx(codec, led->idx, led->mask, 1567 on ? led->on : led->off); 1568 } 1569 1570 /* update mute-LED according to the speaker mute state via COEF bit */ 1571 static int coef_mute_led_set(struct led_classdev *led_cdev, 1572 enum led_brightness brightness) 1573 { 1574 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 1575 struct alc_spec *spec = codec->spec; 1576 1577 alc_update_coef_led(codec, &spec->mute_led_coef, 1578 spec->mute_led_polarity, brightness); 1579 return 0; 1580 } 1581 1582 static void alc285_fixup_hp_mute_led_coefbit(struct hda_codec *codec, 1583 const struct hda_fixup *fix, 1584 int action) 1585 { 1586 struct alc_spec *spec = codec->spec; 1587 1588 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1589 spec->mute_led_polarity = 0; 1590 spec->mute_led_coef.idx = 0x0b; 1591 spec->mute_led_coef.mask = 1 << 3; 1592 spec->mute_led_coef.on = 1 << 3; 1593 spec->mute_led_coef.off = 0; 1594 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set); 1595 } 1596 } 1597 1598 static void alc236_fixup_hp_mute_led_coefbit(struct hda_codec *codec, 1599 const struct hda_fixup *fix, 1600 int action) 1601 { 1602 struct alc_spec *spec = codec->spec; 1603 1604 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1605 spec->mute_led_polarity = 0; 1606 spec->mute_led_coef.idx = 0x34; 1607 spec->mute_led_coef.mask = 1 << 5; 1608 spec->mute_led_coef.on = 0; 1609 spec->mute_led_coef.off = 1 << 5; 1610 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set); 1611 } 1612 } 1613 1614 static void alc236_fixup_hp_mute_led_coefbit2(struct hda_codec *codec, 1615 const struct hda_fixup *fix, int action) 1616 { 1617 struct alc_spec *spec = codec->spec; 1618 1619 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1620 spec->mute_led_polarity = 0; 1621 spec->mute_led_coef.idx = 0x07; 1622 spec->mute_led_coef.mask = 1; 1623 spec->mute_led_coef.on = 1; 1624 spec->mute_led_coef.off = 0; 1625 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set); 1626 } 1627 } 1628 1629 static void alc245_fixup_hp_mute_led_coefbit(struct hda_codec *codec, 1630 const struct hda_fixup *fix, 1631 int action) 1632 { 1633 struct alc_spec *spec = codec->spec; 1634 1635 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1636 spec->mute_led_polarity = 0; 1637 spec->mute_led_coef.idx = 0x0b; 1638 spec->mute_led_coef.mask = 3 << 2; 1639 spec->mute_led_coef.on = 2 << 2; 1640 spec->mute_led_coef.off = 1 << 2; 1641 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set); 1642 } 1643 } 1644 1645 static void alc245_fixup_hp_mute_led_v1_coefbit(struct hda_codec *codec, 1646 const struct hda_fixup *fix, 1647 int action) 1648 { 1649 struct alc_spec *spec = codec->spec; 1650 1651 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1652 spec->mute_led_polarity = 0; 1653 spec->mute_led_coef.idx = 0x0b; 1654 spec->mute_led_coef.mask = 3 << 2; 1655 spec->mute_led_coef.on = 1 << 3; 1656 spec->mute_led_coef.off = 0; 1657 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set); 1658 } 1659 } 1660 1661 static void alc245_fixup_hp_mute_led_v2_coefbit(struct hda_codec *codec, 1662 const struct hda_fixup *fix, 1663 int action) 1664 { 1665 struct alc_spec *spec = codec->spec; 1666 1667 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1668 spec->mute_led_polarity = 0; 1669 spec->mute_led_coef.idx = 0x0b; 1670 spec->mute_led_coef.mask = 1 << 3; 1671 spec->mute_led_coef.on = 1 << 3; 1672 spec->mute_led_coef.off = 0; 1673 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set); 1674 } 1675 } 1676 1677 /* turn on/off mic-mute LED per capture hook by coef bit */ 1678 static int coef_micmute_led_set(struct led_classdev *led_cdev, 1679 enum led_brightness brightness) 1680 { 1681 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 1682 struct alc_spec *spec = codec->spec; 1683 1684 alc_update_coef_led(codec, &spec->mic_led_coef, 1685 spec->micmute_led_polarity, brightness); 1686 return 0; 1687 } 1688 1689 static void alc285_fixup_hp_coef_micmute_led(struct hda_codec *codec, 1690 const struct hda_fixup *fix, int action) 1691 { 1692 struct alc_spec *spec = codec->spec; 1693 1694 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1695 spec->mic_led_coef.idx = 0x19; 1696 spec->mic_led_coef.mask = 1 << 13; 1697 spec->mic_led_coef.on = 1 << 13; 1698 spec->mic_led_coef.off = 0; 1699 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set); 1700 } 1701 } 1702 1703 static void alc285_fixup_hp_gpio_micmute_led(struct hda_codec *codec, 1704 const struct hda_fixup *fix, int action) 1705 { 1706 struct alc_spec *spec = codec->spec; 1707 1708 if (action == HDA_FIXUP_ACT_PRE_PROBE) 1709 spec->micmute_led_polarity = 1; 1710 alc_fixup_hp_gpio_led(codec, action, 0, 0x04); 1711 } 1712 1713 static void alc236_fixup_hp_coef_micmute_led(struct hda_codec *codec, 1714 const struct hda_fixup *fix, int action) 1715 { 1716 struct alc_spec *spec = codec->spec; 1717 1718 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1719 spec->mic_led_coef.idx = 0x35; 1720 spec->mic_led_coef.mask = 3 << 2; 1721 spec->mic_led_coef.on = 2 << 2; 1722 spec->mic_led_coef.off = 1 << 2; 1723 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set); 1724 } 1725 } 1726 1727 static void alc295_fixup_hp_mute_led_coefbit11(struct hda_codec *codec, 1728 const struct hda_fixup *fix, int action) 1729 { 1730 struct alc_spec *spec = codec->spec; 1731 1732 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1733 spec->mute_led_polarity = 0; 1734 spec->mute_led_coef.idx = 0xb; 1735 spec->mute_led_coef.mask = 3 << 3; 1736 spec->mute_led_coef.on = 1 << 3; 1737 spec->mute_led_coef.off = 1 << 4; 1738 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set); 1739 } 1740 } 1741 1742 /* Override wrong pin to NID 0x1b (F.32 BIOS reports 0x18 via DMI OEM string) 1743 * on HP pavilion 15-cs1xxx laptops 1744 */ 1745 static void alc295_fixup_hp_pavilion_mute_led_1b(struct hda_codec *codec, 1746 const struct hda_fixup *fix, 1747 int action) 1748 { 1749 struct alc_spec *spec = codec->spec; 1750 1751 alc269_fixup_hp_mute_led(codec, fix, action); 1752 1753 if (action == HDA_FIXUP_ACT_PRE_PROBE) 1754 spec->mute_led_nid = 0x1b; 1755 } 1756 1757 static void alc233_fixup_lenovo_coef_micmute_led(struct hda_codec *codec, 1758 const struct hda_fixup *fix, int action) 1759 { 1760 struct alc_spec *spec = codec->spec; 1761 1762 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1763 spec->mic_led_coef.idx = 0x10; 1764 spec->mic_led_coef.mask = 1 << 13; 1765 spec->mic_led_coef.on = 0; 1766 spec->mic_led_coef.off = 1 << 13; 1767 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set); 1768 } 1769 } 1770 1771 static void alc285_fixup_hp_mute_led(struct hda_codec *codec, 1772 const struct hda_fixup *fix, int action) 1773 { 1774 alc285_fixup_hp_mute_led_coefbit(codec, fix, action); 1775 alc285_fixup_hp_coef_micmute_led(codec, fix, action); 1776 } 1777 1778 static void alc285_fixup_hp_spectre_x360_mute_led(struct hda_codec *codec, 1779 const struct hda_fixup *fix, int action) 1780 { 1781 alc285_fixup_hp_mute_led_coefbit(codec, fix, action); 1782 alc285_fixup_hp_gpio_micmute_led(codec, fix, action); 1783 } 1784 1785 static void alc245_fixup_hp_envy_x360_mute_led(struct hda_codec *codec, 1786 const struct hda_fixup *fix, int action) 1787 { 1788 alc245_fixup_hp_mute_led_v1_coefbit(codec, fix, action); 1789 alc245_fixup_hp_gpio_led(codec, fix, action); 1790 } 1791 1792 static void alc236_fixup_hp_mute_led(struct hda_codec *codec, 1793 const struct hda_fixup *fix, int action) 1794 { 1795 alc236_fixup_hp_mute_led_coefbit(codec, fix, action); 1796 alc236_fixup_hp_coef_micmute_led(codec, fix, action); 1797 } 1798 1799 static void alc236_fixup_hp_micmute_led_vref(struct hda_codec *codec, 1800 const struct hda_fixup *fix, int action) 1801 { 1802 struct alc_spec *spec = codec->spec; 1803 1804 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1805 spec->cap_mute_led_nid = 0x1a; 1806 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set); 1807 codec->power_filter = led_power_filter; 1808 } 1809 } 1810 1811 static void alc236_fixup_hp_mute_led_micmute_vref(struct hda_codec *codec, 1812 const struct hda_fixup *fix, int action) 1813 { 1814 alc236_fixup_hp_mute_led_coefbit(codec, fix, action); 1815 alc236_fixup_hp_micmute_led_vref(codec, fix, action); 1816 } 1817 1818 static void alc236_fixup_hp_mute_led_micmute_gpio(struct hda_codec *codec, 1819 const struct hda_fixup *fix, int action) 1820 { 1821 struct alc_spec *spec = codec->spec; 1822 1823 if (action == HDA_FIXUP_ACT_PRE_PROBE) 1824 spec->micmute_led_polarity = 1; 1825 1826 alc236_fixup_hp_mute_led_coefbit2(codec, fix, action); 1827 alc_fixup_hp_gpio_led(codec, action, 0x00, 0x01); 1828 } 1829 1830 static inline void alc298_samsung_write_coef_pack(struct hda_codec *codec, 1831 const unsigned short coefs[2]) 1832 { 1833 alc_write_coef_idx(codec, 0x23, coefs[0]); 1834 alc_write_coef_idx(codec, 0x25, coefs[1]); 1835 alc_write_coef_idx(codec, 0x26, 0xb011); 1836 } 1837 1838 struct alc298_samsung_amp_desc { 1839 unsigned char nid; 1840 unsigned short init_seq[2][2]; 1841 }; 1842 1843 static void alc298_fixup_samsung_amp(struct hda_codec *codec, 1844 const struct hda_fixup *fix, int action) 1845 { 1846 int i, j; 1847 static const unsigned short init_seq[][2] = { 1848 { 0x19, 0x00 }, { 0x20, 0xc0 }, { 0x22, 0x44 }, { 0x23, 0x08 }, 1849 { 0x24, 0x85 }, { 0x25, 0x41 }, { 0x35, 0x40 }, { 0x36, 0x01 }, 1850 { 0x38, 0x81 }, { 0x3a, 0x03 }, { 0x3b, 0x81 }, { 0x40, 0x3e }, 1851 { 0x41, 0x07 }, { 0x400, 0x1 } 1852 }; 1853 static const struct alc298_samsung_amp_desc amps[] = { 1854 { 0x3a, { { 0x18, 0x1 }, { 0x26, 0x0 } } }, 1855 { 0x39, { { 0x18, 0x2 }, { 0x26, 0x1 } } } 1856 }; 1857 1858 if (action != HDA_FIXUP_ACT_INIT) 1859 return; 1860 1861 for (i = 0; i < ARRAY_SIZE(amps); i++) { 1862 alc_write_coef_idx(codec, 0x22, amps[i].nid); 1863 1864 for (j = 0; j < ARRAY_SIZE(amps[i].init_seq); j++) 1865 alc298_samsung_write_coef_pack(codec, amps[i].init_seq[j]); 1866 1867 for (j = 0; j < ARRAY_SIZE(init_seq); j++) 1868 alc298_samsung_write_coef_pack(codec, init_seq[j]); 1869 } 1870 } 1871 1872 struct alc298_samsung_v2_amp_desc { 1873 unsigned short nid; 1874 int init_seq_size; 1875 unsigned short init_seq[18][2]; 1876 }; 1877 1878 static const struct alc298_samsung_v2_amp_desc 1879 alc298_samsung_v2_amp_desc_tbl[] = { 1880 { 0x38, 18, { 1881 { 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 }, 1882 { 0x201b, 0x0001 }, { 0x201d, 0x0001 }, { 0x201f, 0x00fe }, 1883 { 0x2021, 0x0000 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 }, 1884 { 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e }, 1885 { 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x2399, 0x0003 }, 1886 { 0x23a4, 0x00b5 }, { 0x23a5, 0x0001 }, { 0x23ba, 0x0094 } 1887 }}, 1888 { 0x39, 18, { 1889 { 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 }, 1890 { 0x201b, 0x0002 }, { 0x201d, 0x0002 }, { 0x201f, 0x00fd }, 1891 { 0x2021, 0x0001 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 }, 1892 { 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e }, 1893 { 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x2399, 0x0003 }, 1894 { 0x23a4, 0x00b5 }, { 0x23a5, 0x0001 }, { 0x23ba, 0x0094 } 1895 }}, 1896 { 0x3c, 15, { 1897 { 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 }, 1898 { 0x201b, 0x0001 }, { 0x201d, 0x0001 }, { 0x201f, 0x00fe }, 1899 { 0x2021, 0x0000 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 }, 1900 { 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e }, 1901 { 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x23ba, 0x008d } 1902 }}, 1903 { 0x3d, 15, { 1904 { 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 }, 1905 { 0x201b, 0x0002 }, { 0x201d, 0x0002 }, { 0x201f, 0x00fd }, 1906 { 0x2021, 0x0001 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 }, 1907 { 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e }, 1908 { 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x23ba, 0x008d } 1909 }} 1910 }; 1911 1912 static void alc298_samsung_v2_enable_amps(struct hda_codec *codec) 1913 { 1914 struct alc_spec *spec = codec->spec; 1915 static const unsigned short enable_seq[][2] = { 1916 { 0x203a, 0x0081 }, { 0x23ff, 0x0001 }, 1917 }; 1918 int i, j; 1919 1920 for (i = 0; i < spec->num_speaker_amps; i++) { 1921 alc_write_coef_idx(codec, 0x22, alc298_samsung_v2_amp_desc_tbl[i].nid); 1922 for (j = 0; j < ARRAY_SIZE(enable_seq); j++) 1923 alc298_samsung_write_coef_pack(codec, enable_seq[j]); 1924 codec_dbg(codec, "alc298_samsung_v2: Enabled speaker amp 0x%02x\n", 1925 alc298_samsung_v2_amp_desc_tbl[i].nid); 1926 } 1927 } 1928 1929 static void alc298_samsung_v2_disable_amps(struct hda_codec *codec) 1930 { 1931 struct alc_spec *spec = codec->spec; 1932 static const unsigned short disable_seq[][2] = { 1933 { 0x23ff, 0x0000 }, { 0x203a, 0x0080 }, 1934 }; 1935 int i, j; 1936 1937 for (i = 0; i < spec->num_speaker_amps; i++) { 1938 alc_write_coef_idx(codec, 0x22, alc298_samsung_v2_amp_desc_tbl[i].nid); 1939 for (j = 0; j < ARRAY_SIZE(disable_seq); j++) 1940 alc298_samsung_write_coef_pack(codec, disable_seq[j]); 1941 codec_dbg(codec, "alc298_samsung_v2: Disabled speaker amp 0x%02x\n", 1942 alc298_samsung_v2_amp_desc_tbl[i].nid); 1943 } 1944 } 1945 1946 static void alc298_samsung_v2_playback_hook(struct hda_pcm_stream *hinfo, 1947 struct hda_codec *codec, 1948 struct snd_pcm_substream *substream, 1949 int action) 1950 { 1951 /* Dynamically enable/disable speaker amps before and after playback */ 1952 if (action == HDA_GEN_PCM_ACT_OPEN) 1953 alc298_samsung_v2_enable_amps(codec); 1954 if (action == HDA_GEN_PCM_ACT_CLOSE) 1955 alc298_samsung_v2_disable_amps(codec); 1956 } 1957 1958 static void alc298_samsung_v2_init_amps(struct hda_codec *codec, 1959 int num_speaker_amps) 1960 { 1961 struct alc_spec *spec = codec->spec; 1962 int i, j; 1963 1964 /* Set spec's num_speaker_amps before doing anything else */ 1965 spec->num_speaker_amps = num_speaker_amps; 1966 1967 /* Disable speaker amps before init to prevent any physical damage */ 1968 alc298_samsung_v2_disable_amps(codec); 1969 1970 /* Initialize the speaker amps */ 1971 for (i = 0; i < spec->num_speaker_amps; i++) { 1972 alc_write_coef_idx(codec, 0x22, alc298_samsung_v2_amp_desc_tbl[i].nid); 1973 for (j = 0; j < alc298_samsung_v2_amp_desc_tbl[i].init_seq_size; j++) { 1974 alc298_samsung_write_coef_pack(codec, 1975 alc298_samsung_v2_amp_desc_tbl[i].init_seq[j]); 1976 } 1977 alc_write_coef_idx(codec, 0x89, 0x0); 1978 codec_dbg(codec, "alc298_samsung_v2: Initialized speaker amp 0x%02x\n", 1979 alc298_samsung_v2_amp_desc_tbl[i].nid); 1980 } 1981 1982 /* register hook to enable speaker amps only when they are needed */ 1983 spec->gen.pcm_playback_hook = alc298_samsung_v2_playback_hook; 1984 } 1985 1986 /* LG Gram Style 14: program vendor coef sequence used by HDA-verb workaround */ 1987 struct alc298_lg_gram_style_seq { 1988 unsigned short verb; 1989 unsigned short idx; 1990 unsigned short val; 1991 }; 1992 1993 static void alc298_lg_gram_style_coef_write(struct hda_codec *codec, 1994 unsigned int verb, 1995 unsigned int idx, 1996 unsigned int val) 1997 { 1998 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x23); 1999 snd_hda_codec_write(codec, 0x20, 0, verb, idx); 2000 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0x00); 2001 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, val); 2002 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb011); 2003 } 2004 2005 static void alc298_lg_gram_style_run_seq(struct hda_codec *codec, 2006 const struct alc298_lg_gram_style_seq *seq, 2007 int seq_size) 2008 { 2009 int i; 2010 2011 for (i = 0; i < seq_size; i++) 2012 alc298_lg_gram_style_coef_write(codec, seq[i].verb, 2013 seq[i].idx, seq[i].val); 2014 } 2015 2016 /* Coef sequences derived from the HDA-verb workaround for this model. */ 2017 static const struct alc298_lg_gram_style_seq alc298_lg_gram_style_preinit_seq[] = { 2018 { 0x420, 0x00, 0x01 }, 2019 }; 2020 2021 static const struct alc298_lg_gram_style_seq alc298_lg_gram_style_disable_seq[] = { 2022 { 0x423, 0xff, 0x00 }, 2023 { 0x420, 0x3a, 0x80 }, 2024 }; 2025 2026 static const struct alc298_lg_gram_style_seq alc298_lg_gram_style_enable_seq[] = { 2027 { 0x420, 0x3a, 0x81 }, 2028 { 0x423, 0xff, 0x01 }, 2029 }; 2030 2031 static const struct alc298_lg_gram_style_seq alc298_lg_gram_style_init_seq_38[] = { 2032 { 0x423, 0xe1, 0x00 }, { 0x420, 0x12, 0x6f }, { 0x420, 0x14, 0x00 }, 2033 { 0x420, 0x1b, 0x01 }, { 0x420, 0x1d, 0x01 }, { 0x420, 0x1f, 0xfe }, 2034 { 0x420, 0x21, 0x00 }, { 0x420, 0x22, 0x10 }, { 0x420, 0x3d, 0x05 }, 2035 { 0x420, 0x3f, 0x03 }, { 0x420, 0x50, 0x2c }, { 0x420, 0x76, 0x0e }, 2036 { 0x420, 0x7c, 0x4a }, { 0x420, 0x81, 0x03 }, { 0x423, 0x99, 0x03 }, 2037 { 0x423, 0xa4, 0xb5 }, { 0x423, 0xa5, 0x01 }, { 0x423, 0xba, 0x94 }, 2038 }; 2039 2040 static const struct alc298_lg_gram_style_seq alc298_lg_gram_style_init_seq_39[] = { 2041 { 0x423, 0xe1, 0x00 }, { 0x420, 0x12, 0x6f }, { 0x420, 0x14, 0x00 }, 2042 { 0x420, 0x1b, 0x02 }, { 0x420, 0x1d, 0x02 }, { 0x420, 0x1f, 0xfd }, 2043 { 0x420, 0x21, 0x01 }, { 0x420, 0x22, 0x10 }, { 0x420, 0x3d, 0x05 }, 2044 { 0x420, 0x3f, 0x03 }, { 0x420, 0x50, 0x2c }, { 0x420, 0x76, 0x0e }, 2045 { 0x420, 0x7c, 0x4a }, { 0x420, 0x81, 0x03 }, { 0x423, 0x99, 0x03 }, 2046 { 0x423, 0xa4, 0xb5 }, { 0x423, 0xa5, 0x01 }, { 0x423, 0xba, 0x94 }, 2047 }; 2048 2049 static const struct alc298_lg_gram_style_seq alc298_lg_gram_style_init_seq_3c[] = { 2050 { 0x423, 0xe1, 0x00 }, { 0x420, 0x12, 0x6f }, { 0x420, 0x14, 0x00 }, 2051 { 0x420, 0x1b, 0x01 }, { 0x420, 0x1d, 0x01 }, { 0x420, 0x1f, 0xfe }, 2052 { 0x420, 0x21, 0x00 }, { 0x420, 0x22, 0x10 }, { 0x420, 0x3d, 0x05 }, 2053 { 0x420, 0x3f, 0x03 }, { 0x420, 0x50, 0x2c }, { 0x420, 0x76, 0x0e }, 2054 { 0x420, 0x7c, 0x4a }, { 0x420, 0x81, 0x03 }, { 0x423, 0xba, 0x8d }, 2055 }; 2056 2057 static const struct alc298_lg_gram_style_seq alc298_lg_gram_style_init_seq_3d[] = { 2058 { 0x423, 0xe1, 0x00 }, { 0x420, 0x12, 0x6f }, { 0x420, 0x14, 0x00 }, 2059 { 0x420, 0x1b, 0x02 }, { 0x420, 0x1d, 0x02 }, { 0x420, 0x1f, 0xfd }, 2060 { 0x420, 0x21, 0x01 }, { 0x420, 0x22, 0x10 }, { 0x420, 0x3d, 0x05 }, 2061 { 0x420, 0x3f, 0x03 }, { 0x420, 0x50, 0x2c }, { 0x420, 0x76, 0x0e }, 2062 { 0x420, 0x7c, 0x4a }, { 0x420, 0x81, 0x03 }, { 0x423, 0xba, 0x8d }, 2063 }; 2064 2065 struct alc298_lg_gram_style_amp_desc { 2066 unsigned char nid; 2067 const struct alc298_lg_gram_style_seq *init_seq; 2068 int init_seq_size; 2069 }; 2070 2071 static const struct alc298_lg_gram_style_amp_desc alc298_lg_gram_style_amps[] = { 2072 { 0x38, alc298_lg_gram_style_init_seq_38, 2073 ARRAY_SIZE(alc298_lg_gram_style_init_seq_38) }, 2074 { 0x39, alc298_lg_gram_style_init_seq_39, 2075 ARRAY_SIZE(alc298_lg_gram_style_init_seq_39) }, 2076 { 0x3c, alc298_lg_gram_style_init_seq_3c, 2077 ARRAY_SIZE(alc298_lg_gram_style_init_seq_3c) }, 2078 { 0x3d, alc298_lg_gram_style_init_seq_3d, 2079 ARRAY_SIZE(alc298_lg_gram_style_init_seq_3d) }, 2080 }; 2081 2082 static void alc298_lg_gram_style_enable_amps(struct hda_codec *codec) 2083 { 2084 struct alc_spec *spec = codec->spec; 2085 int i; 2086 2087 for (i = 0; i < spec->num_speaker_amps; i++) { 2088 alc_write_coef_idx(codec, 0x22, alc298_lg_gram_style_amps[i].nid); 2089 alc298_lg_gram_style_run_seq(codec, 2090 alc298_lg_gram_style_enable_seq, 2091 ARRAY_SIZE(alc298_lg_gram_style_enable_seq)); 2092 } 2093 } 2094 2095 static void alc298_lg_gram_style_disable_amps(struct hda_codec *codec) 2096 { 2097 struct alc_spec *spec = codec->spec; 2098 int i; 2099 2100 for (i = 0; i < spec->num_speaker_amps; i++) { 2101 alc_write_coef_idx(codec, 0x22, alc298_lg_gram_style_amps[i].nid); 2102 alc298_lg_gram_style_run_seq(codec, 2103 alc298_lg_gram_style_disable_seq, 2104 ARRAY_SIZE(alc298_lg_gram_style_disable_seq)); 2105 } 2106 } 2107 2108 static void alc298_lg_gram_style_playback_hook(struct hda_pcm_stream *hinfo, 2109 struct hda_codec *codec, 2110 struct snd_pcm_substream *substream, 2111 int action) 2112 { 2113 if (action == HDA_GEN_PCM_ACT_OPEN) 2114 alc298_lg_gram_style_enable_amps(codec); 2115 if (action == HDA_GEN_PCM_ACT_CLOSE) 2116 alc298_lg_gram_style_disable_amps(codec); 2117 } 2118 2119 static void alc298_lg_gram_style_init_amps(struct hda_codec *codec) 2120 { 2121 struct alc_spec *spec = codec->spec; 2122 int i; 2123 2124 spec->num_speaker_amps = ARRAY_SIZE(alc298_lg_gram_style_amps); 2125 2126 for (i = 0; i < spec->num_speaker_amps; i++) { 2127 alc_write_coef_idx(codec, 0x22, alc298_lg_gram_style_amps[i].nid); 2128 alc298_lg_gram_style_run_seq(codec, 2129 alc298_lg_gram_style_preinit_seq, 2130 ARRAY_SIZE(alc298_lg_gram_style_preinit_seq)); 2131 alc298_lg_gram_style_run_seq(codec, 2132 alc298_lg_gram_style_disable_seq, 2133 ARRAY_SIZE(alc298_lg_gram_style_disable_seq)); 2134 alc298_lg_gram_style_run_seq(codec, 2135 alc298_lg_gram_style_amps[i].init_seq, 2136 alc298_lg_gram_style_amps[i].init_seq_size); 2137 alc_write_coef_idx(codec, 0x89, 0x0); 2138 } 2139 2140 spec->gen.pcm_playback_hook = alc298_lg_gram_style_playback_hook; 2141 } 2142 2143 static void alc298_fixup_samsung_amp_v2_2_amps(struct hda_codec *codec, 2144 const struct hda_fixup *fix, int action) 2145 { 2146 if (action == HDA_FIXUP_ACT_PROBE) 2147 alc298_samsung_v2_init_amps(codec, 2); 2148 } 2149 2150 static void alc298_fixup_samsung_amp_v2_4_amps(struct hda_codec *codec, 2151 const struct hda_fixup *fix, int action) 2152 { 2153 if (action == HDA_FIXUP_ACT_PROBE) 2154 alc298_samsung_v2_init_amps(codec, 4); 2155 } 2156 2157 static void alc298_fixup_lg_gram_style_14(struct hda_codec *codec, 2158 const struct hda_fixup *fix, int action) 2159 { 2160 if (action == HDA_FIXUP_ACT_PROBE) 2161 alc298_lg_gram_style_init_amps(codec); 2162 } 2163 2164 static void gpio2_mic_hotkey_event(struct hda_codec *codec, 2165 struct hda_jack_callback *event) 2166 { 2167 struct alc_spec *spec = codec->spec; 2168 2169 /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore 2170 send both key on and key off event for every interrupt. */ 2171 input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1); 2172 input_sync(spec->kb_dev); 2173 input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0); 2174 input_sync(spec->kb_dev); 2175 } 2176 2177 static int alc_register_micmute_input_device(struct hda_codec *codec) 2178 { 2179 struct alc_spec *spec = codec->spec; 2180 int i; 2181 2182 spec->kb_dev = input_allocate_device(); 2183 if (!spec->kb_dev) { 2184 codec_err(codec, "Out of memory (input_allocate_device)\n"); 2185 return -ENOMEM; 2186 } 2187 2188 spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE; 2189 2190 spec->kb_dev->name = "Microphone Mute Button"; 2191 spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY); 2192 spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]); 2193 spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map); 2194 spec->kb_dev->keycode = spec->alc_mute_keycode_map; 2195 for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++) 2196 set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit); 2197 2198 if (input_register_device(spec->kb_dev)) { 2199 codec_err(codec, "input_register_device failed\n"); 2200 input_free_device(spec->kb_dev); 2201 spec->kb_dev = NULL; 2202 return -ENOMEM; 2203 } 2204 2205 return 0; 2206 } 2207 2208 /* GPIO1 = set according to SKU external amp 2209 * GPIO2 = mic mute hotkey 2210 * GPIO3 = mute LED 2211 * GPIO4 = mic mute LED 2212 */ 2213 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec, 2214 const struct hda_fixup *fix, int action) 2215 { 2216 struct alc_spec *spec = codec->spec; 2217 2218 alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10); 2219 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2220 spec->init_amp = ALC_INIT_DEFAULT; 2221 if (alc_register_micmute_input_device(codec) != 0) 2222 return; 2223 2224 spec->gpio_mask |= 0x06; 2225 spec->gpio_dir |= 0x02; 2226 spec->gpio_data |= 0x02; 2227 snd_hda_codec_write_cache(codec, codec->core.afg, 0, 2228 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04); 2229 snd_hda_jack_detect_enable_callback(codec, codec->core.afg, 2230 gpio2_mic_hotkey_event); 2231 return; 2232 } 2233 2234 if (!spec->kb_dev) 2235 return; 2236 2237 switch (action) { 2238 case HDA_FIXUP_ACT_FREE: 2239 input_unregister_device(spec->kb_dev); 2240 spec->kb_dev = NULL; 2241 } 2242 } 2243 2244 /* GPIO2 = mic mute hotkey 2245 * GPIO3 = mic mute LED 2246 */ 2247 static void alc233_fixup_lenovo_gpio2_mic_hotkey(struct hda_codec *codec, 2248 const struct hda_fixup *fix, int action) 2249 { 2250 struct alc_spec *spec = codec->spec; 2251 2252 alc233_fixup_lenovo_coef_micmute_led(codec, fix, action); 2253 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2254 alc_update_coef_idx(codec, 0x10, 1<<2, 1<<2); 2255 if (alc_register_micmute_input_device(codec) != 0) 2256 return; 2257 2258 spec->gpio_mask |= 0x04; 2259 spec->gpio_dir |= 0x0; 2260 snd_hda_codec_write_cache(codec, codec->core.afg, 0, 2261 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04); 2262 snd_hda_jack_detect_enable_callback(codec, codec->core.afg, 2263 gpio2_mic_hotkey_event); 2264 return; 2265 } 2266 2267 if (!spec->kb_dev) 2268 return; 2269 2270 switch (action) { 2271 case HDA_FIXUP_ACT_FREE: 2272 input_unregister_device(spec->kb_dev); 2273 spec->kb_dev = NULL; 2274 } 2275 } 2276 2277 /* Line2 = mic mute hotkey 2278 * GPIO2 = mic mute LED 2279 */ 2280 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec, 2281 const struct hda_fixup *fix, int action) 2282 { 2283 struct alc_spec *spec = codec->spec; 2284 2285 alc_fixup_hp_gpio_led(codec, action, 0, 0x04); 2286 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2287 spec->init_amp = ALC_INIT_DEFAULT; 2288 if (alc_register_micmute_input_device(codec) != 0) 2289 return; 2290 2291 snd_hda_jack_detect_enable_callback(codec, 0x1b, 2292 gpio2_mic_hotkey_event); 2293 return; 2294 } 2295 2296 if (!spec->kb_dev) 2297 return; 2298 2299 switch (action) { 2300 case HDA_FIXUP_ACT_FREE: 2301 input_unregister_device(spec->kb_dev); 2302 spec->kb_dev = NULL; 2303 } 2304 } 2305 2306 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec, 2307 const struct hda_fixup *fix, int action) 2308 { 2309 struct alc_spec *spec = codec->spec; 2310 2311 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1a); 2312 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2313 spec->cap_mute_led_nid = 0x18; 2314 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set); 2315 } 2316 } 2317 2318 static void alc233_fixup_lenovo_low_en_micmute_led(struct hda_codec *codec, 2319 const struct hda_fixup *fix, int action) 2320 { 2321 struct alc_spec *spec = codec->spec; 2322 2323 if (action == HDA_FIXUP_ACT_PRE_PROBE) 2324 spec->micmute_led_polarity = 1; 2325 alc233_fixup_lenovo_line2_mic_hotkey(codec, fix, action); 2326 } 2327 2328 static void alc255_set_default_jack_type(struct hda_codec *codec) 2329 { 2330 /* Set to iphone type */ 2331 static const struct coef_fw alc255fw[] = { 2332 WRITE_COEF(0x1b, 0x880b), 2333 WRITE_COEF(0x45, 0xd089), 2334 WRITE_COEF(0x1b, 0x080b), 2335 WRITE_COEF(0x46, 0x0004), 2336 WRITE_COEF(0x1b, 0x0c0b), 2337 {} 2338 }; 2339 static const struct coef_fw alc256fw[] = { 2340 WRITE_COEF(0x1b, 0x884b), 2341 WRITE_COEF(0x45, 0xd089), 2342 WRITE_COEF(0x1b, 0x084b), 2343 WRITE_COEF(0x46, 0x0004), 2344 WRITE_COEF(0x1b, 0x0c4b), 2345 {} 2346 }; 2347 switch (codec->core.vendor_id) { 2348 case 0x10ec0255: 2349 alc_process_coef_fw(codec, alc255fw); 2350 break; 2351 case 0x10ec0230: 2352 case 0x10ec0236: 2353 case 0x10ec0256: 2354 case 0x19e58326: 2355 alc_process_coef_fw(codec, alc256fw); 2356 break; 2357 } 2358 msleep(30); 2359 } 2360 2361 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec, 2362 const struct hda_fixup *fix, int action) 2363 { 2364 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2365 alc255_set_default_jack_type(codec); 2366 } 2367 alc_fixup_headset_mode(codec, fix, action); 2368 } 2369 2370 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec, 2371 const struct hda_fixup *fix, int action) 2372 { 2373 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2374 struct alc_spec *spec = codec->spec; 2375 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 2376 alc255_set_default_jack_type(codec); 2377 } else { 2378 alc_fixup_headset_mode(codec, fix, action); 2379 } 2380 } 2381 2382 static void alc288_update_headset_jack_cb(struct hda_codec *codec, 2383 struct hda_jack_callback *jack) 2384 { 2385 struct alc_spec *spec = codec->spec; 2386 2387 alc_update_headset_jack_cb(codec, jack); 2388 /* Headset Mic enable or disable, only for Dell Dino */ 2389 alc_update_gpio_data(codec, 0x40, spec->gen.hp_jack_present); 2390 } 2391 2392 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec, 2393 const struct hda_fixup *fix, int action) 2394 { 2395 alc_fixup_headset_mode(codec, fix, action); 2396 if (action == HDA_FIXUP_ACT_PROBE) { 2397 struct alc_spec *spec = codec->spec; 2398 /* toggled via hp_automute_hook */ 2399 spec->gpio_mask |= 0x40; 2400 spec->gpio_dir |= 0x40; 2401 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb; 2402 } 2403 } 2404 2405 static void alc_fixup_no_shutup(struct hda_codec *codec, 2406 const struct hda_fixup *fix, int action) 2407 { 2408 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2409 struct alc_spec *spec = codec->spec; 2410 spec->no_shutup_pins = 1; 2411 } 2412 } 2413 2414 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */ 2415 static void alc_fixup_tpt440_dock(struct hda_codec *codec, 2416 const struct hda_fixup *fix, int action) 2417 { 2418 static const struct hda_pintbl pincfgs[] = { 2419 { 0x16, 0x21211010 }, /* dock headphone */ 2420 { 0x19, 0x21a11010 }, /* dock mic */ 2421 { } 2422 }; 2423 struct alc_spec *spec = codec->spec; 2424 2425 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2426 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 2427 codec->power_save_node = 0; /* avoid click noises */ 2428 snd_hda_apply_pincfgs(codec, pincfgs); 2429 } 2430 } 2431 2432 static void alc_fixup_tpt470_dock(struct hda_codec *codec, 2433 const struct hda_fixup *fix, int action) 2434 { 2435 static const struct hda_pintbl pincfgs[] = { 2436 { 0x17, 0x21211010 }, /* dock headphone */ 2437 { 0x19, 0x21a11010 }, /* dock mic */ 2438 { } 2439 }; 2440 struct alc_spec *spec = codec->spec; 2441 2442 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2443 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 2444 snd_hda_apply_pincfgs(codec, pincfgs); 2445 } else if (action == HDA_FIXUP_ACT_INIT) { 2446 /* Enable DOCK device */ 2447 snd_hda_codec_write(codec, 0x17, 0, 2448 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0); 2449 /* Enable DOCK device */ 2450 snd_hda_codec_write(codec, 0x19, 0, 2451 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0); 2452 } 2453 } 2454 2455 static void alc_fixup_tpt470_dacs(struct hda_codec *codec, 2456 const struct hda_fixup *fix, int action) 2457 { 2458 /* Assure the speaker pin to be coupled with DAC NID 0x03; otherwise 2459 * the speaker output becomes too low by some reason on Thinkpads with 2460 * ALC298 codec 2461 */ 2462 static const hda_nid_t preferred_pairs[] = { 2463 0x14, 0x03, 0x17, 0x02, 0x21, 0x02, 2464 0 2465 }; 2466 struct alc_spec *spec = codec->spec; 2467 2468 if (action == HDA_FIXUP_ACT_PRE_PROBE) 2469 spec->gen.preferred_dacs = preferred_pairs; 2470 } 2471 2472 static void alc295_fixup_asus_dacs(struct hda_codec *codec, 2473 const struct hda_fixup *fix, int action) 2474 { 2475 static const hda_nid_t preferred_pairs[] = { 2476 0x17, 0x02, 0x21, 0x03, 0 2477 }; 2478 struct alc_spec *spec = codec->spec; 2479 2480 if (action == HDA_FIXUP_ACT_PRE_PROBE) 2481 spec->gen.preferred_dacs = preferred_pairs; 2482 } 2483 2484 static void alc271_hp_gate_mic_jack(struct hda_codec *codec, 2485 const struct hda_fixup *fix, 2486 int action) 2487 { 2488 struct alc_spec *spec = codec->spec; 2489 2490 if (action == HDA_FIXUP_ACT_PROBE) { 2491 int mic_pin = alc_find_ext_mic_pin(codec); 2492 int hp_pin = alc_get_hp_pin(spec); 2493 2494 if (snd_BUG_ON(!mic_pin || !hp_pin)) 2495 return; 2496 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin); 2497 } 2498 } 2499 2500 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec, 2501 const struct hda_fixup *fix, 2502 int action) 2503 { 2504 struct alc_spec *spec = codec->spec; 2505 struct auto_pin_cfg *cfg = &spec->gen.autocfg; 2506 int i; 2507 2508 /* The mic boosts on level 2 and 3 are too noisy 2509 on the internal mic input. 2510 Therefore limit the boost to 0 or 1. */ 2511 2512 if (action != HDA_FIXUP_ACT_PROBE) 2513 return; 2514 2515 for (i = 0; i < cfg->num_inputs; i++) { 2516 hda_nid_t nid = cfg->inputs[i].pin; 2517 unsigned int defcfg; 2518 if (cfg->inputs[i].type != AUTO_PIN_MIC) 2519 continue; 2520 defcfg = snd_hda_codec_get_pincfg(codec, nid); 2521 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT) 2522 continue; 2523 2524 snd_hda_override_amp_caps(codec, nid, HDA_INPUT, 2525 (0x00 << AC_AMPCAP_OFFSET_SHIFT) | 2526 (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) | 2527 (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) | 2528 (0 << AC_AMPCAP_MUTE_SHIFT)); 2529 } 2530 } 2531 2532 static void alc283_hp_automute_hook(struct hda_codec *codec, 2533 struct hda_jack_callback *jack) 2534 { 2535 struct alc_spec *spec = codec->spec; 2536 int vref; 2537 2538 msleep(200); 2539 snd_hda_gen_hp_automute(codec, jack); 2540 2541 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0; 2542 2543 msleep(600); 2544 snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 2545 vref); 2546 } 2547 2548 static void alc283_fixup_chromebook(struct hda_codec *codec, 2549 const struct hda_fixup *fix, int action) 2550 { 2551 struct alc_spec *spec = codec->spec; 2552 2553 switch (action) { 2554 case HDA_FIXUP_ACT_PRE_PROBE: 2555 snd_hda_override_wcaps(codec, 0x03, 0); 2556 /* Disable AA-loopback as it causes white noise */ 2557 spec->gen.mixer_nid = 0; 2558 break; 2559 case HDA_FIXUP_ACT_INIT: 2560 /* MIC2-VREF control */ 2561 /* Set to manual mode */ 2562 alc_update_coef_idx(codec, 0x06, 0x000c, 0); 2563 /* Enable Line1 input control by verb */ 2564 alc_update_coef_idx(codec, 0x1a, 0, 1 << 4); 2565 break; 2566 } 2567 } 2568 2569 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec, 2570 const struct hda_fixup *fix, int action) 2571 { 2572 struct alc_spec *spec = codec->spec; 2573 2574 switch (action) { 2575 case HDA_FIXUP_ACT_PRE_PROBE: 2576 spec->gen.hp_automute_hook = alc283_hp_automute_hook; 2577 break; 2578 case HDA_FIXUP_ACT_INIT: 2579 /* MIC2-VREF control */ 2580 /* Set to manual mode */ 2581 alc_update_coef_idx(codec, 0x06, 0x000c, 0); 2582 break; 2583 } 2584 } 2585 2586 /* mute tablet speaker pin (0x14) via dock plugging in addition */ 2587 static void asus_tx300_automute(struct hda_codec *codec) 2588 { 2589 struct alc_spec *spec = codec->spec; 2590 snd_hda_gen_update_outputs(codec); 2591 if (snd_hda_jack_detect(codec, 0x1b)) 2592 spec->gen.mute_bits |= (1ULL << 0x14); 2593 } 2594 2595 static void alc282_fixup_asus_tx300(struct hda_codec *codec, 2596 const struct hda_fixup *fix, int action) 2597 { 2598 struct alc_spec *spec = codec->spec; 2599 static const struct hda_pintbl dock_pins[] = { 2600 { 0x1b, 0x21114000 }, /* dock speaker pin */ 2601 {} 2602 }; 2603 2604 switch (action) { 2605 case HDA_FIXUP_ACT_PRE_PROBE: 2606 spec->init_amp = ALC_INIT_DEFAULT; 2607 /* TX300 needs to set up GPIO2 for the speaker amp */ 2608 alc_setup_gpio(codec, 0x04); 2609 snd_hda_apply_pincfgs(codec, dock_pins); 2610 spec->gen.auto_mute_via_amp = 1; 2611 spec->gen.automute_hook = asus_tx300_automute; 2612 snd_hda_jack_detect_enable_callback(codec, 0x1b, 2613 snd_hda_gen_hp_automute); 2614 break; 2615 case HDA_FIXUP_ACT_PROBE: 2616 spec->init_amp = ALC_INIT_DEFAULT; 2617 break; 2618 case HDA_FIXUP_ACT_BUILD: 2619 /* this is a bit tricky; give more sane names for the main 2620 * (tablet) speaker and the dock speaker, respectively 2621 */ 2622 rename_ctl(codec, "Speaker Playback Switch", 2623 "Dock Speaker Playback Switch"); 2624 rename_ctl(codec, "Bass Speaker Playback Switch", 2625 "Speaker Playback Switch"); 2626 break; 2627 } 2628 } 2629 2630 static void alc285_lenovo_dac_rename(struct hda_codec *codec, 2631 const struct hda_fixup *fix, int action) 2632 { 2633 if (action == HDA_FIXUP_ACT_BUILD) 2634 rename_ctl(codec, "Line Out Playback Volume", 2635 "Headphone Playback Volume"); 2636 } 2637 static void alc290_fixup_mono_speakers(struct hda_codec *codec, 2638 const struct hda_fixup *fix, int action) 2639 { 2640 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2641 /* DAC node 0x03 is giving mono output. We therefore want to 2642 make sure 0x14 (front speaker) and 0x15 (headphones) use the 2643 stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */ 2644 static const hda_nid_t conn1[] = { 0x0c }; 2645 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1); 2646 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1); 2647 } 2648 } 2649 2650 static void alc298_fixup_speaker_volume(struct hda_codec *codec, 2651 const struct hda_fixup *fix, int action) 2652 { 2653 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2654 /* The speaker is routed to the Node 0x06 by a mistake, as a result 2655 we can't adjust the speaker's volume since this node does not has 2656 Amp-out capability. we change the speaker's route to: 2657 Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 ( 2658 Pin Complex), since Node 0x02 has Amp-out caps, we can adjust 2659 speaker's volume now. */ 2660 2661 static const hda_nid_t conn1[] = { 0x0c }; 2662 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn1), conn1); 2663 } 2664 } 2665 2666 /* disable DAC3 (0x06) selection on NID 0x17 as it has no volume amp control */ 2667 static void alc295_fixup_disable_dac3(struct hda_codec *codec, 2668 const struct hda_fixup *fix, int action) 2669 { 2670 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2671 static const hda_nid_t conn[] = { 0x02, 0x03 }; 2672 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 2673 } 2674 } 2675 2676 /* force NID 0x17 (Bass Speaker) to DAC1 to share it with the main speaker */ 2677 static void alc285_fixup_speaker2_to_dac1(struct hda_codec *codec, 2678 const struct hda_fixup *fix, int action) 2679 { 2680 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2681 static const hda_nid_t conn[] = { 0x02 }; 2682 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 2683 } 2684 } 2685 2686 /* disable DAC3 (0x06) selection on NID 0x15 - share Speaker/Bass Speaker DAC 0x03 */ 2687 static void alc294_fixup_bass_speaker_15(struct hda_codec *codec, 2688 const struct hda_fixup *fix, int action) 2689 { 2690 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2691 static const hda_nid_t conn[] = { 0x02, 0x03 }; 2692 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn), conn); 2693 snd_hda_gen_add_micmute_led_cdev(codec, NULL); 2694 } 2695 } 2696 2697 /* Hook to update amp GPIO4 for automute */ 2698 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec, 2699 struct hda_jack_callback *jack) 2700 { 2701 struct alc_spec *spec = codec->spec; 2702 2703 snd_hda_gen_hp_automute(codec, jack); 2704 /* mute_led_polarity is set to 0, so we pass inverted value here */ 2705 alc_update_gpio_led(codec, 0x10, spec->mute_led_polarity, 2706 !spec->gen.hp_jack_present); 2707 } 2708 2709 /* Manage GPIOs for HP EliteBook Folio 9480m. 2710 * 2711 * GPIO4 is the headphone amplifier power control 2712 * GPIO3 is the audio output mute indicator LED 2713 */ 2714 2715 static void alc280_fixup_hp_9480m(struct hda_codec *codec, 2716 const struct hda_fixup *fix, 2717 int action) 2718 { 2719 struct alc_spec *spec = codec->spec; 2720 2721 alc_fixup_hp_gpio_led(codec, action, 0x08, 0); 2722 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2723 /* amp at GPIO4; toggled via alc280_hp_gpio4_automute_hook() */ 2724 spec->gpio_mask |= 0x10; 2725 spec->gpio_dir |= 0x10; 2726 spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook; 2727 } 2728 } 2729 2730 static void alc275_fixup_gpio4_off(struct hda_codec *codec, 2731 const struct hda_fixup *fix, 2732 int action) 2733 { 2734 struct alc_spec *spec = codec->spec; 2735 2736 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2737 spec->gpio_mask |= 0x04; 2738 spec->gpio_dir |= 0x04; 2739 /* set data bit low */ 2740 } 2741 } 2742 2743 /* Quirk for Thinkpad X1 7th and 8th Gen 2744 * The following fixed routing needed 2745 * DAC1 (NID 0x02) -> Speaker (NID 0x14); some eq applied secretly 2746 * DAC2 (NID 0x03) -> Bass (NID 0x17) & Headphone (NID 0x21); sharing a DAC 2747 * DAC3 (NID 0x06) -> Unused, due to the lack of volume amp 2748 */ 2749 static void alc285_fixup_thinkpad_x1_gen7(struct hda_codec *codec, 2750 const struct hda_fixup *fix, int action) 2751 { 2752 static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */ 2753 static const hda_nid_t preferred_pairs[] = { 2754 0x14, 0x02, 0x17, 0x03, 0x21, 0x03, 0 2755 }; 2756 struct alc_spec *spec = codec->spec; 2757 2758 switch (action) { 2759 case HDA_FIXUP_ACT_PRE_PROBE: 2760 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 2761 spec->gen.preferred_dacs = preferred_pairs; 2762 break; 2763 case HDA_FIXUP_ACT_BUILD: 2764 /* The generic parser creates somewhat unintuitive volume ctls 2765 * with the fixed routing above, and the shared DAC2 may be 2766 * confusing for PA. 2767 * Rename those to unique names so that PA doesn't touch them 2768 * and use only Master volume. 2769 */ 2770 rename_ctl(codec, "Front Playback Volume", "DAC1 Playback Volume"); 2771 rename_ctl(codec, "Bass Speaker Playback Volume", "DAC2 Playback Volume"); 2772 break; 2773 } 2774 } 2775 2776 static void alc225_fixup_s3_pop_noise(struct hda_codec *codec, 2777 const struct hda_fixup *fix, int action) 2778 { 2779 if (action != HDA_FIXUP_ACT_PRE_PROBE) 2780 return; 2781 2782 codec->power_save_node = 1; 2783 } 2784 2785 /* Forcibly assign NID 0x03 to HP/LO while NID 0x02 to SPK for EQ */ 2786 static void alc274_fixup_bind_dacs(struct hda_codec *codec, 2787 const struct hda_fixup *fix, int action) 2788 { 2789 struct alc_spec *spec = codec->spec; 2790 static const hda_nid_t preferred_pairs[] = { 2791 0x21, 0x03, 0x1b, 0x03, 0x16, 0x02, 2792 0 2793 }; 2794 2795 if (action != HDA_FIXUP_ACT_PRE_PROBE) 2796 return; 2797 2798 spec->gen.preferred_dacs = preferred_pairs; 2799 spec->gen.auto_mute_via_amp = 1; 2800 codec->power_save_node = 0; 2801 } 2802 2803 /* avoid DAC 0x06 for speaker switch 0x17; it has no volume control */ 2804 static void alc274_fixup_hp_aio_bind_dacs(struct hda_codec *codec, 2805 const struct hda_fixup *fix, int action) 2806 { 2807 static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */ 2808 /* The speaker is routed to the Node 0x06 by a mistake, thus the 2809 * speaker's volume can't be adjusted since the node doesn't have 2810 * Amp-out capability. Assure the speaker and lineout pin to be 2811 * coupled with DAC NID 0x02. 2812 */ 2813 static const hda_nid_t preferred_pairs[] = { 2814 0x16, 0x02, 0x17, 0x02, 0x21, 0x03, 0 2815 }; 2816 struct alc_spec *spec = codec->spec; 2817 2818 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 2819 spec->gen.preferred_dacs = preferred_pairs; 2820 } 2821 2822 /* avoid DAC 0x06 for bass speaker 0x17; it has no volume control */ 2823 static void alc289_fixup_asus_ga401(struct hda_codec *codec, 2824 const struct hda_fixup *fix, int action) 2825 { 2826 static const hda_nid_t preferred_pairs[] = { 2827 0x14, 0x02, 0x17, 0x02, 0x21, 0x03, 0 2828 }; 2829 struct alc_spec *spec = codec->spec; 2830 2831 if (action == HDA_FIXUP_ACT_PRE_PROBE) 2832 spec->gen.preferred_dacs = preferred_pairs; 2833 } 2834 2835 /* The DAC of NID 0x3 will introduce click/pop noise on headphones, so invalidate it */ 2836 static void alc285_fixup_invalidate_dacs(struct hda_codec *codec, 2837 const struct hda_fixup *fix, int action) 2838 { 2839 if (action != HDA_FIXUP_ACT_PRE_PROBE) 2840 return; 2841 2842 snd_hda_override_wcaps(codec, 0x03, 0); 2843 } 2844 2845 static void alc_combo_jack_hp_jd_restart(struct hda_codec *codec) 2846 { 2847 switch (codec->core.vendor_id) { 2848 case 0x10ec0274: 2849 case 0x10ec0294: 2850 case 0x10ec0225: 2851 case 0x10ec0295: 2852 case 0x10ec0299: 2853 alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */ 2854 alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15); 2855 break; 2856 case 0x10ec0230: 2857 case 0x10ec0235: 2858 case 0x10ec0236: 2859 case 0x10ec0255: 2860 case 0x10ec0256: 2861 case 0x10ec0257: 2862 case 0x19e58326: 2863 alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */ 2864 alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15); 2865 break; 2866 } 2867 } 2868 2869 static void alc295_fixup_chromebook(struct hda_codec *codec, 2870 const struct hda_fixup *fix, int action) 2871 { 2872 struct alc_spec *spec = codec->spec; 2873 2874 switch (action) { 2875 case HDA_FIXUP_ACT_PRE_PROBE: 2876 spec->ultra_low_power = true; 2877 break; 2878 case HDA_FIXUP_ACT_INIT: 2879 alc_combo_jack_hp_jd_restart(codec); 2880 break; 2881 } 2882 } 2883 2884 static void alc256_fixup_chromebook(struct hda_codec *codec, 2885 const struct hda_fixup *fix, int action) 2886 { 2887 struct alc_spec *spec = codec->spec; 2888 2889 switch (action) { 2890 case HDA_FIXUP_ACT_PRE_PROBE: 2891 if (codec->core.subsystem_id == 0x10280d76) 2892 spec->gen.suppress_auto_mute = 0; 2893 else 2894 spec->gen.suppress_auto_mute = 1; 2895 spec->gen.suppress_auto_mic = 1; 2896 spec->en_3kpull_low = false; 2897 break; 2898 } 2899 } 2900 2901 static void alc_fixup_disable_mic_vref(struct hda_codec *codec, 2902 const struct hda_fixup *fix, int action) 2903 { 2904 if (action == HDA_FIXUP_ACT_PRE_PROBE) 2905 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ); 2906 } 2907 2908 2909 static void alc294_gx502_toggle_output(struct hda_codec *codec, 2910 struct hda_jack_callback *cb) 2911 { 2912 /* The Windows driver sets the codec up in a very different way where 2913 * it appears to leave 0x10 = 0x8a20 set. For Linux we need to toggle it 2914 */ 2915 if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT) 2916 alc_write_coef_idx(codec, 0x10, 0x8a20); 2917 else 2918 alc_write_coef_idx(codec, 0x10, 0x0a20); 2919 } 2920 2921 static void alc294_fixup_gx502_hp(struct hda_codec *codec, 2922 const struct hda_fixup *fix, int action) 2923 { 2924 /* Pin 0x21: headphones/headset mic */ 2925 if (!is_jack_detectable(codec, 0x21)) 2926 return; 2927 2928 switch (action) { 2929 case HDA_FIXUP_ACT_PRE_PROBE: 2930 snd_hda_jack_detect_enable_callback(codec, 0x21, 2931 alc294_gx502_toggle_output); 2932 break; 2933 case HDA_FIXUP_ACT_INIT: 2934 /* Make sure to start in a correct state, i.e. if 2935 * headphones have been plugged in before powering up the system 2936 */ 2937 alc294_gx502_toggle_output(codec, NULL); 2938 break; 2939 } 2940 } 2941 2942 static void alc294_gu502_toggle_output(struct hda_codec *codec, 2943 struct hda_jack_callback *cb) 2944 { 2945 /* Windows sets 0x10 to 0x8420 for Node 0x20 which is 2946 * responsible from changes between speakers and headphones 2947 */ 2948 if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT) 2949 alc_write_coef_idx(codec, 0x10, 0x8420); 2950 else 2951 alc_write_coef_idx(codec, 0x10, 0x0a20); 2952 } 2953 2954 static void alc294_fixup_gu502_hp(struct hda_codec *codec, 2955 const struct hda_fixup *fix, int action) 2956 { 2957 if (!is_jack_detectable(codec, 0x21)) 2958 return; 2959 2960 switch (action) { 2961 case HDA_FIXUP_ACT_PRE_PROBE: 2962 snd_hda_jack_detect_enable_callback(codec, 0x21, 2963 alc294_gu502_toggle_output); 2964 break; 2965 case HDA_FIXUP_ACT_INIT: 2966 alc294_gu502_toggle_output(codec, NULL); 2967 break; 2968 } 2969 } 2970 2971 static void alc285_fixup_hp_gpio_amp_init(struct hda_codec *codec, 2972 const struct hda_fixup *fix, int action) 2973 { 2974 if (action != HDA_FIXUP_ACT_INIT) 2975 return; 2976 2977 msleep(100); 2978 alc_write_coef_idx(codec, 0x65, 0x0); 2979 } 2980 2981 static void alc274_fixup_hp_headset_mic(struct hda_codec *codec, 2982 const struct hda_fixup *fix, int action) 2983 { 2984 switch (action) { 2985 case HDA_FIXUP_ACT_INIT: 2986 alc_combo_jack_hp_jd_restart(codec); 2987 break; 2988 } 2989 } 2990 2991 static void alc_fixup_no_int_mic(struct hda_codec *codec, 2992 const struct hda_fixup *fix, int action) 2993 { 2994 struct alc_spec *spec = codec->spec; 2995 2996 switch (action) { 2997 case HDA_FIXUP_ACT_PRE_PROBE: 2998 /* Mic RING SLEEVE swap for combo jack */ 2999 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12); 3000 spec->no_internal_mic_pin = true; 3001 break; 3002 case HDA_FIXUP_ACT_INIT: 3003 alc_combo_jack_hp_jd_restart(codec); 3004 break; 3005 } 3006 } 3007 3008 /* GPIO1 = amplifier on/off 3009 * GPIO3 = mic mute LED 3010 */ 3011 static void alc285_fixup_hp_spectre_x360_eb1(struct hda_codec *codec, 3012 const struct hda_fixup *fix, int action) 3013 { 3014 static const hda_nid_t conn[] = { 0x02 }; 3015 3016 struct alc_spec *spec = codec->spec; 3017 static const struct hda_pintbl pincfgs[] = { 3018 { 0x14, 0x90170110 }, /* front/high speakers */ 3019 { 0x17, 0x90170130 }, /* back/bass speakers */ 3020 { } 3021 }; 3022 3023 //enable micmute led 3024 alc_fixup_hp_gpio_led(codec, action, 0x00, 0x04); 3025 3026 switch (action) { 3027 case HDA_FIXUP_ACT_PRE_PROBE: 3028 spec->micmute_led_polarity = 1; 3029 /* needed for amp of back speakers */ 3030 spec->gpio_mask |= 0x01; 3031 spec->gpio_dir |= 0x01; 3032 snd_hda_apply_pincfgs(codec, pincfgs); 3033 /* share DAC to have unified volume control */ 3034 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn); 3035 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 3036 break; 3037 case HDA_FIXUP_ACT_INIT: 3038 /* need to toggle GPIO to enable the amp of back speakers */ 3039 alc_update_gpio_data(codec, 0x01, true); 3040 msleep(100); 3041 alc_update_gpio_data(codec, 0x01, false); 3042 break; 3043 } 3044 } 3045 3046 /* GPIO1 = amplifier on/off */ 3047 static void alc285_fixup_hp_spectre_x360_df1(struct hda_codec *codec, 3048 const struct hda_fixup *fix, 3049 int action) 3050 { 3051 struct alc_spec *spec = codec->spec; 3052 static const hda_nid_t conn[] = { 0x02 }; 3053 static const struct hda_pintbl pincfgs[] = { 3054 { 0x14, 0x90170110 }, /* front/high speakers */ 3055 { 0x17, 0x90170130 }, /* back/bass speakers */ 3056 { } 3057 }; 3058 3059 // enable mute led 3060 alc285_fixup_hp_mute_led_coefbit(codec, fix, action); 3061 3062 switch (action) { 3063 case HDA_FIXUP_ACT_PRE_PROBE: 3064 /* needed for amp of back speakers */ 3065 spec->gpio_mask |= 0x01; 3066 spec->gpio_dir |= 0x01; 3067 snd_hda_apply_pincfgs(codec, pincfgs); 3068 /* share DAC to have unified volume control */ 3069 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn); 3070 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 3071 break; 3072 case HDA_FIXUP_ACT_INIT: 3073 /* need to toggle GPIO to enable the amp of back speakers */ 3074 alc_update_gpio_data(codec, 0x01, true); 3075 msleep(100); 3076 alc_update_gpio_data(codec, 0x01, false); 3077 break; 3078 } 3079 } 3080 3081 static void alc285_fixup_hp_spectre_x360(struct hda_codec *codec, 3082 const struct hda_fixup *fix, int action) 3083 { 3084 static const hda_nid_t conn[] = { 0x02 }; 3085 static const struct hda_pintbl pincfgs[] = { 3086 { 0x14, 0x90170110 }, /* rear speaker */ 3087 { } 3088 }; 3089 3090 switch (action) { 3091 case HDA_FIXUP_ACT_PRE_PROBE: 3092 snd_hda_apply_pincfgs(codec, pincfgs); 3093 /* force front speaker to DAC1 */ 3094 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 3095 break; 3096 } 3097 } 3098 3099 static void alc285_fixup_hp_envy_x360(struct hda_codec *codec, 3100 const struct hda_fixup *fix, 3101 int action) 3102 { 3103 static const struct coef_fw coefs[] = { 3104 WRITE_COEF(0x08, 0x6a0c), WRITE_COEF(0x0d, 0xa023), 3105 WRITE_COEF(0x10, 0x0320), WRITE_COEF(0x1a, 0x8c03), 3106 WRITE_COEF(0x25, 0x1800), WRITE_COEF(0x26, 0x003a), 3107 WRITE_COEF(0x28, 0x1dfe), WRITE_COEF(0x29, 0xb014), 3108 WRITE_COEF(0x2b, 0x1dfe), WRITE_COEF(0x37, 0xfe15), 3109 WRITE_COEF(0x38, 0x7909), WRITE_COEF(0x45, 0xd489), 3110 WRITE_COEF(0x46, 0x00f4), WRITE_COEF(0x4a, 0x21e0), 3111 WRITE_COEF(0x66, 0x03f0), WRITE_COEF(0x67, 0x1000), 3112 WRITE_COEF(0x6e, 0x1005), { } 3113 }; 3114 3115 static const struct hda_pintbl pincfgs[] = { 3116 { 0x12, 0xb7a60130 }, /* Internal microphone*/ 3117 { 0x14, 0x90170150 }, /* B&O soundbar speakers */ 3118 { 0x17, 0x90170153 }, /* Side speakers */ 3119 { 0x19, 0x03a11040 }, /* Headset microphone */ 3120 { } 3121 }; 3122 3123 switch (action) { 3124 case HDA_FIXUP_ACT_PRE_PROBE: 3125 snd_hda_apply_pincfgs(codec, pincfgs); 3126 3127 /* Fixes volume control problem for side speakers */ 3128 alc295_fixup_disable_dac3(codec, fix, action); 3129 3130 /* Fixes no sound from headset speaker */ 3131 snd_hda_codec_amp_stereo(codec, 0x21, HDA_OUTPUT, 0, -1, 0); 3132 3133 /* Auto-enable headset mic when plugged */ 3134 snd_hda_jack_set_gating_jack(codec, 0x19, 0x21); 3135 3136 /* Headset mic volume enhancement */ 3137 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREF50); 3138 break; 3139 case HDA_FIXUP_ACT_INIT: 3140 alc_process_coef_fw(codec, coefs); 3141 break; 3142 case HDA_FIXUP_ACT_BUILD: 3143 rename_ctl(codec, "Bass Speaker Playback Volume", 3144 "B&O-Tuned Playback Volume"); 3145 rename_ctl(codec, "Front Playback Switch", 3146 "B&O Soundbar Playback Switch"); 3147 rename_ctl(codec, "Bass Speaker Playback Switch", 3148 "Side Speaker Playback Switch"); 3149 break; 3150 } 3151 } 3152 3153 static void alc285_fixup_hp_beep(struct hda_codec *codec, 3154 const struct hda_fixup *fix, int action) 3155 { 3156 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 3157 codec->beep_just_power_on = true; 3158 } else if (action == HDA_FIXUP_ACT_INIT) { 3159 #ifdef CONFIG_SND_HDA_INPUT_BEEP 3160 /* 3161 * Just enable loopback to internal speaker and headphone jack. 3162 * Disable amplification to get about the same beep volume as 3163 * was on pure BIOS setup before loading the driver. 3164 */ 3165 alc_update_coef_idx(codec, 0x36, 0x7070, BIT(13)); 3166 3167 snd_hda_enable_beep_device(codec, 1); 3168 3169 #if !IS_ENABLED(CONFIG_INPUT_PCSPKR) 3170 dev_warn_once(hda_codec_dev(codec), 3171 "enable CONFIG_INPUT_PCSPKR to get PC beeps\n"); 3172 #endif 3173 #endif 3174 } 3175 } 3176 3177 /* for hda_fixup_thinkpad_acpi() */ 3178 #include "../helpers/thinkpad.c" 3179 3180 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec, 3181 const struct hda_fixup *fix, int action) 3182 { 3183 alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */ 3184 hda_fixup_thinkpad_acpi(codec, fix, action); 3185 } 3186 3187 /* for hda_fixup_ideapad_acpi() */ 3188 #include "../helpers/ideapad_hotkey_led.c" 3189 3190 static void alc_fixup_ideapad_acpi(struct hda_codec *codec, 3191 const struct hda_fixup *fix, int action) 3192 { 3193 hda_fixup_ideapad_acpi(codec, fix, action); 3194 } 3195 3196 /* Fixup for Lenovo Legion 15IMHg05 speaker output on headset removal. */ 3197 static void alc287_fixup_legion_15imhg05_speakers(struct hda_codec *codec, 3198 const struct hda_fixup *fix, 3199 int action) 3200 { 3201 struct alc_spec *spec = codec->spec; 3202 3203 switch (action) { 3204 case HDA_FIXUP_ACT_PRE_PROBE: 3205 spec->gen.suppress_auto_mute = 1; 3206 break; 3207 } 3208 } 3209 3210 static void comp_acpi_device_notify(acpi_handle handle, u32 event, void *data) 3211 { 3212 struct hda_codec *cdc = data; 3213 struct alc_spec *spec = cdc->spec; 3214 3215 codec_info(cdc, "ACPI Notification %d\n", event); 3216 3217 hda_component_acpi_device_notify(&spec->comps, handle, event, data); 3218 } 3219 3220 static int comp_bind(struct device *dev) 3221 { 3222 struct hda_codec *cdc = dev_to_hda_codec(dev); 3223 struct alc_spec *spec = cdc->spec; 3224 int ret; 3225 3226 ret = hda_component_manager_bind(cdc, &spec->comps); 3227 if (ret) 3228 return ret; 3229 3230 return hda_component_manager_bind_acpi_notifications(cdc, 3231 &spec->comps, 3232 comp_acpi_device_notify, cdc); 3233 } 3234 3235 static void comp_unbind(struct device *dev) 3236 { 3237 struct hda_codec *cdc = dev_to_hda_codec(dev); 3238 struct alc_spec *spec = cdc->spec; 3239 3240 hda_component_manager_unbind_acpi_notifications(cdc, &spec->comps, comp_acpi_device_notify); 3241 hda_component_manager_unbind(cdc, &spec->comps); 3242 } 3243 3244 static const struct component_master_ops comp_master_ops = { 3245 .bind = comp_bind, 3246 .unbind = comp_unbind, 3247 }; 3248 3249 static void comp_generic_playback_hook(struct hda_pcm_stream *hinfo, struct hda_codec *cdc, 3250 struct snd_pcm_substream *sub, int action) 3251 { 3252 struct alc_spec *spec = cdc->spec; 3253 3254 hda_component_manager_playback_hook(&spec->comps, action); 3255 } 3256 3257 static void comp_generic_fixup(struct hda_codec *cdc, int action, const char *bus, 3258 const char *hid, const char *match_str, int count) 3259 { 3260 struct alc_spec *spec = cdc->spec; 3261 int ret; 3262 3263 switch (action) { 3264 case HDA_FIXUP_ACT_PRE_PROBE: 3265 ret = hda_component_manager_init(cdc, &spec->comps, count, bus, hid, 3266 match_str, &comp_master_ops); 3267 if (ret) 3268 return; 3269 3270 spec->gen.pcm_playback_hook = comp_generic_playback_hook; 3271 break; 3272 case HDA_FIXUP_ACT_FREE: 3273 hda_component_manager_free(&spec->comps, &comp_master_ops); 3274 break; 3275 } 3276 } 3277 3278 static void find_cirrus_companion_amps(struct hda_codec *cdc) 3279 { 3280 struct device *dev = hda_codec_dev(cdc); 3281 struct acpi_device *adev; 3282 const char *bus = NULL; 3283 static const struct { 3284 const char *hid; 3285 const char *name; 3286 } acpi_ids[] = {{ "CSC3554", "cs35l54-hda" }, 3287 { "CSC3556", "cs35l56-hda" }, 3288 { "CSC3557", "cs35l57-hda" }}; 3289 char *match; 3290 int i, count = 0, count_devindex = 0; 3291 3292 for (i = 0; i < ARRAY_SIZE(acpi_ids); ++i) { 3293 adev = acpi_dev_get_first_match_dev(acpi_ids[i].hid, NULL, -1); 3294 if (adev) 3295 break; 3296 } 3297 if (!adev) { 3298 codec_dbg(cdc, "Did not find ACPI entry for a Cirrus Amp\n"); 3299 return; 3300 } 3301 3302 count = i2c_acpi_client_count(adev); 3303 if (count > 0) { 3304 bus = "i2c"; 3305 } else { 3306 count = acpi_spi_count_resources(adev); 3307 if (count > 0) 3308 bus = "spi"; 3309 } 3310 3311 struct fwnode_handle *fwnode __free(fwnode_handle) = 3312 fwnode_handle_get(acpi_fwnode_handle(adev)); 3313 acpi_dev_put(adev); 3314 3315 if (!bus) { 3316 codec_err(cdc, "Did not find any buses for %s\n", acpi_ids[i].hid); 3317 return; 3318 } 3319 3320 if (!fwnode) { 3321 codec_err(cdc, "Could not get fwnode for %s\n", acpi_ids[i].hid); 3322 return; 3323 } 3324 3325 /* 3326 * When available the cirrus,dev-index property is an accurate 3327 * count of the amps in a system and is used in preference to 3328 * the count of bus devices that can contain additional address 3329 * alias entries. 3330 */ 3331 count_devindex = fwnode_property_count_u32(fwnode, "cirrus,dev-index"); 3332 if (count_devindex > 0) 3333 count = count_devindex; 3334 3335 match = devm_kasprintf(dev, GFP_KERNEL, "-%%s:00-%s.%%d", acpi_ids[i].name); 3336 if (!match) 3337 return; 3338 codec_info(cdc, "Found %d %s on %s (%s)\n", count, acpi_ids[i].hid, bus, match); 3339 comp_generic_fixup(cdc, HDA_FIXUP_ACT_PRE_PROBE, bus, acpi_ids[i].hid, match, count); 3340 } 3341 3342 static void aw88399_fixup_i2c_two(struct hda_codec *cdc, const struct hda_fixup *fix, int action) 3343 { 3344 comp_generic_fixup(cdc, action, "i2c", "AWDZ8399", "-%s:00-aw88399-hda.%d", 2); 3345 } 3346 3347 static void alc287_fixup_legion_16iax10h_aw88399(struct hda_codec *codec, 3348 const struct hda_fixup *fix, int action) 3349 { 3350 /* 3351 * Force DAC 0x02 for the bass speaker 0x17, as the default 0x06 lacks volume controls. 3352 */ 3353 static const hda_nid_t conn[] = { 0x02 }; 3354 struct alc_spec *spec = codec->spec; 3355 3356 alc269_fixup_limit_int_mic_boost(codec, fix, action); 3357 alc_fixup_headset_mode_no_hp_mic(codec, fix, action); 3358 alc_fixup_headset_jack(codec, fix, action); 3359 3360 switch (action) { 3361 case HDA_FIXUP_ACT_PRE_PROBE: 3362 spec->gen.suppress_auto_mic = 1; 3363 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 3364 break; 3365 case HDA_FIXUP_ACT_BUILD: 3366 spec->gen.multiout.max_channels = 2; 3367 spec->gen.pcm_rec[0]->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 2; 3368 break; 3369 } 3370 } 3371 3372 static void cs35l41_fixup_i2c_two(struct hda_codec *cdc, const struct hda_fixup *fix, int action) 3373 { 3374 comp_generic_fixup(cdc, action, "i2c", "CSC3551", "-%s:00-cs35l41-hda.%d", 2); 3375 } 3376 3377 static void cs35l41_fixup_i2c_four(struct hda_codec *cdc, const struct hda_fixup *fix, int action) 3378 { 3379 comp_generic_fixup(cdc, action, "i2c", "CSC3551", "-%s:00-cs35l41-hda.%d", 4); 3380 } 3381 3382 static void cs35l41_fixup_spi_two(struct hda_codec *codec, const struct hda_fixup *fix, int action) 3383 { 3384 comp_generic_fixup(codec, action, "spi", "CSC3551", "-%s:00-cs35l41-hda.%d", 2); 3385 } 3386 3387 static void cs35l41_fixup_spi_one(struct hda_codec *codec, const struct hda_fixup *fix, int action) 3388 { 3389 comp_generic_fixup(codec, action, "spi", "CSC3551", "-%s:00-cs35l41-hda.%d", 1); 3390 } 3391 3392 static void cs35l41_fixup_spi_four(struct hda_codec *codec, const struct hda_fixup *fix, int action) 3393 { 3394 comp_generic_fixup(codec, action, "spi", "CSC3551", "-%s:00-cs35l41-hda.%d", 4); 3395 } 3396 3397 static void alc287_fixup_legion_16achg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix, 3398 int action) 3399 { 3400 comp_generic_fixup(cdc, action, "i2c", "CLSA0100", "-%s:00-cs35l41-hda.%d", 2); 3401 } 3402 3403 static void alc287_fixup_legion_16ithg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix, 3404 int action) 3405 { 3406 comp_generic_fixup(cdc, action, "i2c", "CLSA0101", "-%s:00-cs35l41-hda.%d", 2); 3407 } 3408 3409 static void alc285_fixup_asus_ga403u(struct hda_codec *cdc, const struct hda_fixup *fix, int action) 3410 { 3411 /* 3412 * The same SSID has been re-used in different hardware, they have 3413 * different codecs and the newer GA403U has a ALC285. 3414 */ 3415 if (cdc->core.vendor_id != 0x10ec0285) 3416 alc_fixup_inv_dmic(cdc, fix, action); 3417 } 3418 3419 static void tas2781_fixup_tias_i2c(struct hda_codec *cdc, 3420 const struct hda_fixup *fix, int action) 3421 { 3422 comp_generic_fixup(cdc, action, "i2c", "TIAS2781", "-%s:00", 1); 3423 } 3424 3425 static void tas2781_fixup_spi(struct hda_codec *cdc, const struct hda_fixup *fix, int action) 3426 { 3427 comp_generic_fixup(cdc, action, "spi", "TXNW2781", "-%s:00-tas2781-hda.%d", 2); 3428 } 3429 3430 static void tas2781_fixup_txnw_i2c(struct hda_codec *cdc, 3431 const struct hda_fixup *fix, int action) 3432 { 3433 comp_generic_fixup(cdc, action, "i2c", "TXNW2781", "-%s:00-tas2781-hda.%d", 1); 3434 } 3435 3436 static void yoga7_14arb7_fixup_i2c(struct hda_codec *cdc, 3437 const struct hda_fixup *fix, int action) 3438 { 3439 comp_generic_fixup(cdc, action, "i2c", "INT8866", "-%s:00", 1); 3440 } 3441 3442 static void alc256_fixup_acer_sfg16_micmute_led(struct hda_codec *codec, 3443 const struct hda_fixup *fix, int action) 3444 { 3445 alc_fixup_hp_gpio_led(codec, action, 0, 0x04); 3446 } 3447 3448 static void alc287_fixup_acer_micmute_led(struct hda_codec *codec, 3449 const struct hda_fixup *fix, int action) 3450 { 3451 struct alc_spec *spec = codec->spec; 3452 3453 alc_fixup_hp_gpio_led(codec, action, 0, 0x10); 3454 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 3455 spec->micmute_led_polarity = 1; 3456 spec->gpio_mask |= 0x10; 3457 spec->gpio_dir |= 0x10; 3458 } 3459 } 3460 3461 /* for alc295_fixup_hp_top_speakers */ 3462 #include "../helpers/hp_x360.c" 3463 3464 /* for alc285_fixup_ideapad_s740_coef() */ 3465 #include "../helpers/ideapad_s740.c" 3466 3467 /* for alc298_fixup_razer_blade16_2025() */ 3468 #include "../helpers/razer_blade16_2025.c" 3469 3470 static const struct coef_fw alc256_fixup_set_coef_defaults_coefs[] = { 3471 WRITE_COEF(0x10, 0x0020), WRITE_COEF(0x24, 0x0000), 3472 WRITE_COEF(0x26, 0x0000), WRITE_COEF(0x29, 0x3000), 3473 WRITE_COEF(0x37, 0xfe05), WRITE_COEF(0x45, 0x5089), 3474 {} 3475 }; 3476 3477 static void alc256_fixup_set_coef_defaults(struct hda_codec *codec, 3478 const struct hda_fixup *fix, 3479 int action) 3480 { 3481 /* 3482 * A certain other OS sets these coeffs to different values. On at least 3483 * one TongFang barebone these settings might survive even a cold 3484 * reboot. So to restore a clean slate the values are explicitly reset 3485 * to default here. Without this, the external microphone is always in a 3486 * plugged-in state, while the internal microphone is always in an 3487 * unplugged state, breaking the ability to use the internal microphone. 3488 */ 3489 alc_process_coef_fw(codec, alc256_fixup_set_coef_defaults_coefs); 3490 } 3491 3492 static const struct coef_fw alc233_fixup_no_audio_jack_coefs[] = { 3493 WRITE_COEF(0x1a, 0x9003), WRITE_COEF(0x1b, 0x0e2b), WRITE_COEF(0x37, 0xfe06), 3494 WRITE_COEF(0x38, 0x4981), WRITE_COEF(0x45, 0xd489), WRITE_COEF(0x46, 0x0074), 3495 WRITE_COEF(0x49, 0x0149), 3496 {} 3497 }; 3498 3499 static void alc233_fixup_no_audio_jack(struct hda_codec *codec, 3500 const struct hda_fixup *fix, 3501 int action) 3502 { 3503 /* 3504 * The audio jack input and output is not detected on the ASRock NUC Box 3505 * 1100 series when cold booting without this fix. Warm rebooting from a 3506 * certain other OS makes the audio functional, as COEF settings are 3507 * preserved in this case. This fix sets these altered COEF values as 3508 * the default. 3509 */ 3510 alc_process_coef_fw(codec, alc233_fixup_no_audio_jack_coefs); 3511 } 3512 3513 static void alc256_fixup_mic_no_presence_and_resume(struct hda_codec *codec, 3514 const struct hda_fixup *fix, 3515 int action) 3516 { 3517 /* 3518 * The Clevo NJ51CU comes either with the ALC293 or the ALC256 codec, 3519 * but uses the 0x8686 subproduct id in both cases. The ALC256 codec 3520 * needs an additional quirk for sound working after suspend and resume. 3521 */ 3522 if (codec->core.vendor_id == 0x10ec0256) { 3523 alc_update_coef_idx(codec, 0x10, 1<<9, 0); 3524 snd_hda_codec_set_pincfg(codec, 0x19, 0x04a11120); 3525 } else { 3526 snd_hda_codec_set_pincfg(codec, 0x1a, 0x04a1113c); 3527 } 3528 } 3529 3530 static void alc256_fixup_xiaomi_pro15_resume(struct hda_codec *codec, 3531 const struct hda_fixup *fix, 3532 int action) 3533 { 3534 /* 3535 * On the Xiaomi Mi Laptop Pro 15 (TM1905, SSID 1d72:1905) the ALC256 3536 * codec sets coefficient 0x10 bit 9 to 1 after S3 resume, silencing 3537 * the internal speaker. Bluetooth and HDMI audio are unaffected. 3538 * Clear the bit so the speaker keeps working across suspend cycles. 3539 */ 3540 alc_update_coef_idx(codec, 0x10, 1<<9, 0); 3541 } 3542 3543 static void alc256_decrease_headphone_amp_val(struct hda_codec *codec, 3544 const struct hda_fixup *fix, int action) 3545 { 3546 u32 caps; 3547 u8 nsteps, offs; 3548 3549 if (action != HDA_FIXUP_ACT_PRE_PROBE) 3550 return; 3551 3552 caps = query_amp_caps(codec, 0x3, HDA_OUTPUT); 3553 nsteps = ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) - 10; 3554 offs = ((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT) - 10; 3555 caps &= ~AC_AMPCAP_NUM_STEPS & ~AC_AMPCAP_OFFSET; 3556 caps |= (nsteps << AC_AMPCAP_NUM_STEPS_SHIFT) | (offs << AC_AMPCAP_OFFSET_SHIFT); 3557 3558 if (snd_hda_override_amp_caps(codec, 0x3, HDA_OUTPUT, caps)) 3559 codec_warn(codec, "failed to override amp caps for NID 0x3\n"); 3560 } 3561 3562 static void alc_fixup_dell4_mic_no_presence_quiet(struct hda_codec *codec, 3563 const struct hda_fixup *fix, 3564 int action) 3565 { 3566 struct alc_spec *spec = codec->spec; 3567 struct hda_input_mux *imux = &spec->gen.input_mux; 3568 int i; 3569 3570 alc269_fixup_limit_int_mic_boost(codec, fix, action); 3571 3572 switch (action) { 3573 case HDA_FIXUP_ACT_PRE_PROBE: 3574 /** 3575 * Set the vref of pin 0x19 (Headset Mic) and pin 0x1b (Headphone Mic) 3576 * to Hi-Z to avoid pop noises at startup and when plugging and 3577 * unplugging headphones. 3578 */ 3579 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ); 3580 snd_hda_codec_set_pin_target(codec, 0x1b, PIN_VREFHIZ); 3581 break; 3582 case HDA_FIXUP_ACT_PROBE: 3583 /** 3584 * Make the internal mic (0x12) the default input source to 3585 * prevent pop noises on cold boot. 3586 */ 3587 for (i = 0; i < imux->num_items; i++) { 3588 if (spec->gen.imux_pins[i] == 0x12) { 3589 spec->gen.cur_mux[0] = i; 3590 break; 3591 } 3592 } 3593 break; 3594 } 3595 } 3596 3597 static void alc287_fixup_yoga9_14iap7_bass_spk_pin(struct hda_codec *codec, 3598 const struct hda_fixup *fix, int action) 3599 { 3600 /* 3601 * The Pin Complex 0x17 for the bass speakers is wrongly reported as 3602 * unconnected. 3603 */ 3604 static const struct hda_pintbl pincfgs[] = { 3605 { 0x17, 0x90170121 }, 3606 { } 3607 }; 3608 /* 3609 * Avoid DAC 0x06 and 0x08, as they have no volume controls. 3610 * DAC 0x02 and 0x03 would be fine. 3611 */ 3612 static const hda_nid_t conn[] = { 0x02, 0x03 }; 3613 /* 3614 * Prefer both speakerbar (0x14) and bass speakers (0x17) connected to DAC 0x02. 3615 * Headphones (0x21) are connected to DAC 0x03. 3616 */ 3617 static const hda_nid_t preferred_pairs[] = { 3618 0x14, 0x02, 3619 0x17, 0x02, 3620 0x21, 0x03, 3621 0 3622 }; 3623 struct alc_spec *spec = codec->spec; 3624 3625 /* Support Audio mute LED and Mic mute LED on keyboard */ 3626 hda_fixup_ideapad_acpi(codec, fix, action); 3627 3628 switch (action) { 3629 case HDA_FIXUP_ACT_PRE_PROBE: 3630 snd_hda_apply_pincfgs(codec, pincfgs); 3631 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 3632 spec->gen.preferred_dacs = preferred_pairs; 3633 break; 3634 } 3635 } 3636 3637 static void alc_fixup_yoga_pro7_audio(struct hda_codec *codec, 3638 const struct hda_fixup *fix, int action) 3639 { 3640 /* Reuse the DAC routing selected for ThinkPad X1 Gen7 */ 3641 alc285_fixup_thinkpad_x1_gen7(codec, fix, action); 3642 3643 /* Limit the internal mic boost to 0 or 1 to avoid noise */ 3644 alc269_fixup_limit_int_mic_boost(codec, fix, action); 3645 } 3646 3647 static void alc295_fixup_dell_inspiron_top_speakers(struct hda_codec *codec, 3648 const struct hda_fixup *fix, int action) 3649 { 3650 static const struct hda_pintbl pincfgs[] = { 3651 { 0x14, 0x90170151 }, 3652 { 0x17, 0x90170150 }, 3653 { } 3654 }; 3655 static const hda_nid_t conn[] = { 0x02, 0x03 }; 3656 static const hda_nid_t preferred_pairs[] = { 3657 0x14, 0x02, 3658 0x17, 0x03, 3659 0x21, 0x02, 3660 0 3661 }; 3662 struct alc_spec *spec = codec->spec; 3663 3664 alc_fixup_no_shutup(codec, fix, action); 3665 3666 switch (action) { 3667 case HDA_FIXUP_ACT_PRE_PROBE: 3668 snd_hda_apply_pincfgs(codec, pincfgs); 3669 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 3670 spec->gen.preferred_dacs = preferred_pairs; 3671 break; 3672 } 3673 } 3674 3675 /* Forcibly assign NID 0x03 to HP while NID 0x02 to SPK */ 3676 static void alc287_fixup_bind_dacs(struct hda_codec *codec, 3677 const struct hda_fixup *fix, int action) 3678 { 3679 struct alc_spec *spec = codec->spec; 3680 static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */ 3681 static const hda_nid_t preferred_pairs[] = { 3682 0x17, 0x02, 0x21, 0x03, 0 3683 }; 3684 3685 if (action != HDA_FIXUP_ACT_PRE_PROBE) 3686 return; 3687 3688 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 3689 spec->gen.preferred_dacs = preferred_pairs; 3690 spec->gen.auto_mute_via_amp = 1; 3691 if (spec->gen.autocfg.speaker_pins[0] != 0x14) { 3692 snd_hda_codec_write_cache(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 3693 0x0); /* Make sure 0x14 was disable */ 3694 } 3695 } 3696 3697 /* Fix none verb table of Headset Mic pin */ 3698 static void alc2xx_fixup_headset_mic(struct hda_codec *codec, 3699 const struct hda_fixup *fix, int action) 3700 { 3701 struct alc_spec *spec = codec->spec; 3702 static const struct hda_pintbl pincfgs[] = { 3703 { 0x19, 0x03a1103c }, 3704 { } 3705 }; 3706 3707 switch (action) { 3708 case HDA_FIXUP_ACT_PRE_PROBE: 3709 snd_hda_apply_pincfgs(codec, pincfgs); 3710 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12); 3711 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 3712 break; 3713 } 3714 } 3715 3716 static void alc245_fixup_hp_spectre_x360_eu0xxx(struct hda_codec *codec, 3717 const struct hda_fixup *fix, int action) 3718 { 3719 /* 3720 * The Pin Complex 0x14 for the treble speakers is wrongly reported as 3721 * unconnected. 3722 * The Pin Complex 0x17 for the bass speakers has the lowest association 3723 * and sequence values so shift it up a bit to squeeze 0x14 in. 3724 */ 3725 static const struct hda_pintbl pincfgs[] = { 3726 { 0x14, 0x90170110 }, // top/treble 3727 { 0x17, 0x90170111 }, // bottom/bass 3728 { } 3729 }; 3730 3731 /* 3732 * Force DAC 0x02 for the bass speakers 0x17. 3733 */ 3734 static const hda_nid_t conn[] = { 0x02 }; 3735 3736 switch (action) { 3737 case HDA_FIXUP_ACT_PRE_PROBE: 3738 snd_hda_apply_pincfgs(codec, pincfgs); 3739 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 3740 break; 3741 } 3742 3743 cs35l41_fixup_i2c_two(codec, fix, action); 3744 alc245_fixup_hp_mute_led_coefbit(codec, fix, action); 3745 alc245_fixup_hp_gpio_led(codec, fix, action); 3746 } 3747 3748 /* some changes for Spectre x360 16, 2024 model */ 3749 static void alc245_fixup_hp_spectre_x360_16_aa0xxx(struct hda_codec *codec, 3750 const struct hda_fixup *fix, int action) 3751 { 3752 /* 3753 * The Pin Complex 0x14 for the treble speakers is wrongly reported as 3754 * unconnected. 3755 * The Pin Complex 0x17 for the bass speakers has the lowest association 3756 * and sequence values so shift it up a bit to squeeze 0x14 in. 3757 */ 3758 struct alc_spec *spec = codec->spec; 3759 static const struct hda_pintbl pincfgs[] = { 3760 { 0x14, 0x90170110 }, // top/treble 3761 { 0x17, 0x90170111 }, // bottom/bass 3762 { } 3763 }; 3764 3765 /* 3766 * Force DAC 0x02 for the bass speakers 0x17. 3767 */ 3768 static const hda_nid_t conn[] = { 0x02 }; 3769 3770 switch (action) { 3771 case HDA_FIXUP_ACT_PRE_PROBE: 3772 /* needed for amp of back speakers */ 3773 spec->gpio_mask |= 0x01; 3774 spec->gpio_dir |= 0x01; 3775 snd_hda_apply_pincfgs(codec, pincfgs); 3776 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 3777 break; 3778 case HDA_FIXUP_ACT_INIT: 3779 /* need to toggle GPIO to enable the amp of back speakers */ 3780 alc_update_gpio_data(codec, 0x01, true); 3781 msleep(100); 3782 alc_update_gpio_data(codec, 0x01, false); 3783 break; 3784 } 3785 3786 cs35l41_fixup_i2c_two(codec, fix, action); 3787 alc245_fixup_hp_mute_led_coefbit(codec, fix, action); 3788 alc245_fixup_hp_gpio_led(codec, fix, action); 3789 } 3790 3791 static void alc245_fixup_hp_zbook_firefly_g12a(struct hda_codec *codec, 3792 const struct hda_fixup *fix, int action) 3793 { 3794 struct alc_spec *spec = codec->spec; 3795 static const hda_nid_t conn[] = { 0x02 }; 3796 3797 switch (action) { 3798 case HDA_FIXUP_ACT_PRE_PROBE: 3799 spec->gen.auto_mute_via_amp = 1; 3800 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 3801 break; 3802 } 3803 3804 cs35l41_fixup_i2c_two(codec, fix, action); 3805 alc245_fixup_hp_mute_led_coefbit(codec, fix, action); 3806 alc285_fixup_hp_coef_micmute_led(codec, fix, action); 3807 } 3808 3809 /* 3810 * ALC287 PCM hooks 3811 */ 3812 static void alc287_alc1318_playback_pcm_hook(struct hda_pcm_stream *hinfo, 3813 struct hda_codec *codec, 3814 struct snd_pcm_substream *substream, 3815 int action) 3816 { 3817 switch (action) { 3818 case HDA_GEN_PCM_ACT_OPEN: 3819 alc_write_coefex_idx(codec, 0x5a, 0x00, 0x954f); /* write gpio3 to high */ 3820 break; 3821 case HDA_GEN_PCM_ACT_CLOSE: 3822 alc_write_coefex_idx(codec, 0x5a, 0x00, 0x554f); /* write gpio3 as default value */ 3823 break; 3824 } 3825 } 3826 3827 static void alc287_s4_power_gpio3_default(struct hda_codec *codec) 3828 { 3829 if (is_s4_suspend(codec)) { 3830 alc_write_coefex_idx(codec, 0x5a, 0x00, 0x554f); /* write gpio3 as default value */ 3831 } 3832 } 3833 3834 static void alc287_fixup_lenovo_thinkpad_with_alc1318(struct hda_codec *codec, 3835 const struct hda_fixup *fix, int action) 3836 { 3837 struct alc_spec *spec = codec->spec; 3838 static const struct coef_fw coefs[] = { 3839 WRITE_COEF(0x24, 0x0013), WRITE_COEF(0x25, 0x0000), WRITE_COEF(0x26, 0xC300), 3840 WRITE_COEF(0x28, 0x0001), WRITE_COEF(0x29, 0xb023), 3841 WRITE_COEF(0x24, 0x0013), WRITE_COEF(0x25, 0x0000), WRITE_COEF(0x26, 0xC301), 3842 WRITE_COEF(0x28, 0x0001), WRITE_COEF(0x29, 0xb023), 3843 }; 3844 static const struct coef_fw dis_coefs[] = { 3845 WRITE_COEF(0x24, 0x0013), WRITE_COEF(0x25, 0x0000), WRITE_COEF(0x26, 0xC203), 3846 WRITE_COEF(0x28, 0x0004), WRITE_COEF(0x29, 0xb023), 3847 }; /* Disable AMP silence detection */ 3848 3849 if (action != HDA_FIXUP_ACT_PRE_PROBE) 3850 return; 3851 alc_update_coef_idx(codec, 0x10, 1<<11, 1<<11); 3852 alc_process_coef_fw(codec, dis_coefs); 3853 alc_process_coef_fw(codec, coefs); 3854 spec->power_hook = alc287_s4_power_gpio3_default; 3855 spec->gen.pcm_playback_hook = alc287_alc1318_playback_pcm_hook; 3856 } 3857 3858 static void alc287_fixup_tb_vmaster_led(struct hda_codec *codec, 3859 const struct hda_fixup *fix, int action) 3860 { 3861 struct alc_spec *spec = codec->spec; 3862 3863 if (action == HDA_FIXUP_ACT_PRE_PROBE) 3864 spec->gen.vmaster_mute_led = 1; 3865 3866 alc287_fixup_bind_dacs(codec, fix, action); 3867 } 3868 /* GPIO2: mute led GPIO3: micmute led */ 3869 static void alc245_tas2781_spi_hp_fixup_muteled(struct hda_codec *codec, 3870 const struct hda_fixup *fix, int action) 3871 { 3872 struct alc_spec *spec = codec->spec; 3873 static const hda_nid_t conn[] = { 0x02 }; 3874 3875 switch (action) { 3876 case HDA_FIXUP_ACT_PRE_PROBE: 3877 spec->gen.auto_mute_via_amp = 1; 3878 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 3879 break; 3880 } 3881 3882 tas2781_fixup_spi(codec, fix, action); 3883 alc_fixup_hp_gpio_led(codec, action, 0x04, 0x0); 3884 alc285_fixup_hp_coef_micmute_led(codec, fix, action); 3885 } 3886 3887 static void alc245_hp_spk_mute_led_update(void *private_data, int enabled) 3888 { 3889 struct hda_codec *codec = private_data; 3890 unsigned int val; 3891 3892 val = enabled ? 0x08 : 0x04; /* 0x08 led on, 0x04 led off */ 3893 alc_update_coef_idx(codec, 0x0b, 0x0c, val); 3894 } 3895 3896 static void alc245_hp_spk_mute_led_update_inverted(void *private_data, int enabled) 3897 { 3898 struct hda_codec *codec = private_data; 3899 unsigned int val; 3900 3901 val = enabled ? 0x04 : 0x08; /* inverted: 0x04 led off, 0x08 led on */ 3902 alc_update_coef_idx(codec, 0x0b, 0x0c, val); 3903 } 3904 3905 /* JD2: mute led GPIO3: micmute led */ 3906 static void alc245_tas2781_i2c_hp_fixup_muteled(struct hda_codec *codec, 3907 const struct hda_fixup *fix, int action) 3908 { 3909 struct alc_spec *spec = codec->spec; 3910 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3911 static const hda_nid_t conn[] = { 0x02 }; 3912 3913 switch (action) { 3914 case HDA_FIXUP_ACT_PRE_PROBE: 3915 if (!hp_pin) { 3916 spec->gen.vmaster_mute.hook = alc245_hp_spk_mute_led_update; 3917 spec->gen.vmaster_mute_led = 1; 3918 } 3919 spec->gen.auto_mute_via_amp = 1; 3920 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 3921 break; 3922 case HDA_FIXUP_ACT_INIT: 3923 if (!hp_pin) 3924 alc245_hp_spk_mute_led_update(codec, !spec->gen.master_mute); 3925 break; 3926 } 3927 3928 tas2781_fixup_txnw_i2c(codec, fix, action); 3929 if (hp_pin) 3930 alc245_fixup_hp_mute_led_coefbit(codec, fix, action); 3931 alc285_fixup_hp_coef_micmute_led(codec, fix, action); 3932 } 3933 3934 /* Same as alc245_tas2781_i2c_hp_fixup_muteled(), but with inverted speaker 3935 * mute LED polarity. The HP ZBook 8 G2a 14/16 (0x103c:0x8f94, 0x103c:0x8f95) 3936 * are speaker-only models without an HP pin, so the LED is driven directly 3937 * through the vmaster_mute hook. 3938 */ 3939 static void alc245_tas2781_i2c_hp_fixup_muteled_inverted(struct hda_codec *codec, 3940 const struct hda_fixup *fix, int action) 3941 { 3942 struct alc_spec *spec = codec->spec; 3943 static const hda_nid_t conn[] = { 0x02 }; 3944 3945 switch (action) { 3946 case HDA_FIXUP_ACT_PRE_PROBE: 3947 spec->gen.vmaster_mute.hook = alc245_hp_spk_mute_led_update_inverted; 3948 spec->gen.vmaster_mute_led = 1; 3949 spec->gen.auto_mute_via_amp = 1; 3950 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 3951 break; 3952 case HDA_FIXUP_ACT_INIT: 3953 alc245_hp_spk_mute_led_update_inverted(codec, !spec->gen.master_mute); 3954 break; 3955 } 3956 3957 tas2781_fixup_txnw_i2c(codec, fix, action); 3958 alc285_fixup_hp_coef_micmute_led(codec, fix, action); 3959 } 3960 /* 3961 * Clear COEF 0x0d (PCBEEP passthrough) bit 0x40 where BIOS sets it wrongly 3962 * at PM resume 3963 */ 3964 static void alc283_fixup_dell_hp_resume(struct hda_codec *codec, 3965 const struct hda_fixup *fix, int action) 3966 { 3967 if (action == HDA_FIXUP_ACT_INIT) 3968 alc_write_coef_idx(codec, 0xd, 0x2800); 3969 } 3970 3971 /* Swap DAC assignments for HP and speaker */ 3972 static void alc288_fixup_surface_swap_dacs(struct hda_codec *codec, 3973 const struct hda_fixup *fix, int action) 3974 { 3975 struct alc_spec *spec = codec->spec; 3976 static hda_nid_t preferred_pairs[] = { 3977 0x21, 0x03, 0x14, 0x02, 0 3978 }; 3979 3980 if (action != HDA_FIXUP_ACT_PRE_PROBE) 3981 return; 3982 3983 spec->gen.preferred_dacs = preferred_pairs; 3984 } 3985 3986 static void alc274_fixup_hp_89e9_amp(struct hda_codec *codec, 3987 const struct hda_fixup *fix, int action) 3988 { 3989 if (action == HDA_FIXUP_ACT_INIT) { 3990 /* need to toggle GPIO to enable the amp */ 3991 snd_hda_codec_set_gpio(codec, 0x03, 0x03, 0x03, 0); 3992 msleep(100); 3993 snd_hda_codec_set_gpio(codec, 0x03, 0x03, 0x00, 0); 3994 } 3995 } 3996 enum { 3997 ALC269_FIXUP_GPIO2, 3998 ALC269_FIXUP_SONY_VAIO, 3999 ALC275_FIXUP_SONY_VAIO_GPIO2, 4000 ALC269_FIXUP_DELL_M101Z, 4001 ALC269_FIXUP_SKU_IGNORE, 4002 ALC269_FIXUP_ASUS_G73JW, 4003 ALC269_FIXUP_ASUS_N7601ZM_PINS, 4004 ALC269_FIXUP_ASUS_N7601ZM, 4005 ALC269_FIXUP_LENOVO_EAPD, 4006 ALC275_FIXUP_SONY_HWEQ, 4007 ALC275_FIXUP_SONY_DISABLE_AAMIX, 4008 ALC271_FIXUP_DMIC, 4009 ALC269_FIXUP_PCM_44K, 4010 ALC269_FIXUP_STEREO_DMIC, 4011 ALC269_FIXUP_HEADSET_MIC, 4012 ALC269_FIXUP_QUANTA_MUTE, 4013 ALC269_FIXUP_LIFEBOOK, 4014 ALC269_FIXUP_LIFEBOOK_EXTMIC, 4015 ALC269_FIXUP_LIFEBOOK_HP_PIN, 4016 ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT, 4017 ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, 4018 ALC269_FIXUP_AMIC, 4019 ALC269_FIXUP_DMIC, 4020 ALC269VB_FIXUP_AMIC, 4021 ALC269VB_FIXUP_DMIC, 4022 ALC269_FIXUP_HP_MUTE_LED, 4023 ALC269_FIXUP_HP_MUTE_LED_MIC1, 4024 ALC269_FIXUP_HP_MUTE_LED_MIC2, 4025 ALC269_FIXUP_HP_MUTE_LED_MIC3, 4026 ALC269_FIXUP_HP_GPIO_LED, 4027 ALC269_FIXUP_HP_GPIO_MIC1_LED, 4028 ALC269_FIXUP_HP_LINE1_MIC1_LED, 4029 ALC269_FIXUP_INV_DMIC, 4030 ALC269_FIXUP_LENOVO_DOCK, 4031 ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, 4032 ALC269_FIXUP_NO_SHUTUP, 4033 ALC286_FIXUP_SONY_MIC_NO_PRESENCE, 4034 ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT, 4035 ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 4036 ALC269_FIXUP_DELL1_LIMIT_INT_MIC_BOOST, 4037 ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, 4038 ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, 4039 ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 4040 ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET, 4041 ALC269_FIXUP_HEADSET_MODE, 4042 ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, 4043 ALC269_FIXUP_ASPIRE_HEADSET_MIC, 4044 ALC269_FIXUP_ASUS_X101_FUNC, 4045 ALC269_FIXUP_ASUS_X101_VERB, 4046 ALC269_FIXUP_ASUS_X101, 4047 ALC271_FIXUP_AMIC_MIC2, 4048 ALC271_FIXUP_HP_GATE_MIC_JACK, 4049 ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, 4050 ALC269_FIXUP_ACER_AC700, 4051 ALC269_FIXUP_LIMIT_INT_MIC_BOOST, 4052 ALC269_FIXUP_THINKPAD_LIMIT_INT_MIC_BOOST, 4053 ALC269VB_FIXUP_ASUS_ZENBOOK, 4054 ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, 4055 ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE, 4056 ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED, 4057 ALC269VB_FIXUP_ORDISSIMO_EVE2, 4058 ALC283_FIXUP_CHROME_BOOK, 4059 ALC283_FIXUP_SENSE_COMBO_JACK, 4060 ALC282_FIXUP_ASUS_TX300, 4061 ALC283_FIXUP_INT_MIC, 4062 ALC290_FIXUP_MONO_SPEAKERS, 4063 ALC290_FIXUP_MONO_SPEAKERS_HSJACK, 4064 ALC290_FIXUP_SUBWOOFER, 4065 ALC290_FIXUP_SUBWOOFER_HSJACK, 4066 ALC295_FIXUP_HP_MUTE_LED_COEFBIT11, 4067 ALC295_FIXUP_HP_PAVILION_MUTE_LED_1B, 4068 ALC269_FIXUP_THINKPAD_ACPI, 4069 ALC269_FIXUP_LENOVO_XPAD_ACPI, 4070 ALC269_FIXUP_DMIC_THINKPAD_ACPI, 4071 ALC269VB_FIXUP_INFINIX_ZERO_BOOK_13, 4072 ALC269VC_FIXUP_INFINIX_Y4_MAX, 4073 ALC269VB_FIXUP_INFINIX_INBOOK_X3_SLIM, 4074 ALC269VC_FIXUP_LUNNEN_GROUND_14, 4075 ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO, 4076 ALC255_FIXUP_ACER_MIC_NO_PRESENCE, 4077 ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, 4078 ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 4079 ALC255_FIXUP_DELL1_LIMIT_INT_MIC_BOOST, 4080 ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, 4081 ALC255_FIXUP_HEADSET_MODE, 4082 ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC, 4083 ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, 4084 ALC292_FIXUP_TPT440_DOCK, 4085 ALC292_FIXUP_TPT440, 4086 ALC283_FIXUP_HEADSET_MIC, 4087 ALC255_FIXUP_MIC_MUTE_LED, 4088 ALC282_FIXUP_ASPIRE_V5_PINS, 4089 ALC269VB_FIXUP_ASPIRE_E1_COEF, 4090 ALC280_FIXUP_HP_GPIO4, 4091 ALC286_FIXUP_HP_GPIO_LED, 4092 ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, 4093 ALC280_FIXUP_HP_DOCK_PINS, 4094 ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, 4095 ALC280_FIXUP_HP_9480M, 4096 ALC245_FIXUP_HP_X360_AMP, 4097 ALC285_FIXUP_HP_SPECTRE_X360_EB1, 4098 ALC285_FIXUP_HP_SPECTRE_X360_DF1, 4099 ALC285_FIXUP_HP_ENVY_X360, 4100 ALC288_FIXUP_DELL_HEADSET_MODE, 4101 ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, 4102 ALC288_FIXUP_DELL_XPS_13, 4103 ALC288_FIXUP_DISABLE_AAMIX, 4104 ALC292_FIXUP_DELL_E7X_AAMIX, 4105 ALC292_FIXUP_DELL_E7X, 4106 ALC292_FIXUP_DISABLE_AAMIX, 4107 ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, 4108 ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE, 4109 ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 4110 ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, 4111 ALC275_FIXUP_DELL_XPS, 4112 ALC293_FIXUP_LENOVO_SPK_NOISE, 4113 ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, 4114 ALC233_FIXUP_WUJIE_SPEAKERS, 4115 ALC233_FIXUP_LENOVO_L2MH_LOW_ENLED, 4116 ALC255_FIXUP_DELL_SPK_NOISE, 4117 ALC225_FIXUP_DISABLE_MIC_VREF, 4118 ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 4119 ALC295_FIXUP_DISABLE_DAC3, 4120 ALC285_FIXUP_SPEAKER2_TO_DAC1, 4121 ALC285_FIXUP_YOGA_SPEAKER2_TO_DAC1, 4122 ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1, 4123 ALC285_FIXUP_ASUS_HEADSET_MIC, 4124 ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS, 4125 ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1, 4126 ALC285_FIXUP_ASUS_I2C_HEADSET_MIC, 4127 ALC280_FIXUP_HP_HEADSET_MIC, 4128 ALC221_FIXUP_HP_FRONT_MIC, 4129 ALC292_FIXUP_TPT460, 4130 ALC298_FIXUP_SPK_VOLUME, 4131 ALC298_FIXUP_LENOVO_SPK_VOLUME, 4132 ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, 4133 ALC269_FIXUP_ATIV_BOOK_8, 4134 ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE, 4135 ALC221_FIXUP_HP_MIC_NO_PRESENCE, 4136 ALC256_FIXUP_ASUS_HEADSET_MODE, 4137 ALC256_FIXUP_ASUS_MIC, 4138 ALC256_FIXUP_ASUS_AIO_GPIO2, 4139 ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, 4140 ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, 4141 ALC233_FIXUP_LENOVO_MULTI_CODECS, 4142 ALC233_FIXUP_ACER_HEADSET_MIC, 4143 ALC294_FIXUP_LENOVO_MIC_LOCATION, 4144 ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, 4145 ALC225_FIXUP_S3_POP_NOISE, 4146 ALC700_FIXUP_INTEL_REFERENCE, 4147 ALC700_FIXUP_INTEL_HADES_CANYON, 4148 ALC274_FIXUP_DELL_BIND_DACS, 4149 ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, 4150 ALC298_FIXUP_TPT470_DOCK_FIX, 4151 ALC298_FIXUP_TPT470_DOCK, 4152 ALC255_FIXUP_DUMMY_LINEOUT_VERB, 4153 ALC255_FIXUP_DELL_HEADSET_MIC, 4154 ALC256_FIXUP_HUAWEI_MACH_WX9_PINS, 4155 ALC298_FIXUP_HUAWEI_MBX_STEREO, 4156 ALC295_FIXUP_HP_X360, 4157 ALC295_FIXUP_HP_PAVILION_X360, 4158 ALC221_FIXUP_HP_HEADSET_MIC, 4159 ALC285_FIXUP_LENOVO_HEADPHONE_NOISE, 4160 ALC295_FIXUP_HP_AUTO_MUTE, 4161 ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE, 4162 ALC294_FIXUP_ASUS_MIC, 4163 ALC294_FIXUP_ASUS_HEADSET_MIC, 4164 ALC294_FIXUP_ASUS_I2C_HEADSET_MIC, 4165 ALC294_FIXUP_ASUS_SPI_HEADSET_MIC, 4166 ALC294_FIXUP_ASUS_SPK, 4167 ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE, 4168 ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE, 4169 ALC255_FIXUP_ACER_HEADSET_MIC, 4170 ALC295_FIXUP_CHROME_BOOK, 4171 ALC225_FIXUP_HEADSET_JACK, 4172 ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE, 4173 ALC225_FIXUP_WYSE_AUTO_MUTE, 4174 ALC225_FIXUP_WYSE_DISABLE_MIC_VREF, 4175 ALC286_FIXUP_ACER_AIO_HEADSET_MIC, 4176 ALC256_FIXUP_ASUS_HEADSET_MIC, 4177 ALC256_FIXUP_ASUS_MIC_NO_PRESENCE, 4178 ALC255_FIXUP_PREDATOR_SUBWOOFER, 4179 ALC299_FIXUP_PREDATOR_SPK, 4180 ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, 4181 ALC289_FIXUP_DELL_SPK1, 4182 ALC289_FIXUP_DELL_SPK2, 4183 ALC289_FIXUP_DUAL_SPK, 4184 ALC289_FIXUP_RTK_AMP_DUAL_SPK, 4185 ALC294_FIXUP_SPK2_TO_DAC1, 4186 ALC294_FIXUP_ASUS_DUAL_SPK, 4187 ALC285_FIXUP_THINKPAD_X1_GEN7, 4188 ALC285_FIXUP_THINKPAD_HEADSET_JACK, 4189 ALC294_FIXUP_ASUS_ALLY, 4190 ALC294_FIXUP_ASUS_ALLY_PINS, 4191 ALC294_FIXUP_ASUS_ALLY_VERBS, 4192 ALC294_FIXUP_ASUS_HPE, 4193 ALC294_FIXUP_ASUS_COEF_1B, 4194 ALC294_FIXUP_ASUS_GX502_HP, 4195 ALC294_FIXUP_ASUS_GX502_PINS, 4196 ALC294_FIXUP_ASUS_GX502_VERBS, 4197 ALC294_FIXUP_ASUS_GU502_HP, 4198 ALC294_FIXUP_ASUS_GU502_PINS, 4199 ALC294_FIXUP_ASUS_GU502_VERBS, 4200 ALC294_FIXUP_ASUS_G513_PINS, 4201 ALC285_FIXUP_ASUS_G533Z_PINS, 4202 ALC285_FIXUP_HP_GPIO_LED, 4203 ALC285_FIXUP_HP_MUTE_LED, 4204 ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED, 4205 ALC245_FIXUP_HP_ENVY_X360_MUTE_LED, 4206 ALC285_FIXUP_HP_BEEP_MICMUTE_LED, 4207 ALC236_FIXUP_HP_MUTE_LED_COEFBIT2, 4208 ALC236_FIXUP_HP_GPIO_LED, 4209 ALC236_FIXUP_HP_MUTE_LED, 4210 ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF, 4211 ALC236_FIXUP_HP_15_FD0XXX, 4212 ALC236_FIXUP_LENOVO_INV_DMIC, 4213 ALC298_FIXUP_SAMSUNG_AMP, 4214 ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS, 4215 ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS, 4216 ALC298_FIXUP_LG_GRAM_STYLE_14, 4217 ALC298_FIXUP_RAZER_BLADE16_2025_PINS, 4218 ALC298_FIXUP_RAZER_BLADE16_2025, 4219 ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, 4220 ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, 4221 ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, 4222 ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS, 4223 ALC269VC_FIXUP_ACER_HEADSET_MIC, 4224 ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE, 4225 ALC289_FIXUP_ASUS_GA401, 4226 ALC289_FIXUP_ASUS_GA502, 4227 ALC256_FIXUP_ACER_MIC_NO_PRESENCE, 4228 ALC285_FIXUP_HP_GPIO_AMP_INIT, 4229 ALC269_FIXUP_CZC_B20, 4230 ALC269_FIXUP_CZC_TMI, 4231 ALC269_FIXUP_CZC_L101, 4232 ALC269_FIXUP_LEMOTE_A1802, 4233 ALC269_FIXUP_LEMOTE_A190X, 4234 ALC256_FIXUP_INTEL_NUC8_RUGGED, 4235 ALC233_FIXUP_INTEL_NUC8_DMIC, 4236 ALC256_FIXUP_INTEL_NUC10, 4237 ALC255_FIXUP_XIAOMI_HEADSET_MIC, 4238 ALC274_FIXUP_HP_MIC, 4239 ALC274_FIXUP_HP_HEADSET_MIC, 4240 ALC274_FIXUP_HP_ENVY_GPIO, 4241 ALC274_FIXUP_ASUS_ZEN_AIO_27, 4242 ALC256_FIXUP_ASUS_HPE, 4243 ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK, 4244 ALC287_FIXUP_HP_GPIO_LED, 4245 ALC256_FIXUP_HP_HEADSET_MIC, 4246 ALC245_FIXUP_HP_GPIO_LED, 4247 ALC236_FIXUP_DELL_AIO_HEADSET_MIC, 4248 ALC282_FIXUP_ACER_DISABLE_LINEOUT, 4249 ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST, 4250 ALC256_FIXUP_ACER_HEADSET_MIC, 4251 ALC285_FIXUP_IDEAPAD_S740_COEF, 4252 ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST, 4253 ALC295_FIXUP_ASUS_DACS, 4254 ALC295_FIXUP_HP_OMEN, 4255 ALC285_FIXUP_HP_SPECTRE_X360, 4256 ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, 4257 ALC623_FIXUP_LENOVO_THINKSTATION_P340, 4258 ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, 4259 ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST, 4260 ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS, 4261 ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE, 4262 ALC287_FIXUP_YOGA7_14ITL_SPEAKERS, 4263 ALC298_FIXUP_LENOVO_C940_DUET7, 4264 ALC287_FIXUP_LENOVO_YOGA_BOOK_9I, 4265 ALC287_FIXUP_LENOVO_YOGA_PRO7, 4266 ALC287_FIXUP_LENOVO_XPAD_HEADSET_JACK, 4267 ALC287_FIXUP_13S_GEN2_SPEAKERS, 4268 ALC256_FIXUP_SET_COEF_DEFAULTS, 4269 ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE, 4270 ALC233_FIXUP_NO_AUDIO_JACK, 4271 ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME, 4272 ALC256_FIXUP_XIAOMI_PRO15_RESUME, 4273 ALC285_FIXUP_LEGION_Y9000X_SPEAKERS, 4274 ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE, 4275 ALC287_FIXUP_LEGION_16ACHG6, 4276 ALC287_FIXUP_CS35L41_I2C_2, 4277 ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED, 4278 ALC287_FIXUP_CS35L41_I2C_4, 4279 ALC245_FIXUP_CS35L41_SPI_1, 4280 ALC245_FIXUP_CS35L41_SPI_2, 4281 ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED, 4282 ALC245_FIXUP_CS35L41_SPI_4, 4283 ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED, 4284 ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED, 4285 ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE, 4286 ALC295_FIXUP_FRAMEWORK_LAPTOP_LIMIT_INT_MIC_BOOST, 4287 ALC287_FIXUP_LEGION_16ITHG6, 4288 ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK, 4289 ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN, 4290 ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN, 4291 ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS, 4292 ALC236_FIXUP_DELL_DUAL_CODECS, 4293 ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI, 4294 ALC287_FIXUP_TAS2781_I2C, 4295 ALC287_FIXUP_ASUS_ALLY_X, 4296 ALC287_FIXUP_ASUS_ALLY_X_SPEAKER, 4297 ALC287_FIXUP_ASUS_ALLY_X_I2C, 4298 ALC295_FIXUP_DELL_TAS2781_I2C, 4299 ALC245_FIXUP_TAS2781_SPI_2, 4300 ALC287_FIXUP_TXNW2781_I2C, 4301 ALC287_FIXUP_TXNW2781_I2C_ASUS, 4302 ALC287_FIXUP_YOGA7_14ARB7_I2C, 4303 ALC245_FIXUP_HP_MUTE_LED_COEFBIT, 4304 ALC245_FIXUP_HP_MUTE_LED_V1_COEFBIT, 4305 ALC245_FIXUP_HP_MUTE_LED_V2_COEFBIT, 4306 ALC245_FIXUP_HP_X360_MUTE_LEDS, 4307 ALC287_FIXUP_THINKPAD_I2S_SPK, 4308 ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD, 4309 ALC2XX_FIXUP_HEADSET_MIC, 4310 ALC289_FIXUP_DELL_CS35L41_SPI_2, 4311 ALC256_FIXUP_ACER_SFG16_MICMUTE_LED, 4312 ALC256_FIXUP_HEADPHONE_AMP_VOL, 4313 ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX, 4314 ALC245_FIXUP_HP_SPECTRE_X360_16_AA0XXX, 4315 ALC245_FIXUP_HP_ZBOOK_FIREFLY_G12A, 4316 ALC285_FIXUP_ASUS_GA403U, 4317 ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC, 4318 ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1, 4319 ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC, 4320 ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1, 4321 ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318, 4322 ALC256_FIXUP_CHROME_BOOK, 4323 ALC245_FIXUP_CLEVO_NOISY_MIC, 4324 ALC245_FIXUP_MINISFORUM_JACK_DETECT, 4325 ALC269_FIXUP_VAIO_VJFH52_MIC_NO_PRESENCE, 4326 ALC233_FIXUP_MEDION_MTL_SPK, 4327 ALC233_FIXUP_STARLABS_STARFIGHTER, 4328 ALC294_FIXUP_BASS_SPEAKER_15, 4329 ALC283_FIXUP_DELL_HP_RESUME, 4330 ALC294_FIXUP_ASUS_CS35L41_SPI_2, 4331 ALC274_FIXUP_HP_AIO_BIND_DACS, 4332 ALC287_FIXUP_PREDATOR_SPK_CS35L41_I2C_2, 4333 ALC285_FIXUP_ASUS_GA605K_HEADSET_MIC, 4334 ALC269_FIXUP_POSITIVO_P15X_HEADSET_MIC, 4335 ALC289_FIXUP_ASUS_ZEPHYRUS_DUAL_SPK, 4336 ALC256_FIXUP_VAIO_RPL_MIC_NO_PRESENCE, 4337 ALC245_FIXUP_HP_TAS2781_SPI_MUTE_LED, 4338 ALC245_FIXUP_HP_TAS2781_I2C_MUTE_LED, 4339 ALC245_FIXUP_HP_TAS2781_I2C_MUTE_LED_INVERTED, 4340 ALC288_FIXUP_SURFACE_SWAP_DACS, 4341 ALC236_FIXUP_HP_MUTE_LED_MICMUTE_GPIO, 4342 ALC233_FIXUP_LENOVO_GPIO2_MIC_HOTKEY, 4343 ALC245_FIXUP_BASS_HP_DAC, 4344 ALC245_FIXUP_ACER_MICMUTE_LED, 4345 ALC245_FIXUP_CS35L41_I2C_2_MUTE_LED, 4346 ALC236_FIXUP_HP_DMIC, 4347 ALC256_FIXUP_HONOR_MRB_XXX_M1020_AUDIO, 4348 ALC245_FIXUP_HP_ENVY_X360_15_FH0XXX, 4349 ALC287_FIXUP_ACER_MICMUTE_LED, 4350 ALC236_FIXUP_DELL_HP_POP_NOISE, 4351 ALC274_FIXUP_HP_89E9_GPIO, 4352 ALC274_FIXUP_HP_VERBS, 4353 ALC287_FIXUP_AW88399_I2C_2, 4354 ALC287_FIXUP_LENOVO_LEGION_AW88399, 4355 ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN_HEADSET, 4356 ALC285_LENOVO_DAC_RENAME, 4357 ALC287_FIXUP_YOGA9_SPEAKER2_TO_DAC1, 4358 }; 4359 4360 /* A special fixup for Lenovo C940 and Yoga Duet 7; 4361 * both have the very same PCI SSID, and we need to apply different fixups 4362 * depending on the codec ID 4363 */ 4364 static void alc298_fixup_lenovo_c940_duet7(struct hda_codec *codec, 4365 const struct hda_fixup *fix, 4366 int action) 4367 { 4368 int id; 4369 4370 if (codec->core.vendor_id == 0x10ec0298) 4371 id = ALC298_FIXUP_LENOVO_SPK_VOLUME; /* C940 */ 4372 else 4373 id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* Duet 7 */ 4374 __snd_hda_apply_fixup(codec, id, action, 0); 4375 } 4376 4377 /* A special fixup for Lenovo Yoga 9i and Yoga Book 9i 13IRU8 4378 * both have the very same PCI SSID and vendor ID, so we need 4379 * to apply different fixups depending on the subsystem ID 4380 */ 4381 static void alc287_fixup_lenovo_yoga_book_9i(struct hda_codec *codec, 4382 const struct hda_fixup *fix, 4383 int action) 4384 { 4385 int id; 4386 4387 if (codec->core.subsystem_id == 0x17aa3881) 4388 id = ALC287_FIXUP_TAS2781_I2C; /* Yoga Book 9i 13IRU8 */ 4389 else 4390 id = ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP; /* Yoga 9i */ 4391 __snd_hda_apply_fixup(codec, id, action, 0); 4392 } 4393 4394 static void alc700_fixup_intel_hades_canyon(struct hda_codec *codec, 4395 const struct hda_fixup *fix, 4396 int action) 4397 { 4398 /* 4399 * Windows may leave coef 0x1b bit 0x0400 cleared, causing broken 4400 * analog playback after rebooting into Linux. Restore the bit 4401 * during codec initialization. 4402 */ 4403 if (action == HDA_FIXUP_ACT_INIT) 4404 alc_update_coef_idx(codec, 0x1b, 0x0400, 0x0400); 4405 } 4406 4407 static const struct hda_fixup alc269_fixups[] = { 4408 [ALC298_FIXUP_RAZER_BLADE16_2025_PINS] = { 4409 .type = HDA_FIXUP_PINS, 4410 .v.pins = (const struct hda_pintbl[]) { 4411 { 0x14, 0x90170121 }, /* tweeter as internal speaker, seq 1 */ 4412 { 0x17, 0x90170120 }, /* woofer as internal speaker, seq 0 */ 4413 { } 4414 }, 4415 .chained = true, 4416 .chain_id = ALC298_FIXUP_RAZER_BLADE16_2025, 4417 }, 4418 [ALC298_FIXUP_RAZER_BLADE16_2025] = { 4419 .type = HDA_FIXUP_FUNC, 4420 .v.func = alc298_fixup_razer_blade16_2025, 4421 }, 4422 [ALC233_FIXUP_WUJIE_SPEAKERS] = { 4423 .type = HDA_FIXUP_PINS, 4424 .v.pins = (const struct hda_pintbl[]) { 4425 { 0x1b, 0x90170150 }, /* internal speaker */ 4426 { } 4427 }, 4428 }, 4429 [ALC269_FIXUP_GPIO2] = { 4430 .type = HDA_FIXUP_FUNC, 4431 .v.func = alc_fixup_gpio2, 4432 }, 4433 [ALC269_FIXUP_SONY_VAIO] = { 4434 .type = HDA_FIXUP_PINCTLS, 4435 .v.pins = (const struct hda_pintbl[]) { 4436 {0x19, PIN_VREFGRD}, 4437 {} 4438 } 4439 }, 4440 [ALC275_FIXUP_SONY_VAIO_GPIO2] = { 4441 .type = HDA_FIXUP_FUNC, 4442 .v.func = alc275_fixup_gpio4_off, 4443 .chained = true, 4444 .chain_id = ALC269_FIXUP_SONY_VAIO 4445 }, 4446 [ALC269_FIXUP_DELL_M101Z] = { 4447 .type = HDA_FIXUP_VERBS, 4448 .v.verbs = (const struct hda_verb[]) { 4449 /* Enables internal speaker */ 4450 {0x20, AC_VERB_SET_COEF_INDEX, 13}, 4451 {0x20, AC_VERB_SET_PROC_COEF, 0x4040}, 4452 {} 4453 } 4454 }, 4455 [ALC269_FIXUP_SKU_IGNORE] = { 4456 .type = HDA_FIXUP_FUNC, 4457 .v.func = alc_fixup_sku_ignore, 4458 }, 4459 [ALC269_FIXUP_ASUS_G73JW] = { 4460 .type = HDA_FIXUP_PINS, 4461 .v.pins = (const struct hda_pintbl[]) { 4462 { 0x17, 0x99130111 }, /* subwoofer */ 4463 { } 4464 } 4465 }, 4466 [ALC269_FIXUP_ASUS_N7601ZM_PINS] = { 4467 .type = HDA_FIXUP_PINS, 4468 .v.pins = (const struct hda_pintbl[]) { 4469 { 0x19, 0x03A11050 }, 4470 { 0x1a, 0x03A11C30 }, 4471 { 0x21, 0x03211420 }, 4472 { } 4473 } 4474 }, 4475 [ALC269_FIXUP_ASUS_N7601ZM] = { 4476 .type = HDA_FIXUP_VERBS, 4477 .v.verbs = (const struct hda_verb[]) { 4478 {0x20, AC_VERB_SET_COEF_INDEX, 0x62}, 4479 {0x20, AC_VERB_SET_PROC_COEF, 0xa007}, 4480 {0x20, AC_VERB_SET_COEF_INDEX, 0x10}, 4481 {0x20, AC_VERB_SET_PROC_COEF, 0x8420}, 4482 {0x20, AC_VERB_SET_COEF_INDEX, 0x0f}, 4483 {0x20, AC_VERB_SET_PROC_COEF, 0x7774}, 4484 { } 4485 }, 4486 .chained = true, 4487 .chain_id = ALC269_FIXUP_ASUS_N7601ZM_PINS, 4488 }, 4489 [ALC269_FIXUP_LENOVO_EAPD] = { 4490 .type = HDA_FIXUP_VERBS, 4491 .v.verbs = (const struct hda_verb[]) { 4492 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0}, 4493 {} 4494 } 4495 }, 4496 [ALC275_FIXUP_SONY_HWEQ] = { 4497 .type = HDA_FIXUP_FUNC, 4498 .v.func = alc269_fixup_hweq, 4499 .chained = true, 4500 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2 4501 }, 4502 [ALC275_FIXUP_SONY_DISABLE_AAMIX] = { 4503 .type = HDA_FIXUP_FUNC, 4504 .v.func = alc_fixup_disable_aamix, 4505 .chained = true, 4506 .chain_id = ALC269_FIXUP_SONY_VAIO 4507 }, 4508 [ALC271_FIXUP_DMIC] = { 4509 .type = HDA_FIXUP_FUNC, 4510 .v.func = alc271_fixup_dmic, 4511 }, 4512 [ALC269_FIXUP_PCM_44K] = { 4513 .type = HDA_FIXUP_FUNC, 4514 .v.func = alc269_fixup_pcm_44k, 4515 .chained = true, 4516 .chain_id = ALC269_FIXUP_QUANTA_MUTE 4517 }, 4518 [ALC269_FIXUP_STEREO_DMIC] = { 4519 .type = HDA_FIXUP_FUNC, 4520 .v.func = alc269_fixup_stereo_dmic, 4521 }, 4522 [ALC269_FIXUP_HEADSET_MIC] = { 4523 .type = HDA_FIXUP_FUNC, 4524 .v.func = alc_fixup_headset_mic, 4525 }, 4526 [ALC269_FIXUP_QUANTA_MUTE] = { 4527 .type = HDA_FIXUP_FUNC, 4528 .v.func = alc269_fixup_quanta_mute, 4529 }, 4530 [ALC269_FIXUP_LIFEBOOK] = { 4531 .type = HDA_FIXUP_PINS, 4532 .v.pins = (const struct hda_pintbl[]) { 4533 { 0x1a, 0x2101103f }, /* dock line-out */ 4534 { 0x1b, 0x23a11040 }, /* dock mic-in */ 4535 { } 4536 }, 4537 .chained = true, 4538 .chain_id = ALC269_FIXUP_QUANTA_MUTE 4539 }, 4540 [ALC269_FIXUP_LIFEBOOK_EXTMIC] = { 4541 .type = HDA_FIXUP_PINS, 4542 .v.pins = (const struct hda_pintbl[]) { 4543 { 0x19, 0x01a1903c }, /* headset mic, with jack detect */ 4544 { } 4545 }, 4546 }, 4547 [ALC269_FIXUP_LIFEBOOK_HP_PIN] = { 4548 .type = HDA_FIXUP_PINS, 4549 .v.pins = (const struct hda_pintbl[]) { 4550 { 0x21, 0x0221102f }, /* HP out */ 4551 { } 4552 }, 4553 }, 4554 [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = { 4555 .type = HDA_FIXUP_FUNC, 4556 .v.func = alc269_fixup_pincfg_no_hp_to_lineout, 4557 }, 4558 [ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = { 4559 .type = HDA_FIXUP_FUNC, 4560 .v.func = alc269_fixup_pincfg_U7x7_headset_mic, 4561 }, 4562 [ALC269VB_FIXUP_INFINIX_ZERO_BOOK_13] = { 4563 .type = HDA_FIXUP_PINS, 4564 .v.pins = (const struct hda_pintbl[]) { 4565 { 0x14, 0x90170151 }, /* use as internal speaker (LFE) */ 4566 { 0x1b, 0x90170152 }, /* use as internal speaker (back) */ 4567 { } 4568 }, 4569 .chained = true, 4570 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST 4571 }, 4572 [ALC269VC_FIXUP_INFINIX_Y4_MAX] = { 4573 .type = HDA_FIXUP_PINS, 4574 .v.pins = (const struct hda_pintbl[]) { 4575 { 0x1b, 0x90170150 }, /* use as internal speaker */ 4576 { } 4577 }, 4578 .chained = true, 4579 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST 4580 }, 4581 [ALC269VB_FIXUP_INFINIX_INBOOK_X3_SLIM] = { 4582 .type = HDA_FIXUP_PINS, 4583 .v.pins = (const struct hda_pintbl[]) { 4584 { 0x14, 0x411111f0 }, /* disable, not connected */ 4585 { 0x1b, 0x90170110 }, /* use as internal speaker */ 4586 { } 4587 }, 4588 }, 4589 [ALC269VC_FIXUP_LUNNEN_GROUND_14] = { 4590 .type = HDA_FIXUP_PINS, 4591 .v.pins = (const struct hda_pintbl[]) { 4592 { 0x1b, 0x90170150 }, /* internal speaker */ 4593 { } 4594 }, 4595 }, 4596 [ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO] = { 4597 .type = HDA_FIXUP_PINS, 4598 .v.pins = (const struct hda_pintbl[]) { 4599 { 0x18, 0x03a19020 }, /* headset mic */ 4600 { 0x1b, 0x90170150 }, /* speaker */ 4601 { } 4602 }, 4603 }, 4604 [ALC269_FIXUP_AMIC] = { 4605 .type = HDA_FIXUP_PINS, 4606 .v.pins = (const struct hda_pintbl[]) { 4607 { 0x14, 0x99130110 }, /* speaker */ 4608 { 0x15, 0x0121401f }, /* HP out */ 4609 { 0x18, 0x01a19c20 }, /* mic */ 4610 { 0x19, 0x99a3092f }, /* int-mic */ 4611 { } 4612 }, 4613 }, 4614 [ALC269_FIXUP_DMIC] = { 4615 .type = HDA_FIXUP_PINS, 4616 .v.pins = (const struct hda_pintbl[]) { 4617 { 0x12, 0x99a3092f }, /* int-mic */ 4618 { 0x14, 0x99130110 }, /* speaker */ 4619 { 0x15, 0x0121401f }, /* HP out */ 4620 { 0x18, 0x01a19c20 }, /* mic */ 4621 { } 4622 }, 4623 }, 4624 [ALC269VB_FIXUP_AMIC] = { 4625 .type = HDA_FIXUP_PINS, 4626 .v.pins = (const struct hda_pintbl[]) { 4627 { 0x14, 0x99130110 }, /* speaker */ 4628 { 0x18, 0x01a19c20 }, /* mic */ 4629 { 0x19, 0x99a3092f }, /* int-mic */ 4630 { 0x21, 0x0121401f }, /* HP out */ 4631 { } 4632 }, 4633 }, 4634 [ALC269VB_FIXUP_DMIC] = { 4635 .type = HDA_FIXUP_PINS, 4636 .v.pins = (const struct hda_pintbl[]) { 4637 { 0x12, 0x99a3092f }, /* int-mic */ 4638 { 0x14, 0x99130110 }, /* speaker */ 4639 { 0x18, 0x01a19c20 }, /* mic */ 4640 { 0x21, 0x0121401f }, /* HP out */ 4641 { } 4642 }, 4643 }, 4644 [ALC269_FIXUP_HP_MUTE_LED] = { 4645 .type = HDA_FIXUP_FUNC, 4646 .v.func = alc269_fixup_hp_mute_led, 4647 }, 4648 [ALC269_FIXUP_HP_MUTE_LED_MIC1] = { 4649 .type = HDA_FIXUP_FUNC, 4650 .v.func = alc269_fixup_hp_mute_led_mic1, 4651 }, 4652 [ALC269_FIXUP_HP_MUTE_LED_MIC2] = { 4653 .type = HDA_FIXUP_FUNC, 4654 .v.func = alc269_fixup_hp_mute_led_mic2, 4655 }, 4656 [ALC269_FIXUP_HP_MUTE_LED_MIC3] = { 4657 .type = HDA_FIXUP_FUNC, 4658 .v.func = alc269_fixup_hp_mute_led_mic3, 4659 .chained = true, 4660 .chain_id = ALC295_FIXUP_HP_AUTO_MUTE 4661 }, 4662 [ALC269_FIXUP_HP_GPIO_LED] = { 4663 .type = HDA_FIXUP_FUNC, 4664 .v.func = alc269_fixup_hp_gpio_led, 4665 }, 4666 [ALC269_FIXUP_HP_GPIO_MIC1_LED] = { 4667 .type = HDA_FIXUP_FUNC, 4668 .v.func = alc269_fixup_hp_gpio_mic1_led, 4669 }, 4670 [ALC269_FIXUP_HP_LINE1_MIC1_LED] = { 4671 .type = HDA_FIXUP_FUNC, 4672 .v.func = alc269_fixup_hp_line1_mic1_led, 4673 }, 4674 [ALC269_FIXUP_INV_DMIC] = { 4675 .type = HDA_FIXUP_FUNC, 4676 .v.func = alc_fixup_inv_dmic, 4677 }, 4678 [ALC269_FIXUP_NO_SHUTUP] = { 4679 .type = HDA_FIXUP_FUNC, 4680 .v.func = alc_fixup_no_shutup, 4681 }, 4682 [ALC269_FIXUP_LENOVO_DOCK] = { 4683 .type = HDA_FIXUP_PINS, 4684 .v.pins = (const struct hda_pintbl[]) { 4685 { 0x19, 0x23a11040 }, /* dock mic */ 4686 { 0x1b, 0x2121103f }, /* dock headphone */ 4687 { } 4688 }, 4689 .chained = true, 4690 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT 4691 }, 4692 [ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST] = { 4693 .type = HDA_FIXUP_FUNC, 4694 .v.func = alc269_fixup_limit_int_mic_boost, 4695 .chained = true, 4696 .chain_id = ALC269_FIXUP_LENOVO_DOCK, 4697 }, 4698 [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = { 4699 .type = HDA_FIXUP_FUNC, 4700 .v.func = alc269_fixup_pincfg_no_hp_to_lineout, 4701 .chained = true, 4702 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 4703 }, 4704 [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = { 4705 .type = HDA_FIXUP_PINS, 4706 .v.pins = (const struct hda_pintbl[]) { 4707 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 4708 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 4709 { } 4710 }, 4711 .chained = true, 4712 .chain_id = ALC269_FIXUP_HEADSET_MODE 4713 }, 4714 [ALC269_FIXUP_DELL1_LIMIT_INT_MIC_BOOST] = { 4715 .type = HDA_FIXUP_FUNC, 4716 .v.func = alc269_fixup_limit_int_mic_boost, 4717 .chained = true, 4718 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE 4719 }, 4720 [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = { 4721 .type = HDA_FIXUP_PINS, 4722 .v.pins = (const struct hda_pintbl[]) { 4723 { 0x16, 0x21014020 }, /* dock line out */ 4724 { 0x19, 0x21a19030 }, /* dock mic */ 4725 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 4726 { } 4727 }, 4728 .chained = true, 4729 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 4730 }, 4731 [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = { 4732 .type = HDA_FIXUP_PINS, 4733 .v.pins = (const struct hda_pintbl[]) { 4734 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 4735 { } 4736 }, 4737 .chained = true, 4738 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 4739 }, 4740 [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = { 4741 .type = HDA_FIXUP_PINS, 4742 .v.pins = (const struct hda_pintbl[]) { 4743 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 4744 { 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 4745 { } 4746 }, 4747 .chained = true, 4748 .chain_id = ALC269_FIXUP_HEADSET_MODE 4749 }, 4750 [ALC269_FIXUP_HEADSET_MODE] = { 4751 .type = HDA_FIXUP_FUNC, 4752 .v.func = alc_fixup_headset_mode, 4753 .chained = true, 4754 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 4755 }, 4756 [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = { 4757 .type = HDA_FIXUP_FUNC, 4758 .v.func = alc_fixup_headset_mode_no_hp_mic, 4759 }, 4760 [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = { 4761 .type = HDA_FIXUP_PINS, 4762 .v.pins = (const struct hda_pintbl[]) { 4763 { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */ 4764 { } 4765 }, 4766 .chained = true, 4767 .chain_id = ALC269_FIXUP_HEADSET_MODE, 4768 }, 4769 [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = { 4770 .type = HDA_FIXUP_PINS, 4771 .v.pins = (const struct hda_pintbl[]) { 4772 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 4773 { } 4774 }, 4775 .chained = true, 4776 .chain_id = ALC269_FIXUP_HEADSET_MIC 4777 }, 4778 [ALC256_FIXUP_HUAWEI_MACH_WX9_PINS] = { 4779 .type = HDA_FIXUP_PINS, 4780 .v.pins = (const struct hda_pintbl[]) { 4781 {0x12, 0x90a60130}, 4782 {0x13, 0x40000000}, 4783 {0x14, 0x90170110}, 4784 {0x18, 0x411111f0}, 4785 {0x19, 0x04a11040}, 4786 {0x1a, 0x411111f0}, 4787 {0x1b, 0x90170112}, 4788 {0x1d, 0x40759a05}, 4789 {0x1e, 0x411111f0}, 4790 {0x21, 0x04211020}, 4791 { } 4792 }, 4793 .chained = true, 4794 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 4795 }, 4796 [ALC298_FIXUP_HUAWEI_MBX_STEREO] = { 4797 .type = HDA_FIXUP_FUNC, 4798 .v.func = alc298_fixup_huawei_mbx_stereo, 4799 .chained = true, 4800 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 4801 }, 4802 [ALC269_FIXUP_ASUS_X101_FUNC] = { 4803 .type = HDA_FIXUP_FUNC, 4804 .v.func = alc269_fixup_x101_headset_mic, 4805 }, 4806 [ALC269_FIXUP_ASUS_X101_VERB] = { 4807 .type = HDA_FIXUP_VERBS, 4808 .v.verbs = (const struct hda_verb[]) { 4809 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 4810 {0x20, AC_VERB_SET_COEF_INDEX, 0x08}, 4811 {0x20, AC_VERB_SET_PROC_COEF, 0x0310}, 4812 { } 4813 }, 4814 .chained = true, 4815 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC 4816 }, 4817 [ALC269_FIXUP_ASUS_X101] = { 4818 .type = HDA_FIXUP_PINS, 4819 .v.pins = (const struct hda_pintbl[]) { 4820 { 0x18, 0x04a1182c }, /* Headset mic */ 4821 { } 4822 }, 4823 .chained = true, 4824 .chain_id = ALC269_FIXUP_ASUS_X101_VERB 4825 }, 4826 [ALC271_FIXUP_AMIC_MIC2] = { 4827 .type = HDA_FIXUP_PINS, 4828 .v.pins = (const struct hda_pintbl[]) { 4829 { 0x14, 0x99130110 }, /* speaker */ 4830 { 0x19, 0x01a19c20 }, /* mic */ 4831 { 0x1b, 0x99a7012f }, /* int-mic */ 4832 { 0x21, 0x0121401f }, /* HP out */ 4833 { } 4834 }, 4835 }, 4836 [ALC271_FIXUP_HP_GATE_MIC_JACK] = { 4837 .type = HDA_FIXUP_FUNC, 4838 .v.func = alc271_hp_gate_mic_jack, 4839 .chained = true, 4840 .chain_id = ALC271_FIXUP_AMIC_MIC2, 4841 }, 4842 [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = { 4843 .type = HDA_FIXUP_FUNC, 4844 .v.func = alc269_fixup_limit_int_mic_boost, 4845 .chained = true, 4846 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK, 4847 }, 4848 [ALC269_FIXUP_ACER_AC700] = { 4849 .type = HDA_FIXUP_PINS, 4850 .v.pins = (const struct hda_pintbl[]) { 4851 { 0x12, 0x99a3092f }, /* int-mic */ 4852 { 0x14, 0x99130110 }, /* speaker */ 4853 { 0x18, 0x03a11c20 }, /* mic */ 4854 { 0x1e, 0x0346101e }, /* SPDIF1 */ 4855 { 0x21, 0x0321101f }, /* HP out */ 4856 { } 4857 }, 4858 .chained = true, 4859 .chain_id = ALC271_FIXUP_DMIC, 4860 }, 4861 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = { 4862 .type = HDA_FIXUP_FUNC, 4863 .v.func = alc269_fixup_limit_int_mic_boost 4864 }, 4865 [ALC269_FIXUP_THINKPAD_LIMIT_INT_MIC_BOOST] = { 4866 .type = HDA_FIXUP_FUNC, 4867 .v.func = alc269_fixup_limit_int_mic_boost, 4868 .chained = true, 4869 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 4870 }, 4871 [ALC269VB_FIXUP_ASUS_ZENBOOK] = { 4872 .type = HDA_FIXUP_FUNC, 4873 .v.func = alc269_fixup_limit_int_mic_boost, 4874 .chained = true, 4875 .chain_id = ALC269VB_FIXUP_DMIC, 4876 }, 4877 [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = { 4878 .type = HDA_FIXUP_VERBS, 4879 .v.verbs = (const struct hda_verb[]) { 4880 /* class-D output amp +5dB */ 4881 { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 }, 4882 { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 }, 4883 {} 4884 }, 4885 .chained = true, 4886 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK, 4887 }, 4888 [ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE] = { 4889 .type = HDA_FIXUP_PINS, 4890 .v.pins = (const struct hda_pintbl[]) { 4891 { 0x18, 0x01a110f0 }, /* use as headset mic */ 4892 { } 4893 }, 4894 .chained = true, 4895 .chain_id = ALC269_FIXUP_HEADSET_MIC 4896 }, 4897 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = { 4898 .type = HDA_FIXUP_FUNC, 4899 .v.func = alc269_fixup_limit_int_mic_boost, 4900 .chained = true, 4901 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1, 4902 }, 4903 [ALC269VB_FIXUP_ORDISSIMO_EVE2] = { 4904 .type = HDA_FIXUP_PINS, 4905 .v.pins = (const struct hda_pintbl[]) { 4906 { 0x12, 0x99a3092f }, /* int-mic */ 4907 { 0x18, 0x03a11d20 }, /* mic */ 4908 { 0x19, 0x411111f0 }, /* Unused bogus pin */ 4909 { } 4910 }, 4911 }, 4912 [ALC283_FIXUP_CHROME_BOOK] = { 4913 .type = HDA_FIXUP_FUNC, 4914 .v.func = alc283_fixup_chromebook, 4915 }, 4916 [ALC283_FIXUP_SENSE_COMBO_JACK] = { 4917 .type = HDA_FIXUP_FUNC, 4918 .v.func = alc283_fixup_sense_combo_jack, 4919 .chained = true, 4920 .chain_id = ALC283_FIXUP_CHROME_BOOK, 4921 }, 4922 [ALC282_FIXUP_ASUS_TX300] = { 4923 .type = HDA_FIXUP_FUNC, 4924 .v.func = alc282_fixup_asus_tx300, 4925 }, 4926 [ALC283_FIXUP_INT_MIC] = { 4927 .type = HDA_FIXUP_VERBS, 4928 .v.verbs = (const struct hda_verb[]) { 4929 {0x20, AC_VERB_SET_COEF_INDEX, 0x1a}, 4930 {0x20, AC_VERB_SET_PROC_COEF, 0x0011}, 4931 { } 4932 }, 4933 .chained = true, 4934 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST 4935 }, 4936 [ALC290_FIXUP_SUBWOOFER_HSJACK] = { 4937 .type = HDA_FIXUP_PINS, 4938 .v.pins = (const struct hda_pintbl[]) { 4939 { 0x17, 0x90170112 }, /* subwoofer */ 4940 { } 4941 }, 4942 .chained = true, 4943 .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, 4944 }, 4945 [ALC290_FIXUP_SUBWOOFER] = { 4946 .type = HDA_FIXUP_PINS, 4947 .v.pins = (const struct hda_pintbl[]) { 4948 { 0x17, 0x90170112 }, /* subwoofer */ 4949 { } 4950 }, 4951 .chained = true, 4952 .chain_id = ALC290_FIXUP_MONO_SPEAKERS, 4953 }, 4954 [ALC290_FIXUP_MONO_SPEAKERS] = { 4955 .type = HDA_FIXUP_FUNC, 4956 .v.func = alc290_fixup_mono_speakers, 4957 }, 4958 [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = { 4959 .type = HDA_FIXUP_FUNC, 4960 .v.func = alc290_fixup_mono_speakers, 4961 .chained = true, 4962 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, 4963 }, 4964 [ALC269_FIXUP_THINKPAD_ACPI] = { 4965 .type = HDA_FIXUP_FUNC, 4966 .v.func = alc_fixup_thinkpad_acpi, 4967 .chained = true, 4968 .chain_id = ALC269_FIXUP_SKU_IGNORE, 4969 }, 4970 [ALC269_FIXUP_LENOVO_XPAD_ACPI] = { 4971 .type = HDA_FIXUP_FUNC, 4972 .v.func = alc_fixup_ideapad_acpi, 4973 .chained = true, 4974 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 4975 }, 4976 [ALC269_FIXUP_DMIC_THINKPAD_ACPI] = { 4977 .type = HDA_FIXUP_FUNC, 4978 .v.func = alc_fixup_inv_dmic, 4979 .chained = true, 4980 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 4981 }, 4982 [ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = { 4983 .type = HDA_FIXUP_PINS, 4984 .v.pins = (const struct hda_pintbl[]) { 4985 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 4986 { } 4987 }, 4988 .chained = true, 4989 .chain_id = ALC255_FIXUP_HEADSET_MODE 4990 }, 4991 [ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = { 4992 .type = HDA_FIXUP_PINS, 4993 .v.pins = (const struct hda_pintbl[]) { 4994 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 4995 { } 4996 }, 4997 .chained = true, 4998 .chain_id = ALC255_FIXUP_HEADSET_MODE 4999 }, 5000 [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = { 5001 .type = HDA_FIXUP_PINS, 5002 .v.pins = (const struct hda_pintbl[]) { 5003 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 5004 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 5005 { } 5006 }, 5007 .chained = true, 5008 .chain_id = ALC255_FIXUP_HEADSET_MODE 5009 }, 5010 [ALC255_FIXUP_DELL1_LIMIT_INT_MIC_BOOST] = { 5011 .type = HDA_FIXUP_FUNC, 5012 .v.func = alc269_fixup_limit_int_mic_boost, 5013 .chained = true, 5014 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE 5015 }, 5016 [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = { 5017 .type = HDA_FIXUP_PINS, 5018 .v.pins = (const struct hda_pintbl[]) { 5019 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 5020 { } 5021 }, 5022 .chained = true, 5023 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC 5024 }, 5025 [ALC255_FIXUP_HEADSET_MODE] = { 5026 .type = HDA_FIXUP_FUNC, 5027 .v.func = alc_fixup_headset_mode_alc255, 5028 .chained = true, 5029 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 5030 }, 5031 [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = { 5032 .type = HDA_FIXUP_FUNC, 5033 .v.func = alc_fixup_headset_mode_alc255_no_hp_mic, 5034 }, 5035 [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = { 5036 .type = HDA_FIXUP_PINS, 5037 .v.pins = (const struct hda_pintbl[]) { 5038 { 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 5039 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 5040 { } 5041 }, 5042 .chained = true, 5043 .chain_id = ALC269_FIXUP_HEADSET_MODE 5044 }, 5045 [ALC292_FIXUP_TPT440_DOCK] = { 5046 .type = HDA_FIXUP_FUNC, 5047 .v.func = alc_fixup_tpt440_dock, 5048 .chained = true, 5049 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST 5050 }, 5051 [ALC292_FIXUP_TPT440] = { 5052 .type = HDA_FIXUP_FUNC, 5053 .v.func = alc_fixup_disable_aamix, 5054 .chained = true, 5055 .chain_id = ALC292_FIXUP_TPT440_DOCK, 5056 }, 5057 [ALC283_FIXUP_HEADSET_MIC] = { 5058 .type = HDA_FIXUP_PINS, 5059 .v.pins = (const struct hda_pintbl[]) { 5060 { 0x19, 0x04a110f0 }, 5061 { }, 5062 }, 5063 }, 5064 [ALC255_FIXUP_MIC_MUTE_LED] = { 5065 .type = HDA_FIXUP_FUNC, 5066 .v.func = alc_fixup_micmute_led, 5067 }, 5068 [ALC282_FIXUP_ASPIRE_V5_PINS] = { 5069 .type = HDA_FIXUP_PINS, 5070 .v.pins = (const struct hda_pintbl[]) { 5071 { 0x12, 0x90a60130 }, 5072 { 0x14, 0x90170110 }, 5073 { 0x17, 0x40000008 }, 5074 { 0x18, 0x411111f0 }, 5075 { 0x19, 0x01a1913c }, 5076 { 0x1a, 0x411111f0 }, 5077 { 0x1b, 0x411111f0 }, 5078 { 0x1d, 0x40f89b2d }, 5079 { 0x1e, 0x411111f0 }, 5080 { 0x21, 0x0321101f }, 5081 { }, 5082 }, 5083 }, 5084 [ALC269VB_FIXUP_ASPIRE_E1_COEF] = { 5085 .type = HDA_FIXUP_FUNC, 5086 .v.func = alc269vb_fixup_aspire_e1_coef, 5087 }, 5088 [ALC280_FIXUP_HP_GPIO4] = { 5089 .type = HDA_FIXUP_FUNC, 5090 .v.func = alc280_fixup_hp_gpio4, 5091 }, 5092 [ALC286_FIXUP_HP_GPIO_LED] = { 5093 .type = HDA_FIXUP_FUNC, 5094 .v.func = alc286_fixup_hp_gpio_led, 5095 }, 5096 [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = { 5097 .type = HDA_FIXUP_FUNC, 5098 .v.func = alc280_fixup_hp_gpio2_mic_hotkey, 5099 }, 5100 [ALC280_FIXUP_HP_DOCK_PINS] = { 5101 .type = HDA_FIXUP_PINS, 5102 .v.pins = (const struct hda_pintbl[]) { 5103 { 0x1b, 0x21011020 }, /* line-out */ 5104 { 0x1a, 0x01a1903c }, /* headset mic */ 5105 { 0x18, 0x2181103f }, /* line-in */ 5106 { }, 5107 }, 5108 .chained = true, 5109 .chain_id = ALC280_FIXUP_HP_GPIO4 5110 }, 5111 [ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = { 5112 .type = HDA_FIXUP_PINS, 5113 .v.pins = (const struct hda_pintbl[]) { 5114 { 0x1b, 0x21011020 }, /* line-out */ 5115 { 0x18, 0x2181103f }, /* line-in */ 5116 { }, 5117 }, 5118 .chained = true, 5119 .chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED 5120 }, 5121 [ALC280_FIXUP_HP_9480M] = { 5122 .type = HDA_FIXUP_FUNC, 5123 .v.func = alc280_fixup_hp_9480m, 5124 }, 5125 [ALC245_FIXUP_HP_X360_AMP] = { 5126 .type = HDA_FIXUP_FUNC, 5127 .v.func = alc245_fixup_hp_x360_amp, 5128 .chained = true, 5129 .chain_id = ALC245_FIXUP_HP_GPIO_LED 5130 }, 5131 [ALC288_FIXUP_DELL_HEADSET_MODE] = { 5132 .type = HDA_FIXUP_FUNC, 5133 .v.func = alc_fixup_headset_mode_dell_alc288, 5134 .chained = true, 5135 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 5136 }, 5137 [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = { 5138 .type = HDA_FIXUP_PINS, 5139 .v.pins = (const struct hda_pintbl[]) { 5140 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 5141 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 5142 { } 5143 }, 5144 .chained = true, 5145 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE 5146 }, 5147 [ALC288_FIXUP_DISABLE_AAMIX] = { 5148 .type = HDA_FIXUP_FUNC, 5149 .v.func = alc_fixup_disable_aamix, 5150 .chained = true, 5151 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE 5152 }, 5153 [ALC288_FIXUP_DELL_XPS_13] = { 5154 .type = HDA_FIXUP_FUNC, 5155 .v.func = alc_fixup_dell_xps13, 5156 .chained = true, 5157 .chain_id = ALC288_FIXUP_DISABLE_AAMIX 5158 }, 5159 [ALC292_FIXUP_DISABLE_AAMIX] = { 5160 .type = HDA_FIXUP_FUNC, 5161 .v.func = alc_fixup_disable_aamix, 5162 .chained = true, 5163 .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE 5164 }, 5165 [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = { 5166 .type = HDA_FIXUP_FUNC, 5167 .v.func = alc_fixup_disable_aamix, 5168 .chained = true, 5169 .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE 5170 }, 5171 [ALC292_FIXUP_DELL_E7X_AAMIX] = { 5172 .type = HDA_FIXUP_FUNC, 5173 .v.func = alc_fixup_dell_xps13, 5174 .chained = true, 5175 .chain_id = ALC292_FIXUP_DISABLE_AAMIX 5176 }, 5177 [ALC292_FIXUP_DELL_E7X] = { 5178 .type = HDA_FIXUP_FUNC, 5179 .v.func = alc_fixup_micmute_led, 5180 /* micmute fixup must be applied at last */ 5181 .chained_before = true, 5182 .chain_id = ALC292_FIXUP_DELL_E7X_AAMIX, 5183 }, 5184 [ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE] = { 5185 .type = HDA_FIXUP_PINS, 5186 .v.pins = (const struct hda_pintbl[]) { 5187 { 0x18, 0x01a1913c }, /* headset mic w/o jack detect */ 5188 { } 5189 }, 5190 .chained_before = true, 5191 .chain_id = ALC269_FIXUP_HEADSET_MODE, 5192 }, 5193 [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = { 5194 .type = HDA_FIXUP_PINS, 5195 .v.pins = (const struct hda_pintbl[]) { 5196 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 5197 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 5198 { } 5199 }, 5200 .chained = true, 5201 .chain_id = ALC269_FIXUP_HEADSET_MODE 5202 }, 5203 [ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = { 5204 .type = HDA_FIXUP_PINS, 5205 .v.pins = (const struct hda_pintbl[]) { 5206 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 5207 { } 5208 }, 5209 .chained = true, 5210 .chain_id = ALC269_FIXUP_HEADSET_MODE 5211 }, 5212 [ALC275_FIXUP_DELL_XPS] = { 5213 .type = HDA_FIXUP_VERBS, 5214 .v.verbs = (const struct hda_verb[]) { 5215 /* Enables internal speaker */ 5216 {0x20, AC_VERB_SET_COEF_INDEX, 0x1f}, 5217 {0x20, AC_VERB_SET_PROC_COEF, 0x00c0}, 5218 {0x20, AC_VERB_SET_COEF_INDEX, 0x30}, 5219 {0x20, AC_VERB_SET_PROC_COEF, 0x00b1}, 5220 {} 5221 } 5222 }, 5223 [ALC293_FIXUP_LENOVO_SPK_NOISE] = { 5224 .type = HDA_FIXUP_FUNC, 5225 .v.func = alc_fixup_disable_aamix, 5226 .chained = true, 5227 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 5228 }, 5229 [ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = { 5230 .type = HDA_FIXUP_FUNC, 5231 .v.func = alc233_fixup_lenovo_line2_mic_hotkey, 5232 }, 5233 [ALC233_FIXUP_LENOVO_L2MH_LOW_ENLED] = { 5234 .type = HDA_FIXUP_FUNC, 5235 .v.func = alc233_fixup_lenovo_low_en_micmute_led, 5236 }, 5237 [ALC233_FIXUP_INTEL_NUC8_DMIC] = { 5238 .type = HDA_FIXUP_FUNC, 5239 .v.func = alc_fixup_inv_dmic, 5240 .chained = true, 5241 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, 5242 }, 5243 [ALC255_FIXUP_DELL_SPK_NOISE] = { 5244 .type = HDA_FIXUP_FUNC, 5245 .v.func = alc_fixup_disable_aamix, 5246 .chained = true, 5247 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE 5248 }, 5249 [ALC225_FIXUP_DISABLE_MIC_VREF] = { 5250 .type = HDA_FIXUP_FUNC, 5251 .v.func = alc_fixup_disable_mic_vref, 5252 .chained = true, 5253 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE 5254 }, 5255 [ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = { 5256 .type = HDA_FIXUP_VERBS, 5257 .v.verbs = (const struct hda_verb[]) { 5258 /* Disable pass-through path for FRONT 14h */ 5259 { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 }, 5260 { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 }, 5261 {} 5262 }, 5263 .chained = true, 5264 .chain_id = ALC225_FIXUP_DISABLE_MIC_VREF 5265 }, 5266 [ALC280_FIXUP_HP_HEADSET_MIC] = { 5267 .type = HDA_FIXUP_FUNC, 5268 .v.func = alc_fixup_disable_aamix, 5269 .chained = true, 5270 .chain_id = ALC269_FIXUP_HEADSET_MIC, 5271 }, 5272 [ALC221_FIXUP_HP_FRONT_MIC] = { 5273 .type = HDA_FIXUP_PINS, 5274 .v.pins = (const struct hda_pintbl[]) { 5275 { 0x19, 0x02a19020 }, /* Front Mic */ 5276 { } 5277 }, 5278 }, 5279 [ALC292_FIXUP_TPT460] = { 5280 .type = HDA_FIXUP_FUNC, 5281 .v.func = alc_fixup_tpt440_dock, 5282 .chained = true, 5283 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE, 5284 }, 5285 [ALC298_FIXUP_SPK_VOLUME] = { 5286 .type = HDA_FIXUP_FUNC, 5287 .v.func = alc298_fixup_speaker_volume, 5288 .chained = true, 5289 .chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, 5290 }, 5291 [ALC298_FIXUP_LENOVO_SPK_VOLUME] = { 5292 .type = HDA_FIXUP_FUNC, 5293 .v.func = alc298_fixup_speaker_volume, 5294 }, 5295 [ALC295_FIXUP_DISABLE_DAC3] = { 5296 .type = HDA_FIXUP_FUNC, 5297 .v.func = alc295_fixup_disable_dac3, 5298 }, 5299 [ALC285_FIXUP_SPEAKER2_TO_DAC1] = { 5300 .type = HDA_FIXUP_FUNC, 5301 .v.func = alc285_fixup_speaker2_to_dac1, 5302 }, 5303 [ALC285_FIXUP_YOGA_SPEAKER2_TO_DAC1] = { 5304 .type = HDA_FIXUP_FUNC, 5305 .v.func = alc285_fixup_speaker2_to_dac1, 5306 .chained = true, 5307 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 5308 }, 5309 [ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1] = { 5310 .type = HDA_FIXUP_FUNC, 5311 .v.func = alc285_fixup_speaker2_to_dac1, 5312 .chained = true, 5313 .chain_id = ALC245_FIXUP_CS35L41_SPI_2 5314 }, 5315 [ALC285_FIXUP_ASUS_HEADSET_MIC] = { 5316 .type = HDA_FIXUP_PINS, 5317 .v.pins = (const struct hda_pintbl[]) { 5318 { 0x19, 0x03a11050 }, 5319 { 0x1b, 0x03a11c30 }, 5320 { } 5321 }, 5322 .chained = true, 5323 .chain_id = ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1 5324 }, 5325 [ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS] = { 5326 .type = HDA_FIXUP_PINS, 5327 .v.pins = (const struct hda_pintbl[]) { 5328 { 0x14, 0x90170120 }, 5329 { } 5330 }, 5331 .chained = true, 5332 .chain_id = ALC285_FIXUP_ASUS_HEADSET_MIC 5333 }, 5334 [ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1] = { 5335 .type = HDA_FIXUP_FUNC, 5336 .v.func = alc285_fixup_speaker2_to_dac1, 5337 .chained = true, 5338 .chain_id = ALC287_FIXUP_CS35L41_I2C_2 5339 }, 5340 [ALC285_FIXUP_ASUS_I2C_HEADSET_MIC] = { 5341 .type = HDA_FIXUP_PINS, 5342 .v.pins = (const struct hda_pintbl[]) { 5343 { 0x19, 0x03a11050 }, 5344 { 0x1b, 0x03a11c30 }, 5345 { } 5346 }, 5347 .chained = true, 5348 .chain_id = ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1 5349 }, 5350 [ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = { 5351 .type = HDA_FIXUP_PINS, 5352 .v.pins = (const struct hda_pintbl[]) { 5353 { 0x1b, 0x90170151 }, 5354 { } 5355 }, 5356 .chained = true, 5357 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE 5358 }, 5359 [ALC269_FIXUP_ATIV_BOOK_8] = { 5360 .type = HDA_FIXUP_FUNC, 5361 .v.func = alc_fixup_auto_mute_via_amp, 5362 .chained = true, 5363 .chain_id = ALC269_FIXUP_NO_SHUTUP 5364 }, 5365 [ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE] = { 5366 .type = HDA_FIXUP_PINS, 5367 .v.pins = (const struct hda_pintbl[]) { 5368 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 5369 { 0x1a, 0x01813030 }, /* use as headphone mic, without its own jack detect */ 5370 { } 5371 }, 5372 .chained = true, 5373 .chain_id = ALC269_FIXUP_HEADSET_MODE 5374 }, 5375 [ALC221_FIXUP_HP_MIC_NO_PRESENCE] = { 5376 .type = HDA_FIXUP_PINS, 5377 .v.pins = (const struct hda_pintbl[]) { 5378 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 5379 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 5380 { } 5381 }, 5382 .chained = true, 5383 .chain_id = ALC269_FIXUP_HEADSET_MODE 5384 }, 5385 [ALC256_FIXUP_ASUS_HEADSET_MODE] = { 5386 .type = HDA_FIXUP_FUNC, 5387 .v.func = alc_fixup_headset_mode, 5388 }, 5389 [ALC256_FIXUP_ASUS_MIC] = { 5390 .type = HDA_FIXUP_PINS, 5391 .v.pins = (const struct hda_pintbl[]) { 5392 { 0x13, 0x90a60160 }, /* use as internal mic */ 5393 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */ 5394 { } 5395 }, 5396 .chained = true, 5397 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 5398 }, 5399 [ALC256_FIXUP_ASUS_AIO_GPIO2] = { 5400 .type = HDA_FIXUP_FUNC, 5401 /* Set up GPIO2 for the speaker amp */ 5402 .v.func = alc_fixup_gpio4, 5403 }, 5404 [ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = { 5405 .type = HDA_FIXUP_PINS, 5406 .v.pins = (const struct hda_pintbl[]) { 5407 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 5408 { } 5409 }, 5410 .chained = true, 5411 .chain_id = ALC269_FIXUP_HEADSET_MIC 5412 }, 5413 [ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = { 5414 .type = HDA_FIXUP_VERBS, 5415 .v.verbs = (const struct hda_verb[]) { 5416 /* Enables internal speaker */ 5417 {0x20, AC_VERB_SET_COEF_INDEX, 0x40}, 5418 {0x20, AC_VERB_SET_PROC_COEF, 0x8800}, 5419 {} 5420 }, 5421 .chained = true, 5422 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE 5423 }, 5424 [ALC233_FIXUP_LENOVO_MULTI_CODECS] = { 5425 .type = HDA_FIXUP_FUNC, 5426 .v.func = alc233_alc662_fixup_lenovo_dual_codecs, 5427 .chained = true, 5428 .chain_id = ALC269_FIXUP_GPIO2 5429 }, 5430 [ALC233_FIXUP_ACER_HEADSET_MIC] = { 5431 .type = HDA_FIXUP_VERBS, 5432 .v.verbs = (const struct hda_verb[]) { 5433 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 }, 5434 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 }, 5435 { } 5436 }, 5437 .chained = true, 5438 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE 5439 }, 5440 [ALC294_FIXUP_LENOVO_MIC_LOCATION] = { 5441 .type = HDA_FIXUP_PINS, 5442 .v.pins = (const struct hda_pintbl[]) { 5443 /* Change the mic location from front to right, otherwise there are 5444 two front mics with the same name, pulseaudio can't handle them. 5445 This is just a temporary workaround, after applying this fixup, 5446 there will be one "Front Mic" and one "Mic" in this machine. 5447 */ 5448 { 0x1a, 0x04a19040 }, 5449 { } 5450 }, 5451 }, 5452 [ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = { 5453 .type = HDA_FIXUP_PINS, 5454 .v.pins = (const struct hda_pintbl[]) { 5455 { 0x16, 0x0101102f }, /* Rear Headset HP */ 5456 { 0x19, 0x02a1913c }, /* use as Front headset mic, without its own jack detect */ 5457 { 0x1a, 0x01a19030 }, /* Rear Headset MIC */ 5458 { 0x1b, 0x02011020 }, 5459 { } 5460 }, 5461 .chained = true, 5462 .chain_id = ALC225_FIXUP_S3_POP_NOISE 5463 }, 5464 [ALC225_FIXUP_S3_POP_NOISE] = { 5465 .type = HDA_FIXUP_FUNC, 5466 .v.func = alc225_fixup_s3_pop_noise, 5467 .chained = true, 5468 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 5469 }, 5470 [ALC700_FIXUP_INTEL_REFERENCE] = { 5471 .type = HDA_FIXUP_VERBS, 5472 .v.verbs = (const struct hda_verb[]) { 5473 /* Enables internal speaker */ 5474 {0x20, AC_VERB_SET_COEF_INDEX, 0x45}, 5475 {0x20, AC_VERB_SET_PROC_COEF, 0x5289}, 5476 {0x20, AC_VERB_SET_COEF_INDEX, 0x4A}, 5477 {0x20, AC_VERB_SET_PROC_COEF, 0x001b}, 5478 {0x58, AC_VERB_SET_COEF_INDEX, 0x00}, 5479 {0x58, AC_VERB_SET_PROC_COEF, 0x3888}, 5480 {0x20, AC_VERB_SET_COEF_INDEX, 0x6f}, 5481 {0x20, AC_VERB_SET_PROC_COEF, 0x2c0b}, 5482 {} 5483 } 5484 }, 5485 [ALC700_FIXUP_INTEL_HADES_CANYON] = { 5486 .type = HDA_FIXUP_FUNC, 5487 .v.func = alc700_fixup_intel_hades_canyon, 5488 }, 5489 [ALC274_FIXUP_DELL_BIND_DACS] = { 5490 .type = HDA_FIXUP_FUNC, 5491 .v.func = alc274_fixup_bind_dacs, 5492 .chained = true, 5493 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE 5494 }, 5495 [ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = { 5496 .type = HDA_FIXUP_PINS, 5497 .v.pins = (const struct hda_pintbl[]) { 5498 { 0x1b, 0x0401102f }, 5499 { } 5500 }, 5501 .chained = true, 5502 .chain_id = ALC274_FIXUP_DELL_BIND_DACS 5503 }, 5504 [ALC298_FIXUP_TPT470_DOCK_FIX] = { 5505 .type = HDA_FIXUP_FUNC, 5506 .v.func = alc_fixup_tpt470_dock, 5507 .chained = true, 5508 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE 5509 }, 5510 [ALC298_FIXUP_TPT470_DOCK] = { 5511 .type = HDA_FIXUP_FUNC, 5512 .v.func = alc_fixup_tpt470_dacs, 5513 .chained = true, 5514 .chain_id = ALC298_FIXUP_TPT470_DOCK_FIX 5515 }, 5516 [ALC255_FIXUP_DUMMY_LINEOUT_VERB] = { 5517 .type = HDA_FIXUP_PINS, 5518 .v.pins = (const struct hda_pintbl[]) { 5519 { 0x14, 0x0201101f }, 5520 { } 5521 }, 5522 .chained = true, 5523 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE 5524 }, 5525 [ALC255_FIXUP_DELL_HEADSET_MIC] = { 5526 .type = HDA_FIXUP_PINS, 5527 .v.pins = (const struct hda_pintbl[]) { 5528 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 5529 { } 5530 }, 5531 .chained = true, 5532 .chain_id = ALC269_FIXUP_HEADSET_MIC 5533 }, 5534 [ALC295_FIXUP_HP_X360] = { 5535 .type = HDA_FIXUP_FUNC, 5536 .v.func = alc295_fixup_hp_top_speakers, 5537 .chained = true, 5538 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3 5539 }, 5540 [ALC295_FIXUP_HP_PAVILION_X360] = { 5541 .type = HDA_FIXUP_VERBS, 5542 .v.verbs = (const struct hda_verb[]) { 5543 /* force amp gain and processing state */ 5544 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 5545 { 0x20, AC_VERB_SET_PROC_COEF, 0x7770 }, 5546 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0d }, 5547 { 0x20, AC_VERB_SET_PROC_COEF, 0x3000 }, 5548 {} 5549 }, 5550 .chained = true, 5551 .chain_id = ALC295_FIXUP_HP_X360 5552 }, 5553 [ALC221_FIXUP_HP_HEADSET_MIC] = { 5554 .type = HDA_FIXUP_PINS, 5555 .v.pins = (const struct hda_pintbl[]) { 5556 { 0x19, 0x0181313f}, 5557 { } 5558 }, 5559 .chained = true, 5560 .chain_id = ALC269_FIXUP_HEADSET_MIC 5561 }, 5562 [ALC285_FIXUP_LENOVO_HEADPHONE_NOISE] = { 5563 .type = HDA_FIXUP_FUNC, 5564 .v.func = alc285_fixup_invalidate_dacs, 5565 .chained = true, 5566 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 5567 }, 5568 [ALC295_FIXUP_HP_AUTO_MUTE] = { 5569 .type = HDA_FIXUP_FUNC, 5570 .v.func = alc_fixup_auto_mute_via_amp, 5571 }, 5572 [ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE] = { 5573 .type = HDA_FIXUP_PINS, 5574 .v.pins = (const struct hda_pintbl[]) { 5575 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 5576 { } 5577 }, 5578 .chained = true, 5579 .chain_id = ALC269_FIXUP_HEADSET_MIC 5580 }, 5581 [ALC294_FIXUP_ASUS_MIC] = { 5582 .type = HDA_FIXUP_PINS, 5583 .v.pins = (const struct hda_pintbl[]) { 5584 { 0x13, 0x90a60160 }, /* use as internal mic */ 5585 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */ 5586 { } 5587 }, 5588 .chained = true, 5589 .chain_id = ALC269_FIXUP_HEADSET_MIC 5590 }, 5591 [ALC294_FIXUP_ASUS_HEADSET_MIC] = { 5592 .type = HDA_FIXUP_PINS, 5593 .v.pins = (const struct hda_pintbl[]) { 5594 { 0x19, 0x01a1103c }, /* use as headset mic */ 5595 { } 5596 }, 5597 .chained = true, 5598 .chain_id = ALC269_FIXUP_HEADSET_MIC 5599 }, 5600 [ALC294_FIXUP_ASUS_I2C_HEADSET_MIC] = { 5601 .type = HDA_FIXUP_PINS, 5602 .v.pins = (const struct hda_pintbl[]) { 5603 { 0x19, 0x03a19020 }, /* use as headset mic */ 5604 { } 5605 }, 5606 .chained = true, 5607 .chain_id = ALC287_FIXUP_CS35L41_I2C_2 5608 }, 5609 [ALC294_FIXUP_ASUS_SPI_HEADSET_MIC] = { 5610 .type = HDA_FIXUP_PINS, 5611 .v.pins = (const struct hda_pintbl[]) { 5612 { 0x19, 0x04a11020 }, /* use as headset mic */ 5613 { } 5614 }, 5615 .chained = true, 5616 .chain_id = ALC245_FIXUP_CS35L41_SPI_2 5617 }, 5618 [ALC294_FIXUP_ASUS_SPK] = { 5619 .type = HDA_FIXUP_VERBS, 5620 .v.verbs = (const struct hda_verb[]) { 5621 /* Set EAPD high */ 5622 { 0x20, AC_VERB_SET_COEF_INDEX, 0x40 }, 5623 { 0x20, AC_VERB_SET_PROC_COEF, 0x8800 }, 5624 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f }, 5625 { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 }, 5626 { } 5627 }, 5628 .chained = true, 5629 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC 5630 }, 5631 [ALC295_FIXUP_CHROME_BOOK] = { 5632 .type = HDA_FIXUP_FUNC, 5633 .v.func = alc295_fixup_chromebook, 5634 .chained = true, 5635 .chain_id = ALC225_FIXUP_HEADSET_JACK 5636 }, 5637 [ALC225_FIXUP_HEADSET_JACK] = { 5638 .type = HDA_FIXUP_FUNC, 5639 .v.func = alc_fixup_headset_jack, 5640 }, 5641 [ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = { 5642 .type = HDA_FIXUP_PINS, 5643 .v.pins = (const struct hda_pintbl[]) { 5644 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 5645 { } 5646 }, 5647 .chained = true, 5648 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 5649 }, 5650 [ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE] = { 5651 .type = HDA_FIXUP_VERBS, 5652 .v.verbs = (const struct hda_verb[]) { 5653 /* Disable PCBEEP-IN passthrough */ 5654 { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 }, 5655 { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 }, 5656 { } 5657 }, 5658 .chained = true, 5659 .chain_id = ALC285_FIXUP_LENOVO_HEADPHONE_NOISE 5660 }, 5661 [ALC255_FIXUP_ACER_HEADSET_MIC] = { 5662 .type = HDA_FIXUP_PINS, 5663 .v.pins = (const struct hda_pintbl[]) { 5664 { 0x19, 0x03a11130 }, 5665 { 0x1a, 0x90a60140 }, /* use as internal mic */ 5666 { } 5667 }, 5668 .chained = true, 5669 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC 5670 }, 5671 [ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE] = { 5672 .type = HDA_FIXUP_PINS, 5673 .v.pins = (const struct hda_pintbl[]) { 5674 { 0x16, 0x01011020 }, /* Rear Line out */ 5675 { 0x19, 0x01a1913c }, /* use as Front headset mic, without its own jack detect */ 5676 { } 5677 }, 5678 .chained = true, 5679 .chain_id = ALC225_FIXUP_WYSE_AUTO_MUTE 5680 }, 5681 [ALC225_FIXUP_WYSE_AUTO_MUTE] = { 5682 .type = HDA_FIXUP_FUNC, 5683 .v.func = alc_fixup_auto_mute_via_amp, 5684 .chained = true, 5685 .chain_id = ALC225_FIXUP_WYSE_DISABLE_MIC_VREF 5686 }, 5687 [ALC225_FIXUP_WYSE_DISABLE_MIC_VREF] = { 5688 .type = HDA_FIXUP_FUNC, 5689 .v.func = alc_fixup_disable_mic_vref, 5690 .chained = true, 5691 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 5692 }, 5693 [ALC286_FIXUP_ACER_AIO_HEADSET_MIC] = { 5694 .type = HDA_FIXUP_VERBS, 5695 .v.verbs = (const struct hda_verb[]) { 5696 { 0x20, AC_VERB_SET_COEF_INDEX, 0x4f }, 5697 { 0x20, AC_VERB_SET_PROC_COEF, 0x5029 }, 5698 { } 5699 }, 5700 .chained = true, 5701 .chain_id = ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE 5702 }, 5703 [ALC256_FIXUP_ASUS_HEADSET_MIC] = { 5704 .type = HDA_FIXUP_PINS, 5705 .v.pins = (const struct hda_pintbl[]) { 5706 { 0x19, 0x03a11020 }, /* headset mic with jack detect */ 5707 { } 5708 }, 5709 .chained = true, 5710 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 5711 }, 5712 [ALC256_FIXUP_ASUS_MIC_NO_PRESENCE] = { 5713 .type = HDA_FIXUP_PINS, 5714 .v.pins = (const struct hda_pintbl[]) { 5715 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */ 5716 { } 5717 }, 5718 .chained = true, 5719 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 5720 }, 5721 [ALC255_FIXUP_PREDATOR_SUBWOOFER] = { 5722 .type = HDA_FIXUP_PINS, 5723 .v.pins = (const struct hda_pintbl[]) { 5724 { 0x17, 0x90170151 }, /* use as internal speaker (LFE) */ 5725 { 0x1b, 0x90170152 } /* use as internal speaker (back) */ 5726 } 5727 }, 5728 [ALC299_FIXUP_PREDATOR_SPK] = { 5729 .type = HDA_FIXUP_PINS, 5730 .v.pins = (const struct hda_pintbl[]) { 5731 { 0x21, 0x90170150 }, /* use as internal speaker */ 5732 { } 5733 } 5734 }, 5735 [ALC287_FIXUP_PREDATOR_SPK_CS35L41_I2C_2] = { 5736 .type = HDA_FIXUP_FUNC, 5737 .v.func = cs35l41_fixup_i2c_two, 5738 .chained = true, 5739 .chain_id = ALC255_FIXUP_PREDATOR_SUBWOOFER 5740 }, 5741 [ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = { 5742 .type = HDA_FIXUP_PINS, 5743 .v.pins = (const struct hda_pintbl[]) { 5744 { 0x19, 0x04a11040 }, 5745 { 0x21, 0x04211020 }, 5746 { } 5747 }, 5748 .chained = true, 5749 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 5750 }, 5751 [ALC289_FIXUP_DELL_SPK1] = { 5752 .type = HDA_FIXUP_PINS, 5753 .v.pins = (const struct hda_pintbl[]) { 5754 { 0x14, 0x90170140 }, 5755 { } 5756 }, 5757 .chained = true, 5758 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE 5759 }, 5760 [ALC289_FIXUP_DELL_SPK2] = { 5761 .type = HDA_FIXUP_PINS, 5762 .v.pins = (const struct hda_pintbl[]) { 5763 { 0x17, 0x90170130 }, /* bass spk */ 5764 { } 5765 }, 5766 .chained = true, 5767 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE 5768 }, 5769 [ALC289_FIXUP_DUAL_SPK] = { 5770 .type = HDA_FIXUP_FUNC, 5771 .v.func = alc285_fixup_speaker2_to_dac1, 5772 .chained = true, 5773 .chain_id = ALC289_FIXUP_DELL_SPK2 5774 }, 5775 [ALC289_FIXUP_RTK_AMP_DUAL_SPK] = { 5776 .type = HDA_FIXUP_FUNC, 5777 .v.func = alc285_fixup_speaker2_to_dac1, 5778 .chained = true, 5779 .chain_id = ALC289_FIXUP_DELL_SPK1 5780 }, 5781 [ALC294_FIXUP_SPK2_TO_DAC1] = { 5782 .type = HDA_FIXUP_FUNC, 5783 .v.func = alc285_fixup_speaker2_to_dac1, 5784 .chained = true, 5785 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC 5786 }, 5787 [ALC294_FIXUP_ASUS_DUAL_SPK] = { 5788 .type = HDA_FIXUP_FUNC, 5789 /* The GPIO must be pulled to initialize the AMP */ 5790 .v.func = alc_fixup_gpio4, 5791 .chained = true, 5792 .chain_id = ALC294_FIXUP_SPK2_TO_DAC1 5793 }, 5794 [ALC294_FIXUP_ASUS_ALLY] = { 5795 .type = HDA_FIXUP_FUNC, 5796 .v.func = cs35l41_fixup_i2c_two, 5797 .chained = true, 5798 .chain_id = ALC294_FIXUP_ASUS_ALLY_PINS 5799 }, 5800 [ALC294_FIXUP_ASUS_ALLY_PINS] = { 5801 .type = HDA_FIXUP_PINS, 5802 .v.pins = (const struct hda_pintbl[]) { 5803 { 0x19, 0x03a11050 }, 5804 { 0x1a, 0x03a11c30 }, 5805 { 0x21, 0x03211420 }, 5806 { } 5807 }, 5808 .chained = true, 5809 .chain_id = ALC294_FIXUP_ASUS_ALLY_VERBS 5810 }, 5811 [ALC294_FIXUP_ASUS_ALLY_VERBS] = { 5812 .type = HDA_FIXUP_VERBS, 5813 .v.verbs = (const struct hda_verb[]) { 5814 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 }, 5815 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 }, 5816 { 0x20, AC_VERB_SET_COEF_INDEX, 0x46 }, 5817 { 0x20, AC_VERB_SET_PROC_COEF, 0x0004 }, 5818 { 0x20, AC_VERB_SET_COEF_INDEX, 0x47 }, 5819 { 0x20, AC_VERB_SET_PROC_COEF, 0xa47a }, 5820 { 0x20, AC_VERB_SET_COEF_INDEX, 0x49 }, 5821 { 0x20, AC_VERB_SET_PROC_COEF, 0x0049}, 5822 { 0x20, AC_VERB_SET_COEF_INDEX, 0x4a }, 5823 { 0x20, AC_VERB_SET_PROC_COEF, 0x201b }, 5824 { 0x20, AC_VERB_SET_COEF_INDEX, 0x6b }, 5825 { 0x20, AC_VERB_SET_PROC_COEF, 0x4278}, 5826 { } 5827 }, 5828 .chained = true, 5829 .chain_id = ALC285_FIXUP_SPEAKER2_TO_DAC1 5830 }, 5831 [ALC285_FIXUP_THINKPAD_X1_GEN7] = { 5832 .type = HDA_FIXUP_FUNC, 5833 .v.func = alc285_fixup_thinkpad_x1_gen7, 5834 .chained = true, 5835 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 5836 }, 5837 [ALC285_FIXUP_THINKPAD_HEADSET_JACK] = { 5838 .type = HDA_FIXUP_FUNC, 5839 .v.func = alc_fixup_headset_jack, 5840 .chained = true, 5841 .chain_id = ALC285_FIXUP_THINKPAD_X1_GEN7 5842 }, 5843 [ALC294_FIXUP_ASUS_HPE] = { 5844 .type = HDA_FIXUP_VERBS, 5845 .v.verbs = (const struct hda_verb[]) { 5846 /* Set EAPD high */ 5847 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f }, 5848 { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 }, 5849 { } 5850 }, 5851 .chained = true, 5852 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC 5853 }, 5854 [ALC294_FIXUP_ASUS_GX502_PINS] = { 5855 .type = HDA_FIXUP_PINS, 5856 .v.pins = (const struct hda_pintbl[]) { 5857 { 0x19, 0x03a11050 }, /* front HP mic */ 5858 { 0x1a, 0x01a11830 }, /* rear external mic */ 5859 { 0x21, 0x03211020 }, /* front HP out */ 5860 { } 5861 }, 5862 .chained = true, 5863 .chain_id = ALC294_FIXUP_ASUS_GX502_VERBS 5864 }, 5865 [ALC294_FIXUP_ASUS_GX502_VERBS] = { 5866 .type = HDA_FIXUP_VERBS, 5867 .v.verbs = (const struct hda_verb[]) { 5868 /* set 0x15 to HP-OUT ctrl */ 5869 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 5870 /* unmute the 0x15 amp */ 5871 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 }, 5872 { } 5873 }, 5874 .chained = true, 5875 .chain_id = ALC294_FIXUP_ASUS_GX502_HP 5876 }, 5877 [ALC294_FIXUP_ASUS_GX502_HP] = { 5878 .type = HDA_FIXUP_FUNC, 5879 .v.func = alc294_fixup_gx502_hp, 5880 }, 5881 [ALC295_FIXUP_DELL_TAS2781_I2C] = { 5882 .type = HDA_FIXUP_FUNC, 5883 .v.func = tas2781_fixup_tias_i2c, 5884 .chained = true, 5885 .chain_id = ALC289_FIXUP_DUAL_SPK 5886 }, 5887 [ALC294_FIXUP_ASUS_GU502_PINS] = { 5888 .type = HDA_FIXUP_PINS, 5889 .v.pins = (const struct hda_pintbl[]) { 5890 { 0x19, 0x01a11050 }, /* rear HP mic */ 5891 { 0x1a, 0x01a11830 }, /* rear external mic */ 5892 { 0x21, 0x012110f0 }, /* rear HP out */ 5893 { } 5894 }, 5895 .chained = true, 5896 .chain_id = ALC294_FIXUP_ASUS_GU502_VERBS 5897 }, 5898 [ALC294_FIXUP_ASUS_GU502_VERBS] = { 5899 .type = HDA_FIXUP_VERBS, 5900 .v.verbs = (const struct hda_verb[]) { 5901 /* set 0x15 to HP-OUT ctrl */ 5902 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 5903 /* unmute the 0x15 amp */ 5904 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 }, 5905 /* set 0x1b to HP-OUT */ 5906 { 0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 5907 { } 5908 }, 5909 .chained = true, 5910 .chain_id = ALC294_FIXUP_ASUS_GU502_HP 5911 }, 5912 [ALC294_FIXUP_ASUS_GU502_HP] = { 5913 .type = HDA_FIXUP_FUNC, 5914 .v.func = alc294_fixup_gu502_hp, 5915 }, 5916 [ALC294_FIXUP_ASUS_G513_PINS] = { 5917 .type = HDA_FIXUP_PINS, 5918 .v.pins = (const struct hda_pintbl[]) { 5919 { 0x19, 0x03a11050 }, /* front HP mic */ 5920 { 0x1a, 0x03a11c30 }, /* rear external mic */ 5921 { 0x21, 0x03211420 }, /* front HP out */ 5922 { } 5923 }, 5924 }, 5925 [ALC285_FIXUP_ASUS_G533Z_PINS] = { 5926 .type = HDA_FIXUP_PINS, 5927 .v.pins = (const struct hda_pintbl[]) { 5928 { 0x14, 0x90170152 }, /* Speaker Surround Playback Switch */ 5929 { 0x19, 0x03a19020 }, /* Mic Boost Volume */ 5930 { 0x1a, 0x03a11c30 }, /* Mic Boost Volume */ 5931 { 0x1e, 0x90170151 }, /* Rear jack, IN OUT EAPD Detect */ 5932 { 0x21, 0x03211420 }, 5933 { } 5934 }, 5935 }, 5936 [ALC294_FIXUP_ASUS_COEF_1B] = { 5937 .type = HDA_FIXUP_VERBS, 5938 .v.verbs = (const struct hda_verb[]) { 5939 /* Set bit 10 to correct noisy output after reboot from 5940 * Windows 10 (due to pop noise reduction?) 5941 */ 5942 { 0x20, AC_VERB_SET_COEF_INDEX, 0x1b }, 5943 { 0x20, AC_VERB_SET_PROC_COEF, 0x4e4b }, 5944 { } 5945 }, 5946 .chained = true, 5947 .chain_id = ALC289_FIXUP_ASUS_GA401, 5948 }, 5949 [ALC285_FIXUP_HP_GPIO_LED] = { 5950 .type = HDA_FIXUP_FUNC, 5951 .v.func = alc285_fixup_hp_gpio_led, 5952 }, 5953 [ALC285_FIXUP_HP_MUTE_LED] = { 5954 .type = HDA_FIXUP_FUNC, 5955 .v.func = alc285_fixup_hp_mute_led, 5956 }, 5957 [ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED] = { 5958 .type = HDA_FIXUP_FUNC, 5959 .v.func = alc285_fixup_hp_spectre_x360_mute_led, 5960 }, 5961 [ALC245_FIXUP_HP_ENVY_X360_MUTE_LED] = { 5962 .type = HDA_FIXUP_FUNC, 5963 .v.func = alc245_fixup_hp_envy_x360_mute_led, 5964 }, 5965 [ALC285_FIXUP_HP_BEEP_MICMUTE_LED] = { 5966 .type = HDA_FIXUP_FUNC, 5967 .v.func = alc285_fixup_hp_beep, 5968 .chained = true, 5969 .chain_id = ALC285_FIXUP_HP_MUTE_LED, 5970 }, 5971 [ALC236_FIXUP_HP_MUTE_LED_COEFBIT2] = { 5972 .type = HDA_FIXUP_FUNC, 5973 .v.func = alc236_fixup_hp_mute_led_coefbit2, 5974 }, 5975 [ALC236_FIXUP_HP_GPIO_LED] = { 5976 .type = HDA_FIXUP_FUNC, 5977 .v.func = alc236_fixup_hp_gpio_led, 5978 }, 5979 [ALC236_FIXUP_HP_MUTE_LED] = { 5980 .type = HDA_FIXUP_FUNC, 5981 .v.func = alc236_fixup_hp_mute_led, 5982 }, 5983 [ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF] = { 5984 .type = HDA_FIXUP_FUNC, 5985 .v.func = alc236_fixup_hp_mute_led_micmute_vref, 5986 }, 5987 [ALC236_FIXUP_HP_MUTE_LED_MICMUTE_GPIO] = { 5988 .type = HDA_FIXUP_FUNC, 5989 .v.func = alc236_fixup_hp_mute_led_micmute_gpio, 5990 }, 5991 [ALC236_FIXUP_HP_15_FD0XXX] = { 5992 .type = HDA_FIXUP_FUNC, 5993 .v.func = alc236_fixup_hp_15_fd0xxx, 5994 }, 5995 [ALC236_FIXUP_LENOVO_INV_DMIC] = { 5996 .type = HDA_FIXUP_FUNC, 5997 .v.func = alc_fixup_inv_dmic, 5998 .chained = true, 5999 .chain_id = ALC283_FIXUP_INT_MIC, 6000 }, 6001 [ALC295_FIXUP_HP_MUTE_LED_COEFBIT11] = { 6002 .type = HDA_FIXUP_FUNC, 6003 .v.func = alc295_fixup_hp_mute_led_coefbit11, 6004 }, 6005 [ALC295_FIXUP_HP_PAVILION_MUTE_LED_1B] = { 6006 .type = HDA_FIXUP_FUNC, 6007 .v.func = alc295_fixup_hp_pavilion_mute_led_1b, 6008 }, 6009 [ALC298_FIXUP_SAMSUNG_AMP] = { 6010 .type = HDA_FIXUP_FUNC, 6011 .v.func = alc298_fixup_samsung_amp, 6012 .chained = true, 6013 .chain_id = ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET 6014 }, 6015 [ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS] = { 6016 .type = HDA_FIXUP_FUNC, 6017 .v.func = alc298_fixup_samsung_amp_v2_2_amps 6018 }, 6019 [ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS] = { 6020 .type = HDA_FIXUP_FUNC, 6021 .v.func = alc298_fixup_samsung_amp_v2_4_amps 6022 }, 6023 [ALC298_FIXUP_LG_GRAM_STYLE_14] = { 6024 .type = HDA_FIXUP_FUNC, 6025 .v.func = alc298_fixup_lg_gram_style_14 6026 }, 6027 [ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = { 6028 .type = HDA_FIXUP_VERBS, 6029 .v.verbs = (const struct hda_verb[]) { 6030 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc5 }, 6031 { } 6032 }, 6033 }, 6034 [ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = { 6035 .type = HDA_FIXUP_VERBS, 6036 .v.verbs = (const struct hda_verb[]) { 6037 { 0x20, AC_VERB_SET_COEF_INDEX, 0x08}, 6038 { 0x20, AC_VERB_SET_PROC_COEF, 0x2fcf}, 6039 { } 6040 }, 6041 }, 6042 [ALC295_FIXUP_ASUS_MIC_NO_PRESENCE] = { 6043 .type = HDA_FIXUP_PINS, 6044 .v.pins = (const struct hda_pintbl[]) { 6045 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 6046 { } 6047 }, 6048 .chained = true, 6049 .chain_id = ALC269_FIXUP_HEADSET_MODE 6050 }, 6051 [ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS] = { 6052 .type = HDA_FIXUP_PINS, 6053 .v.pins = (const struct hda_pintbl[]) { 6054 { 0x14, 0x90100120 }, /* use as internal speaker */ 6055 { 0x18, 0x02a111f0 }, /* use as headset mic, without its own jack detect */ 6056 { 0x1a, 0x01011020 }, /* use as line out */ 6057 { }, 6058 }, 6059 .chained = true, 6060 .chain_id = ALC269_FIXUP_HEADSET_MIC 6061 }, 6062 [ALC269VC_FIXUP_ACER_HEADSET_MIC] = { 6063 .type = HDA_FIXUP_PINS, 6064 .v.pins = (const struct hda_pintbl[]) { 6065 { 0x18, 0x02a11030 }, /* use as headset mic */ 6066 { } 6067 }, 6068 .chained = true, 6069 .chain_id = ALC269_FIXUP_HEADSET_MIC 6070 }, 6071 [ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE] = { 6072 .type = HDA_FIXUP_PINS, 6073 .v.pins = (const struct hda_pintbl[]) { 6074 { 0x18, 0x01a11130 }, /* use as headset mic, without its own jack detect */ 6075 { } 6076 }, 6077 .chained = true, 6078 .chain_id = ALC269_FIXUP_HEADSET_MIC 6079 }, 6080 [ALC289_FIXUP_ASUS_GA401] = { 6081 .type = HDA_FIXUP_FUNC, 6082 .v.func = alc289_fixup_asus_ga401, 6083 .chained = true, 6084 .chain_id = ALC289_FIXUP_ASUS_GA502, 6085 }, 6086 [ALC289_FIXUP_ASUS_GA502] = { 6087 .type = HDA_FIXUP_PINS, 6088 .v.pins = (const struct hda_pintbl[]) { 6089 { 0x19, 0x03a11020 }, /* headset mic with jack detect */ 6090 { } 6091 }, 6092 }, 6093 [ALC256_FIXUP_ACER_MIC_NO_PRESENCE] = { 6094 .type = HDA_FIXUP_PINS, 6095 .v.pins = (const struct hda_pintbl[]) { 6096 { 0x19, 0x02a11120 }, /* use as headset mic, without its own jack detect */ 6097 { } 6098 }, 6099 .chained = true, 6100 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 6101 }, 6102 [ALC285_FIXUP_HP_GPIO_AMP_INIT] = { 6103 .type = HDA_FIXUP_FUNC, 6104 .v.func = alc285_fixup_hp_gpio_amp_init, 6105 .chained = true, 6106 .chain_id = ALC285_FIXUP_HP_GPIO_LED 6107 }, 6108 [ALC269_FIXUP_CZC_B20] = { 6109 .type = HDA_FIXUP_PINS, 6110 .v.pins = (const struct hda_pintbl[]) { 6111 { 0x12, 0x411111f0 }, 6112 { 0x14, 0x90170110 }, /* speaker */ 6113 { 0x15, 0x032f1020 }, /* HP out */ 6114 { 0x17, 0x411111f0 }, 6115 { 0x18, 0x03ab1040 }, /* mic */ 6116 { 0x19, 0xb7a7013f }, 6117 { 0x1a, 0x0181305f }, 6118 { 0x1b, 0x411111f0 }, 6119 { 0x1d, 0x411111f0 }, 6120 { 0x1e, 0x411111f0 }, 6121 { } 6122 }, 6123 .chain_id = ALC269_FIXUP_DMIC, 6124 }, 6125 [ALC269_FIXUP_CZC_TMI] = { 6126 .type = HDA_FIXUP_PINS, 6127 .v.pins = (const struct hda_pintbl[]) { 6128 { 0x12, 0x4000c000 }, 6129 { 0x14, 0x90170110 }, /* speaker */ 6130 { 0x15, 0x0421401f }, /* HP out */ 6131 { 0x17, 0x411111f0 }, 6132 { 0x18, 0x04a19020 }, /* mic */ 6133 { 0x19, 0x411111f0 }, 6134 { 0x1a, 0x411111f0 }, 6135 { 0x1b, 0x411111f0 }, 6136 { 0x1d, 0x40448505 }, 6137 { 0x1e, 0x411111f0 }, 6138 { 0x20, 0x8000ffff }, 6139 { } 6140 }, 6141 .chain_id = ALC269_FIXUP_DMIC, 6142 }, 6143 [ALC269_FIXUP_CZC_L101] = { 6144 .type = HDA_FIXUP_PINS, 6145 .v.pins = (const struct hda_pintbl[]) { 6146 { 0x12, 0x40000000 }, 6147 { 0x14, 0x01014010 }, /* speaker */ 6148 { 0x15, 0x411111f0 }, /* HP out */ 6149 { 0x16, 0x411111f0 }, 6150 { 0x18, 0x01a19020 }, /* mic */ 6151 { 0x19, 0x02a19021 }, 6152 { 0x1a, 0x0181302f }, 6153 { 0x1b, 0x0221401f }, 6154 { 0x1c, 0x411111f0 }, 6155 { 0x1d, 0x4044c601 }, 6156 { 0x1e, 0x411111f0 }, 6157 { } 6158 }, 6159 .chain_id = ALC269_FIXUP_DMIC, 6160 }, 6161 [ALC269_FIXUP_LEMOTE_A1802] = { 6162 .type = HDA_FIXUP_PINS, 6163 .v.pins = (const struct hda_pintbl[]) { 6164 { 0x12, 0x40000000 }, 6165 { 0x14, 0x90170110 }, /* speaker */ 6166 { 0x17, 0x411111f0 }, 6167 { 0x18, 0x03a19040 }, /* mic1 */ 6168 { 0x19, 0x90a70130 }, /* mic2 */ 6169 { 0x1a, 0x411111f0 }, 6170 { 0x1b, 0x411111f0 }, 6171 { 0x1d, 0x40489d2d }, 6172 { 0x1e, 0x411111f0 }, 6173 { 0x20, 0x0003ffff }, 6174 { 0x21, 0x03214020 }, 6175 { } 6176 }, 6177 .chain_id = ALC269_FIXUP_DMIC, 6178 }, 6179 [ALC269_FIXUP_LEMOTE_A190X] = { 6180 .type = HDA_FIXUP_PINS, 6181 .v.pins = (const struct hda_pintbl[]) { 6182 { 0x14, 0x99130110 }, /* speaker */ 6183 { 0x15, 0x0121401f }, /* HP out */ 6184 { 0x18, 0x01a19c20 }, /* rear mic */ 6185 { 0x19, 0x99a3092f }, /* front mic */ 6186 { 0x1b, 0x0201401f }, /* front lineout */ 6187 { } 6188 }, 6189 .chain_id = ALC269_FIXUP_DMIC, 6190 }, 6191 [ALC256_FIXUP_INTEL_NUC8_RUGGED] = { 6192 .type = HDA_FIXUP_PINS, 6193 .v.pins = (const struct hda_pintbl[]) { 6194 { 0x1b, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 6195 { } 6196 }, 6197 .chained = true, 6198 .chain_id = ALC269_FIXUP_HEADSET_MODE 6199 }, 6200 [ALC256_FIXUP_INTEL_NUC10] = { 6201 .type = HDA_FIXUP_PINS, 6202 .v.pins = (const struct hda_pintbl[]) { 6203 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 6204 { } 6205 }, 6206 .chained = true, 6207 .chain_id = ALC269_FIXUP_HEADSET_MODE 6208 }, 6209 [ALC255_FIXUP_XIAOMI_HEADSET_MIC] = { 6210 .type = HDA_FIXUP_VERBS, 6211 .v.verbs = (const struct hda_verb[]) { 6212 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 }, 6213 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 }, 6214 { } 6215 }, 6216 .chained = true, 6217 .chain_id = ALC289_FIXUP_ASUS_GA502 6218 }, 6219 [ALC274_FIXUP_HP_MIC] = { 6220 .type = HDA_FIXUP_VERBS, 6221 .v.verbs = (const struct hda_verb[]) { 6222 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 }, 6223 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 }, 6224 { } 6225 }, 6226 }, 6227 [ALC274_FIXUP_HP_HEADSET_MIC] = { 6228 .type = HDA_FIXUP_FUNC, 6229 .v.func = alc274_fixup_hp_headset_mic, 6230 .chained = true, 6231 .chain_id = ALC274_FIXUP_HP_MIC 6232 }, 6233 [ALC274_FIXUP_HP_ENVY_GPIO] = { 6234 .type = HDA_FIXUP_FUNC, 6235 .v.func = alc274_fixup_hp_envy_gpio, 6236 }, 6237 [ALC274_FIXUP_ASUS_ZEN_AIO_27] = { 6238 .type = HDA_FIXUP_VERBS, 6239 .v.verbs = (const struct hda_verb[]) { 6240 { 0x20, AC_VERB_SET_COEF_INDEX, 0x10 }, 6241 { 0x20, AC_VERB_SET_PROC_COEF, 0xc420 }, 6242 { 0x20, AC_VERB_SET_COEF_INDEX, 0x40 }, 6243 { 0x20, AC_VERB_SET_PROC_COEF, 0x8800 }, 6244 { 0x20, AC_VERB_SET_COEF_INDEX, 0x49 }, 6245 { 0x20, AC_VERB_SET_PROC_COEF, 0x0249 }, 6246 { 0x20, AC_VERB_SET_COEF_INDEX, 0x4a }, 6247 { 0x20, AC_VERB_SET_PROC_COEF, 0x202b }, 6248 { 0x20, AC_VERB_SET_COEF_INDEX, 0x62 }, 6249 { 0x20, AC_VERB_SET_PROC_COEF, 0xa007 }, 6250 { 0x20, AC_VERB_SET_COEF_INDEX, 0x6b }, 6251 { 0x20, AC_VERB_SET_PROC_COEF, 0x5060 }, 6252 {} 6253 }, 6254 .chained = true, 6255 .chain_id = ALC2XX_FIXUP_HEADSET_MIC, 6256 }, 6257 [ALC256_FIXUP_ASUS_HPE] = { 6258 .type = HDA_FIXUP_VERBS, 6259 .v.verbs = (const struct hda_verb[]) { 6260 /* Set EAPD high */ 6261 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f }, 6262 { 0x20, AC_VERB_SET_PROC_COEF, 0x7778 }, 6263 { } 6264 }, 6265 .chained = true, 6266 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC 6267 }, 6268 [ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK] = { 6269 .type = HDA_FIXUP_FUNC, 6270 .v.func = alc_fixup_headset_jack, 6271 .chained = true, 6272 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 6273 }, 6274 [ALC287_FIXUP_HP_GPIO_LED] = { 6275 .type = HDA_FIXUP_FUNC, 6276 .v.func = alc287_fixup_hp_gpio_led, 6277 }, 6278 [ALC256_FIXUP_HP_HEADSET_MIC] = { 6279 .type = HDA_FIXUP_FUNC, 6280 .v.func = alc274_fixup_hp_headset_mic, 6281 }, 6282 [ALC236_FIXUP_DELL_AIO_HEADSET_MIC] = { 6283 .type = HDA_FIXUP_FUNC, 6284 .v.func = alc_fixup_no_int_mic, 6285 .chained = true, 6286 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE 6287 }, 6288 [ALC282_FIXUP_ACER_DISABLE_LINEOUT] = { 6289 .type = HDA_FIXUP_PINS, 6290 .v.pins = (const struct hda_pintbl[]) { 6291 { 0x1b, 0x411111f0 }, 6292 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 6293 { }, 6294 }, 6295 .chained = true, 6296 .chain_id = ALC269_FIXUP_HEADSET_MODE 6297 }, 6298 [ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST] = { 6299 .type = HDA_FIXUP_FUNC, 6300 .v.func = alc269_fixup_limit_int_mic_boost, 6301 .chained = true, 6302 .chain_id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, 6303 }, 6304 [ALC256_FIXUP_ACER_HEADSET_MIC] = { 6305 .type = HDA_FIXUP_PINS, 6306 .v.pins = (const struct hda_pintbl[]) { 6307 { 0x19, 0x02a1113c }, /* use as headset mic, without its own jack detect */ 6308 { 0x1a, 0x90a1092f }, /* use as internal mic */ 6309 { } 6310 }, 6311 .chained = true, 6312 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 6313 }, 6314 [ALC285_FIXUP_IDEAPAD_S740_COEF] = { 6315 .type = HDA_FIXUP_FUNC, 6316 .v.func = alc285_fixup_ideapad_s740_coef, 6317 .chained = true, 6318 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 6319 }, 6320 [ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST] = { 6321 .type = HDA_FIXUP_FUNC, 6322 .v.func = alc269_fixup_limit_int_mic_boost, 6323 .chained = true, 6324 .chain_id = ALC285_FIXUP_HP_MUTE_LED, 6325 }, 6326 [ALC295_FIXUP_ASUS_DACS] = { 6327 .type = HDA_FIXUP_FUNC, 6328 .v.func = alc295_fixup_asus_dacs, 6329 }, 6330 [ALC295_FIXUP_HP_OMEN] = { 6331 .type = HDA_FIXUP_PINS, 6332 .v.pins = (const struct hda_pintbl[]) { 6333 { 0x12, 0xb7a60130 }, 6334 { 0x13, 0x40000000 }, 6335 { 0x14, 0x411111f0 }, 6336 { 0x16, 0x411111f0 }, 6337 { 0x17, 0x90170110 }, 6338 { 0x18, 0x411111f0 }, 6339 { 0x19, 0x02a11030 }, 6340 { 0x1a, 0x411111f0 }, 6341 { 0x1b, 0x04a19030 }, 6342 { 0x1d, 0x40600001 }, 6343 { 0x1e, 0x411111f0 }, 6344 { 0x21, 0x03211020 }, 6345 {} 6346 }, 6347 .chained = true, 6348 .chain_id = ALC269_FIXUP_HP_LINE1_MIC1_LED, 6349 }, 6350 [ALC285_FIXUP_HP_SPECTRE_X360] = { 6351 .type = HDA_FIXUP_FUNC, 6352 .v.func = alc285_fixup_hp_spectre_x360, 6353 }, 6354 [ALC285_FIXUP_HP_SPECTRE_X360_EB1] = { 6355 .type = HDA_FIXUP_FUNC, 6356 .v.func = alc285_fixup_hp_spectre_x360_eb1 6357 }, 6358 [ALC285_FIXUP_HP_SPECTRE_X360_DF1] = { 6359 .type = HDA_FIXUP_FUNC, 6360 .v.func = alc285_fixup_hp_spectre_x360_df1 6361 }, 6362 [ALC285_FIXUP_HP_ENVY_X360] = { 6363 .type = HDA_FIXUP_FUNC, 6364 .v.func = alc285_fixup_hp_envy_x360, 6365 .chained = true, 6366 .chain_id = ALC285_FIXUP_HP_GPIO_AMP_INIT, 6367 }, 6368 [ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP] = { 6369 .type = HDA_FIXUP_FUNC, 6370 .v.func = alc285_fixup_ideapad_s740_coef, 6371 .chained = true, 6372 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK, 6373 }, 6374 [ALC287_FIXUP_LENOVO_YOGA_PRO7] = { 6375 .type = HDA_FIXUP_FUNC, 6376 .v.func = alc_fixup_yoga_pro7_audio, 6377 .chained = true, 6378 .chain_id = ALC269_FIXUP_LENOVO_XPAD_ACPI, 6379 }, 6380 [ALC287_FIXUP_LENOVO_XPAD_HEADSET_JACK] = { 6381 .type = HDA_FIXUP_FUNC, 6382 .v.func = alc_fixup_headset_jack, 6383 .chained = true, 6384 /* Same as ALC285_FIXUP_THINKPAD_HEADSET_JACK, except that the 6385 * mute LEDs are driven through ideapad_laptop rather than 6386 * thinkpad_acpi. 6387 */ 6388 .chain_id = ALC287_FIXUP_LENOVO_YOGA_PRO7, 6389 }, 6390 [ALC623_FIXUP_LENOVO_THINKSTATION_P340] = { 6391 .type = HDA_FIXUP_FUNC, 6392 .v.func = alc_fixup_no_shutup, 6393 .chained = true, 6394 .chain_id = ALC283_FIXUP_HEADSET_MIC, 6395 }, 6396 [ALC255_FIXUP_ACER_HEADPHONE_AND_MIC] = { 6397 .type = HDA_FIXUP_PINS, 6398 .v.pins = (const struct hda_pintbl[]) { 6399 { 0x21, 0x03211030 }, /* Change the Headphone location to Left */ 6400 { } 6401 }, 6402 .chained = true, 6403 .chain_id = ALC255_FIXUP_XIAOMI_HEADSET_MIC 6404 }, 6405 [ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST] = { 6406 .type = HDA_FIXUP_FUNC, 6407 .v.func = alc269_fixup_limit_int_mic_boost, 6408 .chained = true, 6409 .chain_id = ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF, 6410 }, 6411 [ALC285_FIXUP_LEGION_Y9000X_SPEAKERS] = { 6412 .type = HDA_FIXUP_FUNC, 6413 .v.func = alc285_fixup_ideapad_s740_coef, 6414 .chained = true, 6415 .chain_id = ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE, 6416 }, 6417 [ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE] = { 6418 .type = HDA_FIXUP_FUNC, 6419 .v.func = alc287_fixup_legion_15imhg05_speakers, 6420 .chained = true, 6421 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 6422 }, 6423 [ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS] = { 6424 .type = HDA_FIXUP_VERBS, 6425 //.v.verbs = legion_15imhg05_coefs, 6426 .v.verbs = (const struct hda_verb[]) { 6427 // set left speaker Legion 7i. 6428 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 6429 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 }, 6430 6431 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 6432 { 0x20, AC_VERB_SET_PROC_COEF, 0xc }, 6433 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6434 { 0x20, AC_VERB_SET_PROC_COEF, 0x1a }, 6435 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 6436 6437 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 6438 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 6439 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6440 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6441 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 6442 6443 // set right speaker Legion 7i. 6444 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 6445 { 0x20, AC_VERB_SET_PROC_COEF, 0x42 }, 6446 6447 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 6448 { 0x20, AC_VERB_SET_PROC_COEF, 0xc }, 6449 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6450 { 0x20, AC_VERB_SET_PROC_COEF, 0x2a }, 6451 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 6452 6453 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 6454 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 6455 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6456 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6457 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 6458 {} 6459 }, 6460 .chained = true, 6461 .chain_id = ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE, 6462 }, 6463 [ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE] = { 6464 .type = HDA_FIXUP_FUNC, 6465 .v.func = alc287_fixup_legion_15imhg05_speakers, 6466 .chained = true, 6467 .chain_id = ALC269_FIXUP_HEADSET_MODE, 6468 }, 6469 [ALC287_FIXUP_YOGA7_14ITL_SPEAKERS] = { 6470 .type = HDA_FIXUP_VERBS, 6471 .v.verbs = (const struct hda_verb[]) { 6472 // set left speaker Yoga 7i. 6473 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 6474 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 }, 6475 6476 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 6477 { 0x20, AC_VERB_SET_PROC_COEF, 0xc }, 6478 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6479 { 0x20, AC_VERB_SET_PROC_COEF, 0x1a }, 6480 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 6481 6482 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 6483 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 6484 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6485 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6486 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 6487 6488 // set right speaker Yoga 7i. 6489 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 6490 { 0x20, AC_VERB_SET_PROC_COEF, 0x46 }, 6491 6492 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 6493 { 0x20, AC_VERB_SET_PROC_COEF, 0xc }, 6494 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6495 { 0x20, AC_VERB_SET_PROC_COEF, 0x2a }, 6496 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 6497 6498 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 6499 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 6500 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6501 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6502 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 6503 {} 6504 }, 6505 .chained = true, 6506 .chain_id = ALC269_FIXUP_HEADSET_MODE, 6507 }, 6508 [ALC298_FIXUP_LENOVO_C940_DUET7] = { 6509 .type = HDA_FIXUP_FUNC, 6510 .v.func = alc298_fixup_lenovo_c940_duet7, 6511 }, 6512 [ALC287_FIXUP_LENOVO_YOGA_BOOK_9I] = { 6513 .type = HDA_FIXUP_FUNC, 6514 .v.func = alc287_fixup_lenovo_yoga_book_9i, 6515 }, 6516 [ALC287_FIXUP_13S_GEN2_SPEAKERS] = { 6517 .type = HDA_FIXUP_VERBS, 6518 .v.verbs = (const struct hda_verb[]) { 6519 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 6520 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 }, 6521 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 6522 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 6523 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6524 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6525 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 6526 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 6527 { 0x20, AC_VERB_SET_PROC_COEF, 0x42 }, 6528 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 6529 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 6530 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6531 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6532 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 6533 {} 6534 }, 6535 .chained = true, 6536 .chain_id = ALC269_FIXUP_HEADSET_MODE, 6537 }, 6538 [ALC256_FIXUP_SET_COEF_DEFAULTS] = { 6539 .type = HDA_FIXUP_FUNC, 6540 .v.func = alc256_fixup_set_coef_defaults, 6541 }, 6542 [ALC245_FIXUP_HP_GPIO_LED] = { 6543 .type = HDA_FIXUP_FUNC, 6544 .v.func = alc245_fixup_hp_gpio_led, 6545 }, 6546 [ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = { 6547 .type = HDA_FIXUP_PINS, 6548 .v.pins = (const struct hda_pintbl[]) { 6549 { 0x19, 0x03a11120 }, /* use as headset mic, without its own jack detect */ 6550 { } 6551 }, 6552 .chained = true, 6553 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, 6554 }, 6555 [ALC233_FIXUP_NO_AUDIO_JACK] = { 6556 .type = HDA_FIXUP_FUNC, 6557 .v.func = alc233_fixup_no_audio_jack, 6558 }, 6559 [ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME] = { 6560 .type = HDA_FIXUP_FUNC, 6561 .v.func = alc256_fixup_mic_no_presence_and_resume, 6562 .chained = true, 6563 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 6564 }, 6565 [ALC256_FIXUP_XIAOMI_PRO15_RESUME] = { 6566 .type = HDA_FIXUP_FUNC, 6567 .v.func = alc256_fixup_xiaomi_pro15_resume, 6568 }, 6569 [ALC287_FIXUP_LEGION_16ACHG6] = { 6570 .type = HDA_FIXUP_FUNC, 6571 .v.func = alc287_fixup_legion_16achg6_speakers, 6572 }, 6573 [ALC287_FIXUP_CS35L41_I2C_2] = { 6574 .type = HDA_FIXUP_FUNC, 6575 .v.func = cs35l41_fixup_i2c_two, 6576 }, 6577 [ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED] = { 6578 .type = HDA_FIXUP_FUNC, 6579 .v.func = cs35l41_fixup_i2c_two, 6580 .chained = true, 6581 .chain_id = ALC285_FIXUP_HP_MUTE_LED, 6582 }, 6583 [ALC287_FIXUP_CS35L41_I2C_4] = { 6584 .type = HDA_FIXUP_FUNC, 6585 .v.func = cs35l41_fixup_i2c_four, 6586 }, 6587 [ALC245_FIXUP_CS35L41_SPI_2] = { 6588 .type = HDA_FIXUP_FUNC, 6589 .v.func = cs35l41_fixup_spi_two, 6590 }, 6591 [ALC245_FIXUP_CS35L41_SPI_1] = { 6592 .type = HDA_FIXUP_FUNC, 6593 .v.func = cs35l41_fixup_spi_one, 6594 }, 6595 [ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED] = { 6596 .type = HDA_FIXUP_FUNC, 6597 .v.func = cs35l41_fixup_spi_two, 6598 .chained = true, 6599 .chain_id = ALC285_FIXUP_HP_GPIO_LED, 6600 }, 6601 [ALC245_FIXUP_CS35L41_SPI_4] = { 6602 .type = HDA_FIXUP_FUNC, 6603 .v.func = cs35l41_fixup_spi_four, 6604 }, 6605 [ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED] = { 6606 .type = HDA_FIXUP_FUNC, 6607 .v.func = cs35l41_fixup_spi_four, 6608 .chained = true, 6609 .chain_id = ALC285_FIXUP_HP_GPIO_LED, 6610 }, 6611 [ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED] = { 6612 .type = HDA_FIXUP_VERBS, 6613 .v.verbs = (const struct hda_verb[]) { 6614 { 0x20, AC_VERB_SET_COEF_INDEX, 0x19 }, 6615 { 0x20, AC_VERB_SET_PROC_COEF, 0x8e11 }, 6616 { } 6617 }, 6618 .chained = true, 6619 .chain_id = ALC285_FIXUP_HP_MUTE_LED, 6620 }, 6621 [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET] = { 6622 .type = HDA_FIXUP_FUNC, 6623 .v.func = alc_fixup_dell4_mic_no_presence_quiet, 6624 .chained = true, 6625 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 6626 }, 6627 [ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE] = { 6628 .type = HDA_FIXUP_PINS, 6629 .v.pins = (const struct hda_pintbl[]) { 6630 { 0x19, 0x02a1112c }, /* use as headset mic, without its own jack detect */ 6631 { } 6632 }, 6633 .chained = true, 6634 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 6635 }, 6636 [ALC295_FIXUP_FRAMEWORK_LAPTOP_LIMIT_INT_MIC_BOOST] = { 6637 .type = HDA_FIXUP_FUNC, 6638 .v.func = alc269_fixup_limit_int_mic_boost, 6639 .chained = true, 6640 .chain_id = ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE, 6641 }, 6642 [ALC287_FIXUP_LEGION_16ITHG6] = { 6643 .type = HDA_FIXUP_FUNC, 6644 .v.func = alc287_fixup_legion_16ithg6_speakers, 6645 }, 6646 [ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK] = { 6647 .type = HDA_FIXUP_VERBS, 6648 .v.verbs = (const struct hda_verb[]) { 6649 // enable left speaker 6650 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 6651 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 }, 6652 6653 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 6654 { 0x20, AC_VERB_SET_PROC_COEF, 0xc }, 6655 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6656 { 0x20, AC_VERB_SET_PROC_COEF, 0x1a }, 6657 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 6658 6659 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 6660 { 0x20, AC_VERB_SET_PROC_COEF, 0xf }, 6661 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6662 { 0x20, AC_VERB_SET_PROC_COEF, 0x42 }, 6663 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 6664 6665 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 6666 { 0x20, AC_VERB_SET_PROC_COEF, 0x10 }, 6667 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6668 { 0x20, AC_VERB_SET_PROC_COEF, 0x40 }, 6669 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 6670 6671 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 6672 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 6673 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6674 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6675 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 6676 6677 // enable right speaker 6678 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 6679 { 0x20, AC_VERB_SET_PROC_COEF, 0x46 }, 6680 6681 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 6682 { 0x20, AC_VERB_SET_PROC_COEF, 0xc }, 6683 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6684 { 0x20, AC_VERB_SET_PROC_COEF, 0x2a }, 6685 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 6686 6687 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 6688 { 0x20, AC_VERB_SET_PROC_COEF, 0xf }, 6689 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6690 { 0x20, AC_VERB_SET_PROC_COEF, 0x46 }, 6691 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 6692 6693 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 6694 { 0x20, AC_VERB_SET_PROC_COEF, 0x10 }, 6695 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6696 { 0x20, AC_VERB_SET_PROC_COEF, 0x44 }, 6697 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 6698 6699 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 6700 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 6701 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6702 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 6703 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 6704 6705 { }, 6706 }, 6707 }, 6708 [ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN] = { 6709 .type = HDA_FIXUP_FUNC, 6710 .v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin, 6711 .chained = true, 6712 .chain_id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK, 6713 }, 6714 [ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN] = { 6715 .type = HDA_FIXUP_FUNC, 6716 .v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin, 6717 .chained = true, 6718 .chain_id = ALC287_FIXUP_CS35L41_I2C_2, 6719 }, 6720 [ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS] = { 6721 .type = HDA_FIXUP_FUNC, 6722 .v.func = alc295_fixup_dell_inspiron_top_speakers, 6723 .chained = true, 6724 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 6725 }, 6726 [ALC236_FIXUP_DELL_DUAL_CODECS] = { 6727 .type = HDA_FIXUP_PINS, 6728 .v.func = alc1220_fixup_gb_dual_codecs, 6729 .chained = true, 6730 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 6731 }, 6732 [ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI] = { 6733 .type = HDA_FIXUP_FUNC, 6734 .v.func = cs35l41_fixup_i2c_two, 6735 .chained = true, 6736 .chain_id = ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK, 6737 }, 6738 [ALC287_FIXUP_TAS2781_I2C] = { 6739 .type = HDA_FIXUP_FUNC, 6740 .v.func = tas2781_fixup_tias_i2c, 6741 .chained = true, 6742 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK, 6743 }, 6744 [ALC287_FIXUP_ASUS_ALLY_X] = { 6745 .type = HDA_FIXUP_PINS, 6746 .v.pins = (const struct hda_pintbl[]) { 6747 { 0x19, 0x03a11050 }, /* headset mic */ 6748 { } 6749 }, 6750 .chained = true, 6751 .chain_id = ALC287_FIXUP_ASUS_ALLY_X_SPEAKER, 6752 }, 6753 [ALC287_FIXUP_ASUS_ALLY_X_SPEAKER] = { 6754 .type = HDA_FIXUP_FUNC, 6755 .v.func = alc285_fixup_speaker2_to_dac1, 6756 .chained = true, 6757 .chain_id = ALC287_FIXUP_ASUS_ALLY_X_I2C, 6758 }, 6759 [ALC287_FIXUP_ASUS_ALLY_X_I2C] = { 6760 .type = HDA_FIXUP_FUNC, 6761 .v.func = tas2781_fixup_tias_i2c, 6762 .chained = true, 6763 .chain_id = ALC225_FIXUP_HEADSET_JACK, 6764 }, 6765 [ALC245_FIXUP_TAS2781_SPI_2] = { 6766 .type = HDA_FIXUP_FUNC, 6767 .v.func = tas2781_fixup_spi, 6768 .chained = true, 6769 .chain_id = ALC285_FIXUP_HP_GPIO_LED, 6770 }, 6771 [ALC287_FIXUP_TXNW2781_I2C] = { 6772 .type = HDA_FIXUP_FUNC, 6773 .v.func = tas2781_fixup_txnw_i2c, 6774 .chained = true, 6775 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK, 6776 }, 6777 [ALC287_FIXUP_TXNW2781_I2C_ASUS] = { 6778 .type = HDA_FIXUP_FUNC, 6779 .v.func = tas2781_fixup_txnw_i2c, 6780 .chained = true, 6781 .chain_id = ALC294_FIXUP_ASUS_SPK, 6782 }, 6783 [ALC287_FIXUP_YOGA7_14ARB7_I2C] = { 6784 .type = HDA_FIXUP_FUNC, 6785 .v.func = yoga7_14arb7_fixup_i2c, 6786 .chained = true, 6787 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK, 6788 }, 6789 [ALC245_FIXUP_HP_MUTE_LED_COEFBIT] = { 6790 .type = HDA_FIXUP_FUNC, 6791 .v.func = alc245_fixup_hp_mute_led_coefbit, 6792 }, 6793 [ALC245_FIXUP_HP_MUTE_LED_V1_COEFBIT] = { 6794 .type = HDA_FIXUP_FUNC, 6795 .v.func = alc245_fixup_hp_mute_led_v1_coefbit, 6796 }, 6797 [ALC245_FIXUP_HP_MUTE_LED_V2_COEFBIT] = { 6798 .type = HDA_FIXUP_FUNC, 6799 .v.func = alc245_fixup_hp_mute_led_v2_coefbit, 6800 }, 6801 [ALC245_FIXUP_HP_X360_MUTE_LEDS] = { 6802 .type = HDA_FIXUP_FUNC, 6803 .v.func = alc245_fixup_hp_mute_led_coefbit, 6804 .chained = true, 6805 .chain_id = ALC245_FIXUP_HP_GPIO_LED 6806 }, 6807 [ALC287_FIXUP_THINKPAD_I2S_SPK] = { 6808 .type = HDA_FIXUP_FUNC, 6809 .v.func = alc287_fixup_bind_dacs, 6810 .chained = true, 6811 .chain_id = ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK, 6812 }, 6813 [ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD] = { 6814 .type = HDA_FIXUP_FUNC, 6815 .v.func = alc287_fixup_tb_vmaster_led, 6816 .chained = true, 6817 .chain_id = ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI, 6818 }, 6819 [ALC2XX_FIXUP_HEADSET_MIC] = { 6820 .type = HDA_FIXUP_FUNC, 6821 .v.func = alc2xx_fixup_headset_mic, 6822 }, 6823 [ALC289_FIXUP_DELL_CS35L41_SPI_2] = { 6824 .type = HDA_FIXUP_FUNC, 6825 .v.func = cs35l41_fixup_spi_two, 6826 .chained = true, 6827 .chain_id = ALC289_FIXUP_DUAL_SPK 6828 }, 6829 [ALC256_FIXUP_ACER_SFG16_MICMUTE_LED] = { 6830 .type = HDA_FIXUP_FUNC, 6831 .v.func = alc256_fixup_acer_sfg16_micmute_led, 6832 }, 6833 [ALC256_FIXUP_HEADPHONE_AMP_VOL] = { 6834 .type = HDA_FIXUP_FUNC, 6835 .v.func = alc256_decrease_headphone_amp_val, 6836 }, 6837 [ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX] = { 6838 .type = HDA_FIXUP_FUNC, 6839 .v.func = alc245_fixup_hp_spectre_x360_eu0xxx, 6840 }, 6841 [ALC245_FIXUP_HP_SPECTRE_X360_16_AA0XXX] = { 6842 .type = HDA_FIXUP_FUNC, 6843 .v.func = alc245_fixup_hp_spectre_x360_16_aa0xxx, 6844 }, 6845 [ALC245_FIXUP_HP_ZBOOK_FIREFLY_G12A] = { 6846 .type = HDA_FIXUP_FUNC, 6847 .v.func = alc245_fixup_hp_zbook_firefly_g12a, 6848 }, 6849 [ALC285_FIXUP_ASUS_GA403U] = { 6850 .type = HDA_FIXUP_FUNC, 6851 .v.func = alc285_fixup_asus_ga403u, 6852 }, 6853 [ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC] = { 6854 .type = HDA_FIXUP_PINS, 6855 .v.pins = (const struct hda_pintbl[]) { 6856 { 0x19, 0x03a11050 }, 6857 { 0x1b, 0x03a11c30 }, 6858 { } 6859 }, 6860 .chained = true, 6861 .chain_id = ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1 6862 }, 6863 [ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1] = { 6864 .type = HDA_FIXUP_FUNC, 6865 .v.func = alc285_fixup_speaker2_to_dac1, 6866 .chained = true, 6867 .chain_id = ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC, 6868 }, 6869 [ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC] = { 6870 .type = HDA_FIXUP_PINS, 6871 .v.pins = (const struct hda_pintbl[]) { 6872 { 0x19, 0x03a11050 }, 6873 { 0x1b, 0x03a11c30 }, 6874 { } 6875 }, 6876 }, 6877 [ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1] = { 6878 .type = HDA_FIXUP_FUNC, 6879 .v.func = alc285_fixup_speaker2_to_dac1, 6880 .chained = true, 6881 .chain_id = ALC285_FIXUP_ASUS_GA403U, 6882 }, 6883 [ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318] = { 6884 .type = HDA_FIXUP_FUNC, 6885 .v.func = alc287_fixup_lenovo_thinkpad_with_alc1318, 6886 .chained = true, 6887 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 6888 }, 6889 [ALC256_FIXUP_CHROME_BOOK] = { 6890 .type = HDA_FIXUP_FUNC, 6891 .v.func = alc256_fixup_chromebook, 6892 .chained = true, 6893 .chain_id = ALC225_FIXUP_HEADSET_JACK 6894 }, 6895 [ALC245_FIXUP_CLEVO_NOISY_MIC] = { 6896 .type = HDA_FIXUP_FUNC, 6897 .v.func = alc269_fixup_limit_int_mic_boost, 6898 .chained = true, 6899 .chain_id = ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE, 6900 }, 6901 [ALC245_FIXUP_MINISFORUM_JACK_DETECT] = { 6902 .type = HDA_FIXUP_FUNC, 6903 .v.func = alc245_fixup_minisforum_jack_detect, 6904 }, 6905 [ALC269_FIXUP_VAIO_VJFH52_MIC_NO_PRESENCE] = { 6906 .type = HDA_FIXUP_PINS, 6907 .v.pins = (const struct hda_pintbl[]) { 6908 { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */ 6909 { 0x1b, 0x20a11040 }, /* dock mic */ 6910 { } 6911 }, 6912 .chained = true, 6913 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST 6914 }, 6915 [ALC233_FIXUP_MEDION_MTL_SPK] = { 6916 .type = HDA_FIXUP_PINS, 6917 .v.pins = (const struct hda_pintbl[]) { 6918 { 0x1b, 0x90170110 }, 6919 { } 6920 }, 6921 }, 6922 [ALC233_FIXUP_STARLABS_STARFIGHTER] = { 6923 .type = HDA_FIXUP_FUNC, 6924 .v.func = alc233_fixup_starlabs_starfighter, 6925 .chained = true, 6926 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, 6927 }, 6928 [ALC294_FIXUP_BASS_SPEAKER_15] = { 6929 .type = HDA_FIXUP_FUNC, 6930 .v.func = alc294_fixup_bass_speaker_15, 6931 }, 6932 [ALC283_FIXUP_DELL_HP_RESUME] = { 6933 .type = HDA_FIXUP_FUNC, 6934 .v.func = alc283_fixup_dell_hp_resume, 6935 }, 6936 [ALC294_FIXUP_ASUS_CS35L41_SPI_2] = { 6937 .type = HDA_FIXUP_FUNC, 6938 .v.func = cs35l41_fixup_spi_two, 6939 .chained = true, 6940 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC, 6941 }, 6942 [ALC274_FIXUP_HP_AIO_BIND_DACS] = { 6943 .type = HDA_FIXUP_FUNC, 6944 .v.func = alc274_fixup_hp_aio_bind_dacs, 6945 }, 6946 [ALC285_FIXUP_ASUS_GA605K_HEADSET_MIC] = { 6947 .type = HDA_FIXUP_PINS, 6948 .v.pins = (const struct hda_pintbl[]) { 6949 { 0x19, 0x03a11050 }, 6950 { 0x1b, 0x03a11c30 }, 6951 { } 6952 }, 6953 .chained = true, 6954 .chain_id = ALC285_FIXUP_SPEAKER2_TO_DAC1 6955 }, 6956 [ALC269_FIXUP_POSITIVO_P15X_HEADSET_MIC] = { 6957 .type = HDA_FIXUP_FUNC, 6958 .v.func = alc269_fixup_limit_int_mic_boost, 6959 .chained = true, 6960 .chain_id = ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE, 6961 }, 6962 [ALC289_FIXUP_ASUS_ZEPHYRUS_DUAL_SPK] = { 6963 .type = HDA_FIXUP_PINS, 6964 .v.pins = (const struct hda_pintbl[]) { 6965 { 0x17, 0x90170151 }, /* Internal Speaker LFE */ 6966 { 0x1e, 0x90170150 }, /* Internal Speaker */ 6967 { } 6968 }, 6969 }, 6970 [ALC256_FIXUP_VAIO_RPL_MIC_NO_PRESENCE] = { 6971 .type = HDA_FIXUP_PINS, 6972 .v.pins = (const struct hda_pintbl[]) { 6973 { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */ 6974 { 0x1a, 0x22a190a0 }, /* dock mic */ 6975 { } 6976 }, 6977 .chained = true, 6978 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST 6979 }, 6980 [ALC245_FIXUP_HP_TAS2781_SPI_MUTE_LED] = { 6981 .type = HDA_FIXUP_FUNC, 6982 .v.func = alc245_tas2781_spi_hp_fixup_muteled, 6983 }, 6984 [ALC245_FIXUP_HP_TAS2781_I2C_MUTE_LED] = { 6985 .type = HDA_FIXUP_FUNC, 6986 .v.func = alc245_tas2781_i2c_hp_fixup_muteled, 6987 }, 6988 [ALC245_FIXUP_HP_TAS2781_I2C_MUTE_LED_INVERTED] = { 6989 .type = HDA_FIXUP_FUNC, 6990 .v.func = alc245_tas2781_i2c_hp_fixup_muteled_inverted, 6991 }, 6992 [ALC288_FIXUP_SURFACE_SWAP_DACS] = { 6993 .type = HDA_FIXUP_FUNC, 6994 .v.func = alc288_fixup_surface_swap_dacs, 6995 }, 6996 [ALC233_FIXUP_LENOVO_GPIO2_MIC_HOTKEY] = { 6997 .type = HDA_FIXUP_FUNC, 6998 .v.func = alc233_fixup_lenovo_gpio2_mic_hotkey, 6999 }, 7000 [ALC245_FIXUP_BASS_HP_DAC] = { 7001 .type = HDA_FIXUP_FUNC, 7002 /* Borrow the DAC routing selected for those Thinkpads */ 7003 .v.func = alc285_fixup_thinkpad_x1_gen7, 7004 }, 7005 [ALC245_FIXUP_ACER_MICMUTE_LED] = { 7006 .type = HDA_FIXUP_FUNC, 7007 .v.func = alc285_fixup_hp_coef_micmute_led, 7008 .chained = true, 7009 .chain_id = ALC2XX_FIXUP_HEADSET_MIC, 7010 }, 7011 [ALC245_FIXUP_CS35L41_I2C_2_MUTE_LED] = { 7012 .type = HDA_FIXUP_FUNC, 7013 .v.func = alc245_fixup_hp_mute_led_coefbit, 7014 .chained = true, 7015 .chain_id = ALC287_FIXUP_CS35L41_I2C_2, 7016 }, 7017 [ALC236_FIXUP_HP_DMIC] = { 7018 .type = HDA_FIXUP_PINS, 7019 .v.pins = (const struct hda_pintbl[]) { 7020 { 0x12, 0x90a60160 }, /* use as internal mic */ 7021 { } 7022 }, 7023 }, 7024 [ALC256_FIXUP_HONOR_MRB_XXX_M1020_AUDIO] = { 7025 .type = HDA_FIXUP_PINS, 7026 .v.pins = (const struct hda_pintbl[]) { 7027 { 0x14, 0x90170111 }, 7028 { 0x19, 0x03a1113c }, 7029 { 0x1a, 0x22a190a0 }, 7030 { 0x1b, 0x90170110 }, 7031 { } 7032 } 7033 }, 7034 [ALC245_FIXUP_HP_ENVY_X360_15_FH0XXX] = { 7035 .type = HDA_FIXUP_FUNC, 7036 .v.func = cs35l41_fixup_i2c_two, 7037 .chained = true, 7038 .chain_id = ALC245_FIXUP_HP_X360_MUTE_LEDS 7039 }, 7040 [ALC287_FIXUP_ACER_MICMUTE_LED] = { 7041 .type = HDA_FIXUP_FUNC, 7042 .v.func = alc287_fixup_acer_micmute_led, 7043 .chained = true, 7044 .chain_id = ALC2XX_FIXUP_HEADSET_MIC, 7045 }, 7046 [ALC236_FIXUP_DELL_HP_POP_NOISE] = { 7047 .type = HDA_FIXUP_FUNC, 7048 .v.func = alc285_fixup_invalidate_dacs, 7049 }, 7050 [ALC274_FIXUP_HP_89E9_GPIO] = { 7051 .type = HDA_FIXUP_FUNC, 7052 .v.func = alc274_fixup_hp_89e9_amp, 7053 }, 7054 [ALC274_FIXUP_HP_VERBS] = { 7055 .type = HDA_FIXUP_VERBS, 7056 .v.verbs = (const struct hda_verb[]) { 7057 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b }, 7058 { 0x20, AC_VERB_SET_PROC_COEF, 0x7778 }, 7059 { 0x20, AC_VERB_SET_COEF_INDEX, 0x10 }, 7060 { 0x20, AC_VERB_SET_PROC_COEF, 0xc580 }, 7061 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 7062 { 0x20, AC_VERB_SET_PROC_COEF, 0x5757 }, 7063 { 0x20, AC_VERB_SET_COEF_INDEX, 0x62 }, 7064 { 0x20, AC_VERB_SET_PROC_COEF, 0xa007 }, 7065 { 0x20, AC_VERB_SET_COEF_INDEX, 0x6b }, 7066 { 0x20, AC_VERB_SET_PROC_COEF, 0x0060 }, 7067 { } 7068 }, 7069 .chained = true, 7070 .chain_id = ALC274_FIXUP_HP_89E9_GPIO, 7071 }, 7072 [ALC287_FIXUP_AW88399_I2C_2] = { 7073 .type = HDA_FIXUP_FUNC, 7074 .v.func = aw88399_fixup_i2c_two, 7075 }, 7076 [ALC287_FIXUP_LENOVO_LEGION_AW88399] = { 7077 .type = HDA_FIXUP_FUNC, 7078 .v.func = alc287_fixup_legion_16iax10h_aw88399, 7079 .chained = true, 7080 .chain_id = ALC287_FIXUP_AW88399_I2C_2, 7081 }, 7082 [ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN_HEADSET] = { 7083 .type = HDA_FIXUP_FUNC, 7084 .v.func = alc_fixup_headset_jack, 7085 .chained = true, 7086 .chain_id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN, 7087 }, 7088 [ALC285_LENOVO_DAC_RENAME] = { 7089 .type = HDA_FIXUP_FUNC, 7090 .v.func = alc285_lenovo_dac_rename, 7091 }, 7092 [ALC287_FIXUP_YOGA9_SPEAKER2_TO_DAC1] = { 7093 .type = HDA_FIXUP_FUNC, 7094 .v.func = alc285_fixup_speaker2_to_dac1, 7095 .chained = true, 7096 .chain_id = ALC287_FIXUP_TXNW2781_I2C, 7097 }, 7098 }; 7099 7100 static const struct hda_quirk alc269_fixup_tbl[] = { 7101 SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC), 7102 SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC), 7103 SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC), 7104 SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700), 7105 SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC), 7106 SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK), 7107 SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK), 7108 SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572), 7109 SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572), 7110 SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS), 7111 SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC), 7112 SND_PCI_QUIRK(0x1025, 0x0840, "Acer Aspire E1", ALC269VB_FIXUP_ASPIRE_E1_COEF), 7113 SND_PCI_QUIRK(0x1025, 0x0943, "Acer Aspire V3-572G", ALC269_FIXUP_ASPIRE_HEADSET_MIC), 7114 SND_PCI_QUIRK(0x1025, 0x100c, "Acer Aspire E5-574G", ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST), 7115 SND_PCI_QUIRK(0x1025, 0x101c, "Acer Veriton N2510G", ALC269_FIXUP_LIFEBOOK), 7116 SND_PCI_QUIRK(0x1025, 0x102b, "Acer Aspire C24-860", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE), 7117 SND_PCI_QUIRK(0x1025, 0x1065, "Acer Aspire C20-820", ALC269VC_FIXUP_ACER_HEADSET_MIC), 7118 SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK), 7119 SND_PCI_QUIRK(0x1025, 0x1094, "Acer Aspire E5-575T", ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST), 7120 SND_PCI_QUIRK(0x1025, 0x1099, "Acer Aspire E5-523G", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 7121 SND_PCI_QUIRK(0x1025, 0x110e, "Acer Aspire ES1-432", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 7122 SND_PCI_QUIRK(0x1025, 0x1166, "Acer Veriton N4640G", ALC269_FIXUP_LIFEBOOK), 7123 SND_PCI_QUIRK(0x1025, 0x1167, "Acer Veriton N6640G", ALC269_FIXUP_LIFEBOOK), 7124 SND_PCI_QUIRK(0x1025, 0x1177, "Acer Predator G9-593", ALC255_FIXUP_PREDATOR_SUBWOOFER), 7125 SND_PCI_QUIRK(0x1025, 0x1178, "Acer Predator G9-593", ALC255_FIXUP_PREDATOR_SUBWOOFER), 7126 SND_PCI_QUIRK(0x1025, 0x1246, "Acer Predator Helios 500", ALC299_FIXUP_PREDATOR_SPK), 7127 SND_PCI_QUIRK(0x1025, 0x1247, "Acer vCopperbox", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS), 7128 SND_PCI_QUIRK(0x1025, 0x1248, "Acer Veriton N4660G", ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE), 7129 SND_PCI_QUIRK(0x1025, 0x1269, "Acer SWIFT SF314-54", ALC256_FIXUP_ACER_HEADSET_MIC), 7130 SND_PCI_QUIRK(0x1025, 0x126a, "Acer Swift SF114-32", ALC256_FIXUP_ACER_MIC_NO_PRESENCE), 7131 SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), 7132 SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), 7133 SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), 7134 SND_PCI_QUIRK(0x1025, 0x129c, "Acer SWIFT SF314-55", ALC256_FIXUP_ACER_HEADSET_MIC), 7135 SND_PCI_QUIRK(0x1025, 0x129d, "Acer SWIFT SF313-51", ALC256_FIXUP_ACER_MIC_NO_PRESENCE), 7136 SND_PCI_QUIRK(0x1025, 0x1300, "Acer SWIFT SF314-56", ALC256_FIXUP_ACER_MIC_NO_PRESENCE), 7137 SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), 7138 SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC), 7139 SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC), 7140 SND_PCI_QUIRK(0x1025, 0x1360, "Acer Aspire A115", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 7141 SND_PCI_QUIRK(0x1025, 0x141f, "Acer Spin SP513-54N", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 7142 SND_PCI_QUIRK(0x1025, 0x142b, "Acer Swift SF314-42", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 7143 SND_PCI_QUIRK(0x1025, 0x1430, "Acer TravelMate B311R-31", ALC256_FIXUP_ACER_MIC_NO_PRESENCE), 7144 SND_PCI_QUIRK(0x1025, 0x1466, "Acer Aspire A515-56", ALC255_FIXUP_ACER_HEADPHONE_AND_MIC), 7145 SND_PCI_QUIRK(0x1025, 0x1534, "Acer Predator PH315-54", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 7146 SND_PCI_QUIRK(0x1025, 0x1539, "Acer Nitro 5 AN515-57", ALC2XX_FIXUP_HEADSET_MIC), 7147 SND_PCI_QUIRK(0x1025, 0x159c, "Acer Nitro 5 AN515-58", ALC287_FIXUP_ACER_MICMUTE_LED), 7148 SND_PCI_QUIRK(0x1025, 0x1597, "Acer Nitro 5 AN517-55", ALC2XX_FIXUP_HEADSET_MIC), 7149 SND_PCI_QUIRK(0x1025, 0x159e, "Acer Nitro 5 AN515-46", ALC2XX_FIXUP_HEADSET_MIC), 7150 SND_PCI_QUIRK(0x1025, 0x160e, "Acer PT316-51S", ALC2XX_FIXUP_HEADSET_MIC), 7151 SND_PCI_QUIRK(0x1025, 0x1616, "Acer Aspire A515-57", ALC256_FIXUP_ACER_SFG16_MICMUTE_LED), 7152 SND_PCI_QUIRK(0x1025, 0x161f, "Acer S40-54", ALC256_FIXUP_ACER_MIC_NO_PRESENCE), 7153 SND_PCI_QUIRK(0x1025, 0x1640, "Acer Aspire A315-44P", ALC256_FIXUP_ACER_SFG16_MICMUTE_LED), 7154 SND_PCI_QUIRK(0x1025, 0x166c, "Acer Predator PH16-71", ALC2XX_FIXUP_HEADSET_MIC), 7155 SND_PCI_QUIRK(0x1025, 0x1679, "Acer Nitro 16 AN16-41", ALC2XX_FIXUP_HEADSET_MIC), 7156 SND_PCI_QUIRK(0x1025, 0x169a, "Acer Swift SFG16", ALC256_FIXUP_ACER_SFG16_MICMUTE_LED), 7157 SND_PCI_QUIRK(0x1025, 0x171e, "Acer Nitro ANV15-51", ALC245_FIXUP_ACER_MICMUTE_LED), 7158 SND_PCI_QUIRK(0x1025, 0x173a, "Acer Swift SFG14-73", ALC245_FIXUP_ACER_MICMUTE_LED), 7159 SND_PCI_QUIRK(0x1025, 0x1758, "Acer Nitro ANV15-41", ALC245_FIXUP_ACER_MICMUTE_LED), 7160 SND_PCI_QUIRK(0x1025, 0x1826, "Acer Helios ZPC", ALC287_FIXUP_PREDATOR_SPK_CS35L41_I2C_2), 7161 SND_PCI_QUIRK(0x1025, 0x182c, "Acer Helios ZPD", ALC287_FIXUP_PREDATOR_SPK_CS35L41_I2C_2), 7162 SND_PCI_QUIRK(0x1025, 0x1844, "Acer Helios ZPS", ALC287_FIXUP_PREDATOR_SPK_CS35L41_I2C_2), 7163 SND_PCI_QUIRK(0x1025, 0x1909, "Acer Nitro ANV16-42", ALC2XX_FIXUP_HEADSET_MIC), 7164 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z), 7165 SND_PCI_QUIRK(0x1028, 0x053c, "Dell Latitude E5430", ALC292_FIXUP_DELL_E7X), 7166 SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS), 7167 SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X), 7168 SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X), 7169 SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X), 7170 SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X), 7171 SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER), 7172 SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE), 7173 SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE), 7174 SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE), 7175 SND_PCI_QUIRK(0x1028, 0x0604, "Dell Venue 11 Pro 7130", ALC283_FIXUP_DELL_HP_RESUME), 7176 SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK), 7177 SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK), 7178 SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X), 7179 SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X), 7180 SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK), 7181 SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 7182 SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 7183 SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13), 7184 SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE), 7185 SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK), 7186 SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE), 7187 SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 7188 SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 7189 SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 7190 SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 7191 SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 7192 SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 7193 SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 7194 SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER), 7195 SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE), 7196 SND_PCI_QUIRK(0x1028, 0x0738, "Dell Precision 5820", ALC269_FIXUP_NO_SHUTUP), 7197 SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME), 7198 SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME), 7199 SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER), 7200 SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3), 7201 SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE), 7202 SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB), 7203 SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB), 7204 SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC), 7205 SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC), 7206 SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB), 7207 SND_PCI_QUIRK(0x1028, 0x0879, "Dell Latitude 5420 Rugged", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE), 7208 SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE), 7209 SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE), 7210 SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB), 7211 SND_PCI_QUIRK(0x1028, 0x097d, "Dell Precision", ALC289_FIXUP_DUAL_SPK), 7212 SND_PCI_QUIRK(0x1028, 0x097e, "Dell Precision", ALC289_FIXUP_DUAL_SPK), 7213 SND_PCI_QUIRK(0x1028, 0x098d, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE), 7214 SND_PCI_QUIRK(0x1028, 0x09bf, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE), 7215 SND_PCI_QUIRK(0x1028, 0x0a2e, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC), 7216 SND_PCI_QUIRK(0x1028, 0x0a30, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC), 7217 SND_PCI_QUIRK(0x1028, 0x0a38, "Dell Latitude 7520", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET), 7218 SND_PCI_QUIRK(0x1028, 0x0a58, "Dell", ALC255_FIXUP_DELL_HEADSET_MIC), 7219 SND_PCI_QUIRK(0x1028, 0x0a61, "Dell XPS 15 9510", ALC289_FIXUP_DUAL_SPK), 7220 SND_PCI_QUIRK(0x1028, 0x0a62, "Dell Precision 5560", ALC289_FIXUP_DUAL_SPK), 7221 SND_PCI_QUIRK(0x1028, 0x0a9d, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE), 7222 SND_PCI_QUIRK(0x1028, 0x0a9e, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE), 7223 SND_PCI_QUIRK(0x1028, 0x0b19, "Dell XPS 15 9520", ALC289_FIXUP_DUAL_SPK), 7224 SND_PCI_QUIRK(0x1028, 0x0b1a, "Dell Precision 5570", ALC289_FIXUP_DUAL_SPK), 7225 SND_PCI_QUIRK(0x1028, 0x0b27, "Dell", ALC245_FIXUP_CS35L41_SPI_2), 7226 SND_PCI_QUIRK(0x1028, 0x0b28, "Dell", ALC245_FIXUP_CS35L41_SPI_2), 7227 SND_PCI_QUIRK(0x1028, 0x0b37, "Dell Inspiron 16 Plus 7620 2-in-1", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS), 7228 SND_PCI_QUIRK(0x1028, 0x0b71, "Dell Inspiron 16 Plus 7620", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS), 7229 SND_PCI_QUIRK(0x1028, 0x0beb, "Dell XPS 15 9530 (2023)", ALC289_FIXUP_DELL_CS35L41_SPI_2), 7230 SND_PCI_QUIRK(0x1028, 0x0c03, "Dell Precision 5340", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE), 7231 SND_PCI_QUIRK(0x1028, 0x0c0b, "Dell Oasis 14 RPL-P", ALC289_FIXUP_RTK_AMP_DUAL_SPK), 7232 SND_PCI_QUIRK(0x1028, 0x0c0d, "Dell Oasis", ALC289_FIXUP_RTK_AMP_DUAL_SPK), 7233 SND_PCI_QUIRK(0x1028, 0x0c0e, "Dell Oasis 16", ALC289_FIXUP_RTK_AMP_DUAL_SPK), 7234 SND_PCI_QUIRK(0x1028, 0x0c19, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS), 7235 SND_PCI_QUIRK(0x1028, 0x0c1a, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS), 7236 SND_PCI_QUIRK(0x1028, 0x0c1b, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS), 7237 SND_PCI_QUIRK(0x1028, 0x0c1c, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS), 7238 SND_PCI_QUIRK(0x1028, 0x0c1d, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS), 7239 SND_PCI_QUIRK(0x1028, 0x0c1e, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS), 7240 SND_PCI_QUIRK(0x1028, 0x0c28, "Dell Inspiron 16 Plus 7630", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS), 7241 SND_PCI_QUIRK(0x1028, 0x0c4d, "Dell", ALC287_FIXUP_CS35L41_I2C_4), 7242 SND_PCI_QUIRK(0x1028, 0x0c90, "Alienware x16 R2", ALC289_FIXUP_DUAL_SPK), 7243 SND_PCI_QUIRK(0x1028, 0x0c94, "Dell Polaris 3 metal", ALC295_FIXUP_DELL_TAS2781_I2C), 7244 SND_PCI_QUIRK(0x1028, 0x0c96, "Dell Polaris 2in1", ALC295_FIXUP_DELL_TAS2781_I2C), 7245 SND_PCI_QUIRK(0x1028, 0x0cbd, "Dell Oasis 13 CS MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2), 7246 SND_PCI_QUIRK(0x1028, 0x0cbe, "Dell Oasis 13 2-IN-1 MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2), 7247 SND_PCI_QUIRK(0x1028, 0x0cbf, "Dell Oasis 13 Low Weight MTU-L", ALC289_FIXUP_DELL_CS35L41_SPI_2), 7248 SND_PCI_QUIRK(0x1028, 0x0cc0, "Dell Oasis 13", ALC289_FIXUP_RTK_AMP_DUAL_SPK), 7249 SND_PCI_QUIRK(0x1028, 0x0cc1, "Dell Oasis 14 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2), 7250 SND_PCI_QUIRK(0x1028, 0x0cc2, "Dell Oasis 14 2-in-1 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2), 7251 SND_PCI_QUIRK(0x1028, 0x0cc3, "Dell Oasis 14 Low Weight MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2), 7252 SND_PCI_QUIRK(0x1028, 0x0cc4, "Dell Oasis 16 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2), 7253 SND_PCI_QUIRK(0x1028, 0x0cc5, "Dell Oasis 14", ALC289_FIXUP_RTK_AMP_DUAL_SPK), 7254 SND_PCI_QUIRK(0x1028, 0x0d56, "Dell Pro Tower QCT1255", ALC236_FIXUP_DELL_HP_POP_NOISE), 7255 SND_PCI_QUIRK(0x1028, 0x0d58, "Dell Pro Micro QCM1255", ALC236_FIXUP_DELL_HP_POP_NOISE), 7256 SND_PCI_QUIRK(0x1028, 0x0d5a, "Dell Pro Slim QCS1255", ALC236_FIXUP_DELL_HP_POP_NOISE), 7257 SND_PCI_QUIRK(0x1028, 0x0e6b, "Dell Pro Tower QCT1255", ALC236_FIXUP_DELL_HP_POP_NOISE), 7258 SND_PCI_QUIRK(0x1028, 0x0e6c, "Dell Pro Slim QCS1255", ALC236_FIXUP_DELL_HP_POP_NOISE), 7259 SND_PCI_QUIRK(0x1028, 0x0e6d, "Dell Pro Micro QCM1255", ALC236_FIXUP_DELL_HP_POP_NOISE), 7260 SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 7261 SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 7262 SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2), 7263 SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED), 7264 SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED), 7265 SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7266 SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7267 SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7268 SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7269 SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC), 7270 SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7271 SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7272 SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 7273 SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 7274 SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 7275 SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 7276 SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 7277 SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7278 SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7279 SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7280 SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7281 SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7282 SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7283 SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED), 7284 SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY), 7285 SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7286 SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7287 SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7288 SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7289 SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7290 SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7291 SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7292 SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7293 SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED), 7294 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7295 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS), 7296 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7297 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS), 7298 SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7299 SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7300 SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7301 SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7302 SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7303 SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7304 SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7305 SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7306 SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7307 SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7308 SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7309 SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7310 SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7311 SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7312 SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M), 7313 SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7314 SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 7315 SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7316 SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7317 SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7318 SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 7319 SND_PCI_QUIRK(0x103c, 0x2b5e, "HP 288 Pro G2 MT", ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE), 7320 SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE), 7321 SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE), 7322 SND_PCI_QUIRK(0x103c, 0x8077, "HP", ALC256_FIXUP_HP_HEADSET_MIC), 7323 SND_PCI_QUIRK(0x103c, 0x8158, "HP", ALC256_FIXUP_HP_HEADSET_MIC), 7324 SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC295_FIXUP_HP_X360), 7325 SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC), 7326 SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360), 7327 SND_PCI_QUIRK(0x103c, 0x827f, "HP x360", ALC269_FIXUP_HP_MUTE_LED_MIC3), 7328 SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE), 7329 SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE), 7330 SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3), 7331 SND_PCI_QUIRK(0x103c, 0x841c, "HP Pavilion 15-CK0xx", ALC269_FIXUP_HP_MUTE_LED_MIC3), 7332 HDA_CODEC_QUIRK(0x103c, 0x8486, "HP Pavilion x360", ALC295_FIXUP_HP_PAVILION_X360), 7333 SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3), 7334 SND_PCI_QUIRK(0x103c, 0x84a6, "HP 250 G7 Notebook PC", ALC269_FIXUP_HP_LINE1_MIC1_LED), 7335 SND_PCI_QUIRK(0x103c, 0x84ae, "HP 15-db0403ng", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 7336 SND_PCI_QUIRK(0x103c, 0x84da, "HP OMEN dc0019-ur", ALC295_FIXUP_HP_OMEN), 7337 SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3), 7338 SND_PCI_QUIRK(0x103c, 0x8519, "HP Spectre x360 15-df0xxx", ALC285_FIXUP_HP_SPECTRE_X360), 7339 SND_PCI_QUIRK(0x103c, 0x8536, "HP ProBook 430 G6", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7340 SND_PCI_QUIRK(0x103c, 0x8537, "HP ProBook 440 G6", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7341 SND_PCI_QUIRK(0x103c, 0x8548, "HP EliteBook x360 830 G6", ALC285_FIXUP_HP_GPIO_LED), 7342 SND_PCI_QUIRK(0x103c, 0x854a, "HP EliteBook 830 G6", ALC285_FIXUP_HP_GPIO_LED), 7343 SND_PCI_QUIRK(0x103c, 0x854d, "HP EliteBook 840 G6", ALC285_FIXUP_HP_GPIO_LED), 7344 SND_PCI_QUIRK(0x103c, 0x856a, "HP Pavilion 15-cs1xxx", ALC295_FIXUP_HP_PAVILION_MUTE_LED_1B), 7345 SND_PCI_QUIRK(0x103c, 0x85c6, "HP Pavilion x360 Convertible 14-dy1xxx", ALC295_FIXUP_HP_MUTE_LED_COEFBIT11), 7346 SND_PCI_QUIRK(0x103c, 0x85de, "HP Envy x360 13-ar0xxx", ALC285_FIXUP_HP_ENVY_X360), 7347 SND_PCI_QUIRK(0x103c, 0x85f0, "HP Laptop 15-dw0xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 7348 SND_PCI_QUIRK(0x103c, 0x85f3, "HP 250 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 7349 SND_PCI_QUIRK(0x103c, 0x8603, "HP Omen 17-cb0xxx", ALC285_FIXUP_HP_MUTE_LED), 7350 SND_PCI_QUIRK(0x103c, 0x860c, "HP ZBook 17 G6", ALC285_FIXUP_HP_GPIO_AMP_INIT), 7351 SND_PCI_QUIRK(0x103c, 0x860f, "HP ZBook 15 G6", ALC285_FIXUP_HP_GPIO_AMP_INIT), 7352 SND_PCI_QUIRK(0x103c, 0x861f, "HP Elite Dragonfly G1", ALC285_FIXUP_HP_GPIO_AMP_INIT), 7353 SND_PCI_QUIRK(0x103c, 0x864f, "HP Laptop 15-dy0xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 7354 SND_PCI_QUIRK(0x103c, 0x869d, "HP", ALC236_FIXUP_HP_MUTE_LED), 7355 SND_PCI_QUIRK(0x103c, 0x86c1, "HP Laptop 15-da3001TU", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 7356 SND_PCI_QUIRK(0x103c, 0x86c7, "HP Envy AiO 32", ALC274_FIXUP_HP_ENVY_GPIO), 7357 SND_PCI_QUIRK(0x103c, 0x86c8, "HP Laptop 14s-dr1xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 7358 SND_PCI_QUIRK(0x103c, 0x86e7, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1), 7359 SND_PCI_QUIRK(0x103c, 0x863e, "HP Spectre x360 15-df1xxx", ALC285_FIXUP_HP_SPECTRE_X360_DF1), 7360 SND_PCI_QUIRK(0x103c, 0x86e8, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1), 7361 SND_PCI_QUIRK(0x103c, 0x86f9, "HP Spectre x360 13-aw0xxx", ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED), 7362 SND_PCI_QUIRK(0x103c, 0x8706, "HP Laptop 15s-eq1xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 7363 SND_PCI_QUIRK(0x103c, 0x8716, "HP Elite Dragonfly G2 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT), 7364 SND_PCI_QUIRK(0x103c, 0x8720, "HP EliteBook x360 1040 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT), 7365 SND_PCI_QUIRK(0x103c, 0x8724, "HP EliteBook 850 G7", ALC285_FIXUP_HP_GPIO_LED), 7366 SND_PCI_QUIRK(0x103c, 0x8728, "HP EliteBook 840 G7", ALC285_FIXUP_HP_GPIO_LED), 7367 SND_PCI_QUIRK(0x103c, 0x8729, "HP", ALC285_FIXUP_HP_GPIO_LED), 7368 SND_PCI_QUIRK(0x103c, 0x8730, "HP ProBook 445 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7369 SND_PCI_QUIRK(0x103c, 0x8735, "HP ProBook 435 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7370 SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_AMP_INIT), 7371 SND_PCI_QUIRK(0x103c, 0x8756, "HP ENVY Laptop 13-ba0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS), 7372 SND_PCI_QUIRK(0x103c, 0x8760, "HP EliteBook 8{4,5}5 G7", ALC285_FIXUP_HP_BEEP_MICMUTE_LED), 7373 SND_PCI_QUIRK(0x103c, 0x876e, "HP ENVY x360 Convertible 13-ay0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS), 7374 SND_PCI_QUIRK(0x103c, 0x877a, "HP", ALC285_FIXUP_HP_MUTE_LED), 7375 SND_PCI_QUIRK(0x103c, 0x877d, "HP", ALC236_FIXUP_HP_MUTE_LED), 7376 SND_PCI_QUIRK(0x103c, 0x8780, "HP ZBook Fury 17 G7 Mobile Workstation", 7377 ALC285_FIXUP_HP_GPIO_AMP_INIT), 7378 SND_PCI_QUIRK(0x103c, 0x8783, "HP ZBook Fury 15 G7 Mobile Workstation", 7379 ALC285_FIXUP_HP_GPIO_AMP_INIT), 7380 SND_PCI_QUIRK(0x103c, 0x8786, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED), 7381 SND_PCI_QUIRK(0x103c, 0x8787, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED), 7382 SND_PCI_QUIRK(0x103c, 0x8788, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED), 7383 SND_PCI_QUIRK(0x103c, 0x87b7, "HP Laptop 14-fq0xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 7384 SND_PCI_QUIRK(0x103c, 0x87c8, "HP", ALC287_FIXUP_HP_GPIO_LED), 7385 SND_PCI_QUIRK(0x103c, 0x87cb, "HP Pavilion 15-eg0xxx", ALC287_FIXUP_HP_GPIO_LED), 7386 SND_PCI_QUIRK(0x103c, 0x87cc, "HP Pavilion 15-eg0xxx", ALC287_FIXUP_HP_GPIO_LED), 7387 SND_PCI_QUIRK(0x103c, 0x87d3, "HP Laptop 15-gw0xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 7388 SND_PCI_QUIRK(0x103c, 0x87df, "HP ProBook 430 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 7389 SND_PCI_QUIRK(0x103c, 0x87e5, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 7390 SND_PCI_QUIRK(0x103c, 0x87e7, "HP ProBook 450 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 7391 SND_PCI_QUIRK(0x103c, 0x87f1, "HP ProBook 630 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 7392 SND_PCI_QUIRK(0x103c, 0x87f2, "HP ProBook 640 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 7393 SND_PCI_QUIRK(0x103c, 0x87f4, "HP", ALC287_FIXUP_HP_GPIO_LED), 7394 SND_PCI_QUIRK(0x103c, 0x87f5, "HP", ALC287_FIXUP_HP_GPIO_LED), 7395 SND_PCI_QUIRK(0x103c, 0x87f6, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP), 7396 SND_PCI_QUIRK(0x103c, 0x87f7, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP), 7397 SND_PCI_QUIRK(0x103c, 0x87fd, "HP Laptop 14-dq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 7398 SND_PCI_QUIRK(0x103c, 0x87fe, "HP Laptop 15s-fq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 7399 SND_PCI_QUIRK(0x103c, 0x8805, "HP ProBook 650 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 7400 SND_PCI_QUIRK(0x103c, 0x880d, "HP EliteBook 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED), 7401 SND_PCI_QUIRK(0x103c, 0x8811, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1), 7402 SND_PCI_QUIRK(0x103c, 0x8812, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1), 7403 SND_PCI_QUIRK(0x103c, 0x881d, "HP 250 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 7404 SND_PCI_QUIRK(0x103c, 0x881e, "HP Laptop 15s-du3xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 7405 SND_PCI_QUIRK(0x103c, 0x8846, "HP EliteBook 850 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED), 7406 SND_PCI_QUIRK(0x103c, 0x8847, "HP EliteBook x360 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED), 7407 SND_PCI_QUIRK(0x103c, 0x884b, "HP EliteBook 840 Aero G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED), 7408 SND_PCI_QUIRK(0x103c, 0x884c, "HP EliteBook 840 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED), 7409 HDA_CODEC_QUIRK(0x103c, 0x885b, "HP Spectre x360 14-ea", ALC245_FIXUP_HP_X360_AMP), 7410 SND_PCI_QUIRK(0x103c, 0x8862, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST), 7411 SND_PCI_QUIRK(0x103c, 0x8863, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST), 7412 SND_PCI_QUIRK(0x103c, 0x886d, "HP ZBook Fury 17.3 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT), 7413 SND_PCI_QUIRK(0x103c, 0x8870, "HP ZBook Fury 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT), 7414 SND_PCI_QUIRK(0x103c, 0x8873, "HP ZBook Studio 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT), 7415 SND_PCI_QUIRK(0x103c, 0x887a, "HP Laptop 15s-eq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 7416 SND_PCI_QUIRK(0x103c, 0x887c, "HP Laptop 14s-fq1xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 7417 SND_PCI_QUIRK(0x103c, 0x888a, "HP ENVY x360 Convertible 15-eu0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS), 7418 SND_PCI_QUIRK(0x103c, 0x888d, "HP ZBook Power 15.6 inch G8 Mobile Workstation PC", ALC236_FIXUP_HP_GPIO_LED), 7419 SND_PCI_QUIRK(0x103c, 0x8895, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED), 7420 SND_PCI_QUIRK(0x103c, 0x8896, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_MUTE_LED), 7421 SND_PCI_QUIRK(0x103c, 0x8898, "HP EliteBook 845 G8 Notebook PC", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST), 7422 SND_PCI_QUIRK(0x103c, 0x88b3, "HP ENVY x360 Convertible 15-es0xxx", ALC245_FIXUP_HP_ENVY_X360_MUTE_LED), 7423 SND_PCI_QUIRK(0x103c, 0x88d0, "HP Pavilion 15-eh1xxx (mainboard 88D0)", ALC287_FIXUP_HP_GPIO_LED), 7424 SND_PCI_QUIRK(0x103c, 0x88d1, "HP Pavilion 15-eh1xxx (mainboard 88D1)", ALC245_FIXUP_HP_MUTE_LED_V1_COEFBIT), 7425 SND_PCI_QUIRK(0x103c, 0x88dd, "HP Pavilion 15z-ec200", ALC285_FIXUP_HP_MUTE_LED), 7426 SND_PCI_QUIRK(0x103c, 0x88eb, "HP Victus 16-e0xxx", ALC245_FIXUP_HP_MUTE_LED_V2_COEFBIT), 7427 SND_PCI_QUIRK(0x103c, 0x88ed, "HP Victus 16-e0xxx (MB 88ED)", 7428 ALC245_FIXUP_HP_MUTE_LED_V2_COEFBIT), 7429 SND_PCI_QUIRK(0x103c, 0x88ee, "HP Victus 16-e0xxx (MB 88EE)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT), 7430 SND_PCI_QUIRK(0x103c, 0x8902, "HP OMEN 16", ALC285_FIXUP_HP_MUTE_LED), 7431 SND_PCI_QUIRK(0x103c, 0x890e, "HP 255 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 7432 SND_PCI_QUIRK(0x103c, 0x8919, "HP Pavilion Aero Laptop 13-be0xxx", ALC287_FIXUP_HP_GPIO_LED), 7433 SND_PCI_QUIRK(0x103c, 0x896d, "HP ZBook Firefly 16 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7434 SND_PCI_QUIRK(0x103c, 0x896e, "HP EliteBook x360 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7435 SND_PCI_QUIRK(0x103c, 0x8971, "HP EliteBook 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7436 SND_PCI_QUIRK(0x103c, 0x8972, "HP EliteBook 840 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7437 SND_PCI_QUIRK(0x103c, 0x8973, "HP EliteBook 860 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7438 SND_PCI_QUIRK(0x103c, 0x8974, "HP EliteBook 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7439 SND_PCI_QUIRK(0x103c, 0x8975, "HP EliteBook x360 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7440 SND_PCI_QUIRK(0x103c, 0x897d, "HP mt440 Mobile Thin Client U74", ALC236_FIXUP_HP_GPIO_LED), 7441 SND_PCI_QUIRK(0x103c, 0x8981, "HP Elite Dragonfly G3", ALC245_FIXUP_CS35L41_SPI_4), 7442 SND_PCI_QUIRK(0x103c, 0x898a, "HP Pavilion 15-eg100", ALC287_FIXUP_HP_GPIO_LED), 7443 SND_PCI_QUIRK(0x103c, 0x898e, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2), 7444 SND_PCI_QUIRK(0x103c, 0x898f, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2), 7445 SND_PCI_QUIRK(0x103c, 0x8991, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 7446 SND_PCI_QUIRK(0x103c, 0x8992, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2), 7447 SND_PCI_QUIRK(0x103c, 0x8994, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 7448 SND_PCI_QUIRK(0x103c, 0x8995, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2), 7449 SND_PCI_QUIRK(0x103c, 0x89a0, "HP Laptop 15-dw4xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 7450 SND_PCI_QUIRK(0x103c, 0x89a4, "HP ProBook 440 G9", ALC236_FIXUP_HP_GPIO_LED), 7451 SND_PCI_QUIRK(0x103c, 0x89a6, "HP ProBook 450 G9", ALC236_FIXUP_HP_GPIO_LED), 7452 SND_PCI_QUIRK(0x103c, 0x89aa, "HP EliteBook 630 G9", ALC236_FIXUP_HP_GPIO_LED), 7453 SND_PCI_QUIRK(0x103c, 0x89ac, "HP EliteBook 640 G9", ALC236_FIXUP_HP_GPIO_LED), 7454 SND_PCI_QUIRK(0x103c, 0x89ae, "HP EliteBook 650 G9", ALC236_FIXUP_HP_GPIO_LED), 7455 SND_PCI_QUIRK(0x103c, 0x89c0, "HP ZBook Power 15.6 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7456 SND_PCI_QUIRK(0x103c, 0x89c3, "Zbook Studio G9", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED), 7457 SND_PCI_QUIRK(0x103c, 0x89c6, "Zbook Fury 17 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7458 SND_PCI_QUIRK(0x103c, 0x89ca, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7459 SND_PCI_QUIRK(0x103c, 0x89d3, "HP EliteBook 645 G9 (MB 89D2)", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7460 SND_PCI_QUIRK(0x103c, 0x89da, "HP Spectre x360 14t-ea100", ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX), 7461 SND_PCI_QUIRK(0x103c, 0x89e7, "HP Elite x2 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7462 SND_PCI_QUIRK(0x103c, 0x8a05, "HP Dragonfly Folio G3 2-in-1", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED), 7463 SND_PCI_QUIRK(0x103c, 0x8a06, "HP Dragonfly Folio G3 2-in-1", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED), 7464 SND_PCI_QUIRK(0x103c, 0x8a0e, "HP Pavilion Laptop 15-eh2xxx", ALC287_FIXUP_HP_GPIO_LED), 7465 SND_PCI_QUIRK(0x103c, 0x8a0f, "HP Pavilion 14-ec1xxx", ALC287_FIXUP_HP_GPIO_LED), 7466 SND_PCI_QUIRK(0x103c, 0x8a1b, "HP 255 15.6 inch G9 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 7467 SND_PCI_QUIRK(0x103c, 0x8a1f, "HP Laptop 14s-dr5xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 7468 SND_PCI_QUIRK(0x103c, 0x8a20, "HP Laptop 15s-fq5xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 7469 SND_PCI_QUIRK(0x103c, 0x8a25, "HP Victus 16-d1xxx (MB 8A25)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT), 7470 SND_PCI_QUIRK(0x103c, 0x8a26, "HP Victus 16-d1xxx (MB 8A26)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT), 7471 SND_PCI_QUIRK(0x103c, 0x8a28, "HP Envy 13", ALC287_FIXUP_CS35L41_I2C_2), 7472 SND_PCI_QUIRK(0x103c, 0x8a29, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 7473 SND_PCI_QUIRK(0x103c, 0x8a2a, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 7474 SND_PCI_QUIRK(0x103c, 0x8a2b, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 7475 SND_PCI_QUIRK(0x103c, 0x8a2c, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2), 7476 SND_PCI_QUIRK(0x103c, 0x8a2d, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2), 7477 SND_PCI_QUIRK(0x103c, 0x8a2e, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2), 7478 SND_PCI_QUIRK(0x103c, 0x8a30, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 7479 SND_PCI_QUIRK(0x103c, 0x8a31, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 7480 SND_PCI_QUIRK(0x103c, 0x8a34, "HP Pavilion x360 2-in-1 Laptop 14-ek0xxx", ALC245_FIXUP_HP_MUTE_LED_COEFBIT), 7481 SND_PCI_QUIRK(0x103c, 0x8a36, "HP Pavilion Plus 14-eh0xxx", ALC245_FIXUP_HP_MUTE_LED_COEFBIT), 7482 SND_PCI_QUIRK(0x103c, 0x8a3d, "HP Victus 15-fb0xxx (MB 8A3D)", ALC245_FIXUP_HP_MUTE_LED_V2_COEFBIT), 7483 SND_PCI_QUIRK(0x103c, 0x8a4f, "HP Victus 15-fa0xxx (MB 8A4F)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT), 7484 SND_PCI_QUIRK(0x103c, 0x8a50, "HP Victus 15-fa0xxx (MB 8A50)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT), 7485 SND_PCI_QUIRK(0x103c, 0x8a6b, "HP Pavilion All-in-One Desktop 27-ca1xxx", ALC274_FIXUP_HP_VERBS), 7486 SND_PCI_QUIRK(0x103c, 0x8a6e, "HP EDNA 360", ALC287_FIXUP_CS35L41_I2C_4), 7487 SND_PCI_QUIRK(0x103c, 0x8a74, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 7488 SND_PCI_QUIRK(0x103c, 0x8a75, "HP ProBook 450 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 7489 SND_PCI_QUIRK(0x103c, 0x8a76, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 7490 SND_PCI_QUIRK(0x103c, 0x8a77, "HP ProBook 450 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 7491 SND_PCI_QUIRK(0x103c, 0x8a78, "HP Dev One", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST), 7492 SND_PCI_QUIRK(0x103c, 0x8aa0, "HP ProBook 440 G9 (MB 8A9E)", ALC236_FIXUP_HP_GPIO_LED), 7493 SND_PCI_QUIRK(0x103c, 0x8aa3, "HP ProBook 450 G9 (MB 8AA1)", ALC236_FIXUP_HP_GPIO_LED), 7494 SND_PCI_QUIRK(0x103c, 0x8aa8, "HP EliteBook 640 G9 (MB 8AA6)", ALC236_FIXUP_HP_GPIO_LED), 7495 SND_PCI_QUIRK(0x103c, 0x8aab, "HP EliteBook 650 G9 (MB 8AA9)", ALC236_FIXUP_HP_GPIO_LED), 7496 SND_PCI_QUIRK(0x103c, 0x8ab8, "HP EliteBook 830 G8 Notebook PC (MB 8AB8)", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7497 SND_PCI_QUIRK(0x103c, 0x8ab9, "HP EliteBook 840 G8 (MB 8AB8)", ALC285_FIXUP_HP_GPIO_LED), 7498 SND_PCI_QUIRK(0x103c, 0x8abb, "HP ZBook Firefly 14 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7499 SND_PCI_QUIRK(0x103c, 0x8ad1, "HP EliteBook 840 14 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7500 SND_PCI_QUIRK(0x103c, 0x8ad2, "HP EliteBook 860 16 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7501 SND_PCI_QUIRK(0x103c, 0x8ad8, "HP 800 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7502 SND_PCI_QUIRK(0x103c, 0x8b0f, "HP Elite mt645 G7 Mobile Thin Client U81", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7503 SND_PCI_QUIRK(0x103c, 0x8b2f, "HP 255 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 7504 SND_PCI_QUIRK(0x103c, 0x8b34, "HP 250 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 7505 SND_PCI_QUIRK(0x103c, 0x8b3a, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 7506 SND_PCI_QUIRK(0x103c, 0x8b3f, "HP mt440 Mobile Thin Client U91", ALC236_FIXUP_HP_GPIO_LED), 7507 SND_PCI_QUIRK(0x103c, 0x8b42, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7508 SND_PCI_QUIRK(0x103c, 0x8b43, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7509 SND_PCI_QUIRK(0x103c, 0x8b44, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7510 SND_PCI_QUIRK(0x103c, 0x8b45, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7511 SND_PCI_QUIRK(0x103c, 0x8b46, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7512 SND_PCI_QUIRK(0x103c, 0x8b47, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7513 SND_PCI_QUIRK(0x103c, 0x8b59, "HP Elite mt645 G7 Mobile Thin Client U89", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7514 SND_PCI_QUIRK(0x103c, 0x8b5d, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7515 SND_PCI_QUIRK(0x103c, 0x8b5e, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7516 SND_PCI_QUIRK(0x103c, 0x8b5f, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7517 SND_PCI_QUIRK(0x103c, 0x8b63, "HP Elite Dragonfly 13.5 inch G4", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED), 7518 SND_PCI_QUIRK(0x103c, 0x8b65, "HP ProBook 455 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7519 SND_PCI_QUIRK(0x103c, 0x8b66, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7520 SND_PCI_QUIRK(0x103c, 0x8b70, "HP EliteBook 835 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 7521 SND_PCI_QUIRK(0x103c, 0x8b72, "HP EliteBook 845 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 7522 SND_PCI_QUIRK(0x103c, 0x8b74, "HP EliteBook 845W G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 7523 SND_PCI_QUIRK(0x103c, 0x8b77, "HP ElieBook 865 G10", ALC287_FIXUP_CS35L41_I2C_2), 7524 SND_PCI_QUIRK(0x103c, 0x8b7a, "HP", ALC236_FIXUP_HP_GPIO_LED), 7525 SND_PCI_QUIRK(0x103c, 0x8b7d, "HP", ALC236_FIXUP_HP_GPIO_LED), 7526 SND_PCI_QUIRK(0x103c, 0x8b87, "HP", ALC236_FIXUP_HP_GPIO_LED), 7527 SND_PCI_QUIRK(0x103c, 0x8b8a, "HP", ALC236_FIXUP_HP_GPIO_LED), 7528 SND_PCI_QUIRK(0x103c, 0x8b8b, "HP", ALC236_FIXUP_HP_GPIO_LED), 7529 SND_PCI_QUIRK(0x103c, 0x8b8d, "HP", ALC236_FIXUP_HP_GPIO_LED), 7530 SND_PCI_QUIRK(0x103c, 0x8b8f, "HP", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED), 7531 SND_PCI_QUIRK(0x103c, 0x8b92, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7532 SND_PCI_QUIRK(0x103c, 0x8b96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7533 SND_PCI_QUIRK(0x103c, 0x8b97, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7534 SND_PCI_QUIRK(0x103c, 0x8bb3, "HP Slim OMEN", ALC287_FIXUP_CS35L41_I2C_2), 7535 SND_PCI_QUIRK(0x103c, 0x8bb4, "HP Slim OMEN", ALC287_FIXUP_CS35L41_I2C_2), 7536 SND_PCI_QUIRK(0x103c, 0x8bb6, "HP Laptop 15-fd0039nt", ALC236_FIXUP_HP_15_FD0XXX), 7537 SND_PCI_QUIRK(0x103c, 0x8bbe, "HP Victus 16-r0xxx (MB 8BBE)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT), 7538 SND_PCI_QUIRK(0x103c, 0x8bc8, "HP Victus 15-fa1xxx", ALC245_FIXUP_HP_MUTE_LED_COEFBIT), 7539 SND_PCI_QUIRK(0x103c, 0x8bcd, "HP Omen 16-xd0xxx", ALC245_FIXUP_HP_MUTE_LED_V1_COEFBIT), 7540 SND_PCI_QUIRK(0x103c, 0x8bd4, "HP Victus 16-s0xxx (MB 8BD4)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT), 7541 SND_PCI_QUIRK(0x103c, 0x8bd6, "HP Pavilion Aero Laptop 13z-be200", ALC287_FIXUP_HP_GPIO_LED), 7542 SND_PCI_QUIRK(0x103c, 0x8bdd, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 7543 SND_PCI_QUIRK(0x103c, 0x8bde, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 7544 SND_PCI_QUIRK(0x103c, 0x8bdf, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 7545 SND_PCI_QUIRK(0x103c, 0x8be0, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 7546 SND_PCI_QUIRK(0x103c, 0x8be1, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 7547 SND_PCI_QUIRK(0x103c, 0x8be2, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 7548 SND_PCI_QUIRK(0x103c, 0x8be3, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 7549 SND_PCI_QUIRK(0x103c, 0x8be5, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2), 7550 SND_PCI_QUIRK(0x103c, 0x8be6, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2), 7551 SND_PCI_QUIRK(0x103c, 0x8be7, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 7552 SND_PCI_QUIRK(0x103c, 0x8be8, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 7553 SND_PCI_QUIRK(0x103c, 0x8be9, "HP Envy x360 2-in-1 Laptop 15-fh0xxx", ALC245_FIXUP_HP_ENVY_X360_15_FH0XXX), 7554 SND_PCI_QUIRK(0x103c, 0x8bf0, "HP", ALC236_FIXUP_HP_GPIO_LED), 7555 SND_PCI_QUIRK(0x103c, 0x8c15, "HP Spectre x360 2-in-1 Laptop 14-eu0xxx", ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX), 7556 SND_PCI_QUIRK(0x103c, 0x8c16, "HP Spectre x360 2-in-1 Laptop 16-aa0xxx", ALC245_FIXUP_HP_SPECTRE_X360_16_AA0XXX), 7557 SND_PCI_QUIRK(0x103c, 0x8c17, "HP Spectre x360 2-in-1 Laptop 16-aa0xxx", ALC245_FIXUP_HP_SPECTRE_X360_16_AA0XXX), 7558 SND_PCI_QUIRK(0x103c, 0x8c21, "HP Pavilion Plus Laptop 14-ey0XXX", ALC245_FIXUP_HP_X360_MUTE_LEDS), 7559 SND_PCI_QUIRK(0x103c, 0x8c2d, "HP Victus 15-fa1xxx (MB 8C2D)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT), 7560 SND_PCI_QUIRK(0x103c, 0x8c30, "HP Victus 15-fb1xxx", ALC245_FIXUP_HP_MUTE_LED_COEFBIT), 7561 SND_PCI_QUIRK(0x103c, 0x8c3f, "HP Victus 15-fa1xxx (MB 8C3F)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT), 7562 SND_PCI_QUIRK(0x103c, 0x8c46, "HP EliteBook 830 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7563 SND_PCI_QUIRK(0x103c, 0x8c47, "HP EliteBook 840 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7564 SND_PCI_QUIRK(0x103c, 0x8c48, "HP EliteBook 860 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7565 SND_PCI_QUIRK(0x103c, 0x8c49, "HP Elite x360 830 2-in-1 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7566 SND_PCI_QUIRK(0x103c, 0x8c4d, "HP Omen", ALC287_FIXUP_CS35L41_I2C_2), 7567 SND_PCI_QUIRK(0x103c, 0x8c4e, "HP Omen", ALC287_FIXUP_CS35L41_I2C_2), 7568 SND_PCI_QUIRK(0x103c, 0x8c4f, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 7569 SND_PCI_QUIRK(0x103c, 0x8c50, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 7570 SND_PCI_QUIRK(0x103c, 0x8c51, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 7571 SND_PCI_QUIRK(0x103c, 0x8c52, "HP EliteBook 1040 G11", ALC285_FIXUP_HP_GPIO_LED), 7572 SND_PCI_QUIRK(0x103c, 0x8c53, "HP Elite x360 1040 2-in-1 G11", ALC285_FIXUP_HP_GPIO_LED), 7573 SND_PCI_QUIRK(0x103c, 0x8c66, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2), 7574 SND_PCI_QUIRK(0x103c, 0x8c67, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 7575 SND_PCI_QUIRK(0x103c, 0x8c68, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 7576 SND_PCI_QUIRK(0x103c, 0x8c6a, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2), 7577 SND_PCI_QUIRK(0x103c, 0x8c70, "HP EliteBook 835 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 7578 SND_PCI_QUIRK(0x103c, 0x8c71, "HP EliteBook 845 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 7579 SND_PCI_QUIRK(0x103c, 0x8c72, "HP EliteBook 865 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 7580 SND_PCI_QUIRK(0x103c, 0x8c7b, "HP ProBook 445 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7581 SND_PCI_QUIRK(0x103c, 0x8c7c, "HP ProBook 445 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7582 SND_PCI_QUIRK(0x103c, 0x8c7d, "HP ProBook 465 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7583 SND_PCI_QUIRK(0x103c, 0x8c7e, "HP ProBook 465 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7584 SND_PCI_QUIRK(0x103c, 0x8c7f, "HP EliteBook 645 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7585 SND_PCI_QUIRK(0x103c, 0x8c80, "HP EliteBook 645 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7586 SND_PCI_QUIRK(0x103c, 0x8c81, "HP EliteBook 665 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7587 SND_PCI_QUIRK(0x103c, 0x8c89, "HP ProBook 460 G11", ALC236_FIXUP_HP_GPIO_LED), 7588 SND_PCI_QUIRK(0x103c, 0x8c8a, "HP EliteBook 630", ALC236_FIXUP_HP_GPIO_LED), 7589 SND_PCI_QUIRK(0x103c, 0x8c8c, "HP EliteBook 660", ALC236_FIXUP_HP_GPIO_LED), 7590 SND_PCI_QUIRK(0x103c, 0x8c8d, "HP ProBook 440 G11", ALC236_FIXUP_HP_GPIO_LED), 7591 SND_PCI_QUIRK(0x103c, 0x8c8e, "HP ProBook 460 G11", ALC236_FIXUP_HP_GPIO_LED), 7592 SND_PCI_QUIRK(0x103c, 0x8c8f, "HP EliteBook 630 G11", ALC236_FIXUP_HP_GPIO_LED), 7593 SND_PCI_QUIRK(0x103c, 0x8c90, "HP EliteBook 640", ALC236_FIXUP_HP_GPIO_LED), 7594 SND_PCI_QUIRK(0x103c, 0x8c91, "HP EliteBook 660", ALC236_FIXUP_HP_GPIO_LED), 7595 SND_PCI_QUIRK(0x103c, 0x8c96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7596 SND_PCI_QUIRK(0x103c, 0x8c97, "HP ZBook", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7597 SND_PCI_QUIRK(0x103c, 0x8c99, "HP Victus 16-r1xxx (MB 8C99)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT), 7598 SND_PCI_QUIRK(0x103c, 0x8c9c, "HP Victus 16-s1xxx (MB 8C9C)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT), 7599 SND_PCI_QUIRK(0x103c, 0x8ca1, "HP ZBook Power", ALC236_FIXUP_HP_GPIO_LED), 7600 SND_PCI_QUIRK(0x103c, 0x8ca2, "HP ZBook Power", ALC236_FIXUP_HP_GPIO_LED), 7601 SND_PCI_QUIRK(0x103c, 0x8ca4, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7602 SND_PCI_QUIRK(0x103c, 0x8ca7, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 7603 SND_PCI_QUIRK(0x103c, 0x8caf, "HP Elite mt645 G8 Mobile Thin Client", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7604 SND_PCI_QUIRK(0x103c, 0x8cbc, "HP Pavilion Laptop 16-ag0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS), 7605 SND_PCI_QUIRK(0x103c, 0x8cbd, "HP Pavilion Aero Laptop 13-bg0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS), 7606 SND_PCI_QUIRK(0x103c, 0x8cdd, "HP Spectre", ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX), 7607 SND_PCI_QUIRK(0x103c, 0x8cde, "HP OmniBook Ultra Flip Laptop 14t", ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX), 7608 SND_PCI_QUIRK(0x103c, 0x8cdf, "HP SnowWhite", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 7609 SND_PCI_QUIRK(0x103c, 0x8ce0, "HP SnowWhite", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 7610 SND_PCI_QUIRK(0x103c, 0x8cf5, "HP ZBook Studio 16", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED), 7611 SND_PCI_QUIRK(0x103c, 0x8d01, "HP ZBook Power 14 G12", ALC285_FIXUP_HP_GPIO_LED), 7612 SND_PCI_QUIRK(0x103c, 0x8d07, "HP Victus 15-fb2xxx (MB 8D07)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT), 7613 SND_PCI_QUIRK(0x103c, 0x8d18, "HP EliteStudio 8 AIO", ALC274_FIXUP_HP_AIO_BIND_DACS), 7614 SND_PCI_QUIRK(0x103c, 0x8d84, "HP EliteBook X G1i", ALC285_FIXUP_HP_GPIO_LED), 7615 SND_PCI_QUIRK(0x103c, 0x8d85, "HP EliteBook 14 G12", ALC285_FIXUP_HP_GPIO_LED), 7616 SND_PCI_QUIRK(0x103c, 0x8d86, "HP Elite X360 14 G12", ALC285_FIXUP_HP_GPIO_LED), 7617 SND_PCI_QUIRK(0x103c, 0x8d8c, "HP EliteBook 13 G12", ALC285_FIXUP_HP_GPIO_LED), 7618 SND_PCI_QUIRK(0x103c, 0x8d8d, "HP Elite X360 13 G12", ALC285_FIXUP_HP_GPIO_LED), 7619 SND_PCI_QUIRK(0x103c, 0x8d8e, "HP EliteBook 14 G12", ALC285_FIXUP_HP_GPIO_LED), 7620 SND_PCI_QUIRK(0x103c, 0x8d8f, "HP EliteBook 14 G12", ALC285_FIXUP_HP_GPIO_LED), 7621 SND_PCI_QUIRK(0x103c, 0x8d90, "HP EliteBook 16 G12", ALC285_FIXUP_HP_GPIO_LED), 7622 SND_PCI_QUIRK(0x103c, 0x8d91, "HP ZBook Firefly 14 G12", ALC285_FIXUP_HP_GPIO_LED), 7623 SND_PCI_QUIRK(0x103c, 0x8d92, "HP ZBook Firefly 16 G12", ALC285_FIXUP_HP_GPIO_LED), 7624 SND_PCI_QUIRK(0x103c, 0x8dcd, "HP Victus 15-fa2xxx", ALC245_FIXUP_HP_MUTE_LED_COEFBIT), 7625 SND_PCI_QUIRK(0x103c, 0x8d9b, "HP 17 Turbine OmniBook 7 UMA", ALC287_FIXUP_CS35L41_I2C_2), 7626 SND_PCI_QUIRK(0x103c, 0x8d9c, "HP 17 Turbine OmniBook 7 DIS", ALC287_FIXUP_CS35L41_I2C_2), 7627 SND_PCI_QUIRK(0x103c, 0x8d9d, "HP 17 Turbine OmniBook X UMA", ALC287_FIXUP_CS35L41_I2C_2), 7628 SND_PCI_QUIRK(0x103c, 0x8d9e, "HP 17 Turbine OmniBook X DIS", ALC287_FIXUP_CS35L41_I2C_2), 7629 SND_PCI_QUIRK(0x103c, 0x8d9f, "HP 14 Cadet (x360)", ALC287_FIXUP_CS35L41_I2C_2), 7630 SND_PCI_QUIRK(0x103c, 0x8da0, "HP 16 Clipper OmniBook 7(X360)", ALC287_FIXUP_CS35L41_I2C_2), 7631 SND_PCI_QUIRK(0x103c, 0x8da1, "HP 16 Clipper OmniBook X", ALC287_FIXUP_CS35L41_I2C_2), 7632 SND_PCI_QUIRK(0x103c, 0x8da7, "HP 14 Enstrom OmniBook X", ALC287_FIXUP_CS35L41_I2C_2), 7633 SND_PCI_QUIRK(0x103c, 0x8da8, "HP 16 Piston OmniBook X", ALC245_FIXUP_HP_ENVY_X360_15_FH0XXX), 7634 SND_PCI_QUIRK(0x103c, 0x8dc9, "HP Laptop 15-fc0xxx", ALC236_FIXUP_HP_DMIC), 7635 SND_PCI_QUIRK(0x103c, 0x8dd4, "HP EliteStudio 8 AIO", ALC274_FIXUP_HP_AIO_BIND_DACS), 7636 SND_PCI_QUIRK(0x103c, 0x8dd7, "HP Laptop 15-fd0xxx", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_GPIO), 7637 SND_PCI_QUIRK(0x103c, 0x8de8, "HP Gemtree", ALC245_FIXUP_TAS2781_SPI_2), 7638 SND_PCI_QUIRK(0x103c, 0x8de9, "HP Gemtree", ALC245_FIXUP_TAS2781_SPI_2), 7639 SND_PCI_QUIRK(0x103c, 0x8dec, "HP EliteBook 640 G12", ALC236_FIXUP_HP_GPIO_LED), 7640 SND_PCI_QUIRK(0x103c, 0x8ded, "HP EliteBook 640 G12", ALC236_FIXUP_HP_GPIO_LED), 7641 SND_PCI_QUIRK(0x103c, 0x8dee, "HP EliteBook 660 G12", ALC236_FIXUP_HP_GPIO_LED), 7642 SND_PCI_QUIRK(0x103c, 0x8def, "HP EliteBook 660 G12", ALC236_FIXUP_HP_GPIO_LED), 7643 SND_PCI_QUIRK(0x103c, 0x8df0, "HP EliteBook 630 G12", ALC236_FIXUP_HP_GPIO_LED), 7644 SND_PCI_QUIRK(0x103c, 0x8df1, "HP EliteBook 630 G12", ALC236_FIXUP_HP_GPIO_LED), 7645 SND_PCI_QUIRK(0x103c, 0x8df7, "HP Z66 G6", ALC236_FIXUP_HP_GPIO_LED), 7646 SND_PCI_QUIRK(0x103c, 0x8dfb, "HP EliteBook 6 G1a 14", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7647 SND_PCI_QUIRK(0x103c, 0x8dfc, "HP EliteBook 645 G12", ALC236_FIXUP_HP_GPIO_LED), 7648 SND_PCI_QUIRK(0x103c, 0x8dfd, "HP EliteBook 6 G1a 16", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7649 SND_PCI_QUIRK(0x103c, 0x8dfe, "HP EliteBook 665 G12", ALC236_FIXUP_HP_GPIO_LED), 7650 SND_PCI_QUIRK(0x103c, 0x8e0d, "HP EliteBook 6 G1a 14 (AD3Q9ET#UUG)", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7651 SND_PCI_QUIRK(0x103c, 0x8e11, "HP Trekker", ALC287_FIXUP_CS35L41_I2C_2), 7652 SND_PCI_QUIRK(0x103c, 0x8e12, "HP Trekker", ALC287_FIXUP_CS35L41_I2C_2), 7653 SND_PCI_QUIRK(0x103c, 0x8e13, "HP Trekker", ALC287_FIXUP_CS35L41_I2C_2), 7654 SND_PCI_QUIRK(0x103c, 0x8e14, "HP ZBook Firefly 14 G12", ALC245_FIXUP_HP_ZBOOK_FIREFLY_G12A), 7655 SND_PCI_QUIRK(0x103c, 0x8e15, "HP ZBook Firefly 14 G12", ALC245_FIXUP_HP_ZBOOK_FIREFLY_G12A), 7656 SND_PCI_QUIRK(0x103c, 0x8e16, "HP ZBook Firefly 14 G12", ALC245_FIXUP_HP_ZBOOK_FIREFLY_G12A), 7657 SND_PCI_QUIRK(0x103c, 0x8e17, "HP ZBook Firefly 14 G12", ALC245_FIXUP_HP_ZBOOK_FIREFLY_G12A), 7658 SND_PCI_QUIRK(0x103c, 0x8e18, "HP ZBook Firefly 14 G12A", ALC245_FIXUP_HP_ZBOOK_FIREFLY_G12A), 7659 SND_PCI_QUIRK(0x103c, 0x8e19, "HP ZBook Firefly 14 G12A", ALC245_FIXUP_HP_ZBOOK_FIREFLY_G12A), 7660 SND_PCI_QUIRK(0x103c, 0x8e1a, "HP ZBook Firefly 14 G12A", ALC245_FIXUP_HP_ZBOOK_FIREFLY_G12A), 7661 SND_PCI_QUIRK(0x103c, 0x8e1b, "HP EliteBook G12", ALC245_FIXUP_HP_ZBOOK_FIREFLY_G12A), 7662 SND_PCI_QUIRK(0x103c, 0x8e1c, "HP EliteBook G12", ALC245_FIXUP_HP_ZBOOK_FIREFLY_G12A), 7663 SND_PCI_QUIRK(0x103c, 0x8e1d, "HP ZBook X Gli 16 G12", ALC236_FIXUP_HP_GPIO_LED), 7664 SND_PCI_QUIRK(0x103c, 0x8e2c, "HP EliteBook 16 G12", ALC285_FIXUP_HP_GPIO_LED), 7665 SND_PCI_QUIRK(0x103c, 0x8e36, "HP 14 Enstrom OmniBook X", ALC287_FIXUP_CS35L41_I2C_2), 7666 SND_PCI_QUIRK(0x103c, 0x8e37, "HP 16 Piston OmniBook X", ALC287_FIXUP_CS35L41_I2C_2), 7667 SND_PCI_QUIRK(0x103c, 0x8e3a, "HP Agusta", ALC287_FIXUP_CS35L41_I2C_2), 7668 SND_PCI_QUIRK(0x103c, 0x8e3b, "HP Agusta", ALC287_FIXUP_CS35L41_I2C_2), 7669 SND_PCI_QUIRK(0x103c, 0x8e60, "HP OmniBook 7 Laptop 16-bh0xxx", ALC245_FIXUP_CS35L41_I2C_2_MUTE_LED), 7670 SND_PCI_QUIRK(0x103c, 0x8e61, "HP Trekker ", ALC287_FIXUP_CS35L41_I2C_2), 7671 SND_PCI_QUIRK(0x103c, 0x8e62, "HP Trekker ", ALC287_FIXUP_CS35L41_I2C_2), 7672 SND_PCI_QUIRK(0x103c, 0x8e75, "HP Trekker G7JC", ALC287_FIXUP_CS35L41_I2C_2), 7673 SND_PCI_QUIRK(0x103c, 0x8e8a, "HP NexusX", ALC245_FIXUP_HP_TAS2781_I2C_MUTE_LED), 7674 SND_PCI_QUIRK(0x103c, 0x8e9c, "HP 16 Clipper OmniBook X X360", ALC287_FIXUP_CS35L41_I2C_2), 7675 SND_PCI_QUIRK(0x103c, 0x8e9d, "HP 17 Turbine OmniBook X UMA", ALC287_FIXUP_CS35L41_I2C_2), 7676 SND_PCI_QUIRK(0x103c, 0x8e9e, "HP 17 Turbine OmniBook X UMA", ALC287_FIXUP_CS35L41_I2C_2), 7677 SND_PCI_QUIRK(0x103c, 0x8eb6, "HP Abe A6U", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_GPIO), 7678 SND_PCI_QUIRK(0x103c, 0x8eb8, "HP Abe A6U", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_GPIO), 7679 SND_PCI_QUIRK(0x103c, 0x8ec1, "HP 200 G2i", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_GPIO), 7680 SND_PCI_QUIRK(0x103c, 0x8ec4, "HP Bantie I6U", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_GPIO), 7681 SND_PCI_QUIRK(0x103c, 0x8ec5, "HP Bantie I6U", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_GPIO), 7682 SND_PCI_QUIRK(0x103c, 0x8ece, "HP Abe I6U", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_GPIO), 7683 SND_PCI_QUIRK(0x103c, 0x8ecf, "HP Abe I6U", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_GPIO), 7684 SND_PCI_QUIRK(0x103c, 0x8ed2, "HP Abe I6U", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_GPIO), 7685 SND_PCI_QUIRK(0x103c, 0x8ed5, "HP EliteBook 8 Flip G2i 13", ALC245_FIXUP_HP_TAS2781_SPI_MUTE_LED), 7686 SND_PCI_QUIRK(0x103c, 0x8ed6, "HP EliteBook 8 G2i 13", ALC245_FIXUP_HP_TAS2781_SPI_MUTE_LED), 7687 SND_PCI_QUIRK(0x103c, 0x8ed7, "HP EliteBook 8 G2i 14", ALC245_FIXUP_HP_TAS2781_SPI_MUTE_LED), 7688 SND_PCI_QUIRK(0x103c, 0x8ed8, "HP EliteBook 8 G2i 16", ALC245_FIXUP_HP_TAS2781_SPI_MUTE_LED), 7689 SND_PCI_QUIRK(0x103c, 0x8ed9, "HP ZBook Firefly 14W", ALC245_FIXUP_HP_TAS2781_SPI_MUTE_LED), 7690 SND_PCI_QUIRK(0x103c, 0x8eda, "HP ZBook Firefly 16W", ALC245_FIXUP_HP_TAS2781_SPI_MUTE_LED), 7691 SND_PCI_QUIRK(0x103c, 0x8ee4, "HP Bantie A6U", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_GPIO), 7692 SND_PCI_QUIRK(0x103c, 0x8ee5, "HP Bantie A6U", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_GPIO), 7693 SND_PCI_QUIRK(0x103c, 0x8ee7, "HP Abe A6U", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_GPIO), 7694 SND_PCI_QUIRK(0x103c, 0x8f07, "HP Agusta G7KX", ALC287_FIXUP_CS35L41_I2C_2), 7695 SND_PCI_QUIRK(0x103c, 0x8f0c, "HP ZBook X G2i 16W", ALC236_FIXUP_HP_GPIO_LED), 7696 SND_PCI_QUIRK(0x103c, 0x8f0e, "HP ZBook X G2i 16W", ALC236_FIXUP_HP_GPIO_LED), 7697 SND_PCI_QUIRK(0x103c, 0x8f2d, "HP Auster 14", ALC287_FIXUP_CS35L41_I2C_2), 7698 SND_PCI_QUIRK(0x103c, 0x8f2e, "HP Auster 14", ALC287_FIXUP_CS35L41_I2C_2), 7699 SND_PCI_QUIRK(0x103c, 0x8f37, "HP EliteBook 6 G2i", ALC236_FIXUP_HP_GPIO_LED), 7700 SND_PCI_QUIRK(0x103c, 0x8f38, "HP EliteBook 6 G2i", ALC236_FIXUP_HP_GPIO_LED), 7701 SND_PCI_QUIRK(0x103c, 0x8f39, "HP EliteBook 6 G2i", ALC236_FIXUP_HP_GPIO_LED), 7702 SND_PCI_QUIRK(0x103c, 0x8f3a, "HP EliteBook 6 G2i", ALC236_FIXUP_HP_GPIO_LED), 7703 SND_PCI_QUIRK(0x103c, 0x8f3c, "HP EliteBook 6 G2a", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7704 SND_PCI_QUIRK(0x103c, 0x8f3d, "HP EliteBook 6 G2a", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 7705 SND_PCI_QUIRK(0x103c, 0x8f40, "HP ZBook 8 G2a 14", ALC245_FIXUP_HP_TAS2781_I2C_MUTE_LED), 7706 SND_PCI_QUIRK(0x103c, 0x8f41, "HP ZBook 8 G2a 16", ALC245_FIXUP_HP_TAS2781_I2C_MUTE_LED), 7707 SND_PCI_QUIRK(0x103c, 0x8f42, "HP ZBook 8 G2a 14W", ALC245_FIXUP_HP_TAS2781_I2C_MUTE_LED), 7708 SND_PCI_QUIRK(0x103c, 0x8f57, "HP Trekker G7JC", ALC287_FIXUP_CS35L41_I2C_2), 7709 SND_PCI_QUIRK(0x103c, 0x8f62, "HP ZBook 8 G2a 16W", ALC245_FIXUP_HP_TAS2781_I2C_MUTE_LED), 7710 SND_PCI_QUIRK(0x103c, 0x8f7e, "HP Messi", ALC245_FIXUP_HP_TAS2781_I2C_MUTE_LED), 7711 SND_PCI_QUIRK(0x103c, 0x8f94, "HP ZBook 8 G2a 14", ALC245_FIXUP_HP_TAS2781_I2C_MUTE_LED_INVERTED), 7712 SND_PCI_QUIRK(0x103c, 0x8f95, "HP ZBook 8 G2a 16", ALC245_FIXUP_HP_TAS2781_I2C_MUTE_LED_INVERTED), 7713 SND_PCI_QUIRK(0x1043, 0x1024, "ASUS Zephyrus G14 2025", ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC), 7714 SND_PCI_QUIRK(0x1043, 0x1032, "ASUS VivoBook X513EA", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE), 7715 SND_PCI_QUIRK(0x1043, 0x1034, "ASUS GU605C", ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1), 7716 SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC), 7717 SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300), 7718 SND_PCI_QUIRK(0x1043, 0x1044, "ASUS GA403UM", ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC), 7719 SND_PCI_QUIRK(0x1043, 0x1054, "ASUS G614FH/FM/FP", ALC287_FIXUP_CS35L41_I2C_2), 7720 SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 7721 SND_PCI_QUIRK(0x1043, 0x106f, "ASUS VivoBook X515UA", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE), 7722 SND_PCI_QUIRK(0x1043, 0x1074, "ASUS G614PH/PM/PP", ALC287_FIXUP_CS35L41_I2C_2), 7723 SND_PCI_QUIRK(0x1043, 0x10a1, "ASUS UX391UA", ALC294_FIXUP_ASUS_SPK), 7724 SND_PCI_QUIRK(0x1043, 0x10a4, "ASUS TP3407SA", ALC287_FIXUP_TAS2781_I2C), 7725 SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC), 7726 SND_PCI_QUIRK(0x1043, 0x10c4, "ASUS Vivobook S14 S5406SA", ALC2XX_FIXUP_HEADSET_MIC), 7727 SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE), 7728 SND_PCI_QUIRK(0x1043, 0x10d3, "ASUS K6500ZC", ALC294_FIXUP_ASUS_SPK), 7729 SND_PCI_QUIRK(0x1043, 0x1154, "ASUS TP3607SH", ALC287_FIXUP_TAS2781_I2C), 7730 SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 7731 SND_PCI_QUIRK(0x1043, 0x1194, "ASUS UM3406KA", ALC287_FIXUP_CS35L41_I2C_2), 7732 SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE), 7733 SND_PCI_QUIRK(0x1043, 0x1204, "ASUS Strix G615JHR_JMR_JPR", ALC287_FIXUP_TXNW2781_I2C_ASUS), 7734 SND_PCI_QUIRK(0x1043, 0x1214, "ASUS Strix G615LH_LM_LP", ALC287_FIXUP_TXNW2781_I2C_ASUS), 7735 SND_PCI_QUIRK(0x1043, 0x125e, "ASUS Q524UQK", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE), 7736 SND_PCI_QUIRK(0x1043, 0x1271, "ASUS X430UN", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE), 7737 SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE), 7738 SND_PCI_QUIRK(0x1043, 0x1294, "ASUS B3405CVA", ALC245_FIXUP_CS35L41_SPI_2), 7739 SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE), 7740 SND_PCI_QUIRK(0x1043, 0x12a3, "Asus N7691ZM", ALC269_FIXUP_ASUS_N7601ZM), 7741 SND_PCI_QUIRK(0x1043, 0x12af, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2), 7742 SND_PCI_QUIRK(0x1043, 0x12b4, "ASUS B3405CCA / P3405CCA", ALC294_FIXUP_ASUS_CS35L41_SPI_2), 7743 SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE), 7744 SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE), 7745 SND_PCI_QUIRK(0x1043, 0x1313, "Asus K42JZ", ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE), 7746 SND_PCI_QUIRK(0x1043, 0x1314, "ASUS GA605K", ALC285_FIXUP_ASUS_GA605K_HEADSET_MIC), 7747 SND_PCI_QUIRK(0x1043, 0x1384, "ASUS RC73XA", ALC287_FIXUP_TXNW2781_I2C_ASUS), 7748 SND_PCI_QUIRK(0x1043, 0x1394, "ASUS RC73YA", ALC287_FIXUP_TXNW2781_I2C_ASUS), 7749 SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE), 7750 SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK), 7751 SND_PCI_QUIRK(0x1043, 0x1433, "ASUS GX650PY/PZ/PV/PU/PYV/PZV/PIV/PVV", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC), 7752 SND_PCI_QUIRK(0x1043, 0x1454, "ASUS PM3406CKA", ALC287_FIXUP_CS35L41_I2C_2), 7753 SND_PCI_QUIRK(0x1043, 0x1460, "Asus VivoBook 15", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE), 7754 SND_PCI_QUIRK(0x1043, 0x1463, "Asus GA402X/GA402N", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC), 7755 SND_PCI_QUIRK(0x1043, 0x1473, "ASUS GU604VI/VC/VE/VG/VJ/VQ/VU/VV/VY/VZ", ALC285_FIXUP_ASUS_HEADSET_MIC), 7756 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS GU603VQ/VU/VV/VJ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC), 7757 SND_PCI_QUIRK(0x1043, 0x1493, "ASUS GV601VV/VU/VJ/VQ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC), 7758 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G614JY/JZ/JG", ALC245_FIXUP_CS35L41_SPI_2), 7759 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS G513PI/PU/PV", ALC287_FIXUP_CS35L41_I2C_2), 7760 SND_PCI_QUIRK(0x1043, 0x14f2, "ASUS VivoBook X515JA", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE), 7761 SND_PCI_QUIRK(0x1043, 0x1503, "ASUS G733PY/PZ/PZV/PYV", ALC287_FIXUP_CS35L41_I2C_2), 7762 SND_PCI_QUIRK(0x1043, 0x1514, "ASUS ROG Flow Z13 GZ302EAC", ALC287_FIXUP_CS35L41_I2C_2), 7763 SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A), 7764 SND_PCI_QUIRK(0x1043, 0x1533, "ASUS GV302XA/XJ/XQ/XU/XV/XI", ALC287_FIXUP_CS35L41_I2C_2), 7765 SND_PCI_QUIRK(0x1043, 0x1573, "ASUS GZ301VV/VQ/VU/VJ/VA/VC/VE/VVC/VQC/VUC/VJC/VEC/VCC", ALC285_FIXUP_ASUS_HEADSET_MIC), 7766 SND_PCI_QUIRK(0x1043, 0x1584, "ASUS UM3406GA ", ALC287_FIXUP_CS35L41_I2C_2), 7767 SND_PCI_QUIRK(0x1043, 0x1602, "ASUS ROG Strix SCAR 15", ALC285_FIXUP_ASUS_G533Z_PINS), 7768 SND_PCI_QUIRK(0x1043, 0x1652, "ASUS ROG Zephyrus Do 15 SE", ALC289_FIXUP_ASUS_ZEPHYRUS_DUAL_SPK), 7769 SND_PCI_QUIRK(0x1043, 0x1662, "ASUS GV301QH", ALC294_FIXUP_ASUS_DUAL_SPK), 7770 SND_PCI_QUIRK(0x1043, 0x1663, "ASUS GU603ZI/ZJ/ZQ/ZU/ZV", ALC285_FIXUP_ASUS_HEADSET_MIC), 7771 SND_PCI_QUIRK(0x1043, 0x1683, "ASUS UM3402YAR", ALC287_FIXUP_CS35L41_I2C_2), 7772 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS UX3402VA", ALC245_FIXUP_CS35L41_SPI_2), 7773 SND_PCI_QUIRK(0x1043, 0x16b2, "ASUS GU603", ALC289_FIXUP_ASUS_GA401), 7774 SND_PCI_QUIRK(0x1043, 0x16d3, "ASUS UX5304VA", ALC245_FIXUP_CS35L41_SPI_2), 7775 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC), 7776 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS UX7602VI/BZ", ALC245_FIXUP_CS35L41_SPI_2), 7777 SND_PCI_QUIRK(0x1043, 0x1740, "ASUS UX430UA", ALC295_FIXUP_ASUS_DACS), 7778 SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_DUAL_SPK), 7779 SND_PCI_QUIRK(0x1043, 0x17f3, "ROG Ally NR2301L/X", ALC294_FIXUP_ASUS_ALLY), 7780 SND_PCI_QUIRK(0x1043, 0x1863, "ASUS UX6404VI/VV", ALC245_FIXUP_CS35L41_SPI_2), 7781 SND_PCI_QUIRK(0x1043, 0x1881, "ASUS Zephyrus S/M", ALC294_FIXUP_ASUS_GX502_PINS), 7782 SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC), 7783 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS UM3504DA", ALC287_FIXUP_CS35L41_I2C_2), 7784 SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC), 7785 SND_PCI_QUIRK(0x1043, 0x194e, "ASUS UX563FD", ALC294_FIXUP_ASUS_HPE), 7786 SND_PCI_QUIRK(0x1043, 0x1970, "ASUS UX550VE", ALC289_FIXUP_ASUS_GA401), 7787 SND_PCI_QUIRK(0x1043, 0x197e, "ASUS VivoBook X509DAP", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE), 7788 SND_PCI_QUIRK(0x1043, 0x1982, "ASUS B1400CEPE", ALC256_FIXUP_ASUS_HPE), 7789 SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE), 7790 SND_PCI_QUIRK(0x1043, 0x19e1, "ASUS UX581LV", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE), 7791 SND_PCI_QUIRK(0x1043, 0x19f4, "ASUS UM3405GA", ALC294_FIXUP_ASUS_I2C_HEADSET_MIC), 7792 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW), 7793 SND_PCI_QUIRK(0x1043, 0x1a63, "ASUS UX3405MA", ALC294_FIXUP_ASUS_SPI_HEADSET_MIC), 7794 SND_PCI_QUIRK(0x1043, 0x1a83, "ASUS UM5302LA", ALC287_FIXUP_CS35L41_I2C_2), 7795 SND_PCI_QUIRK(0x1043, 0x1a8e, "ASUS G712LWS", ALC294_FIXUP_LENOVO_MIC_LOCATION), 7796 SND_PCI_QUIRK(0x1043, 0x1a8f, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2), 7797 SND_PCI_QUIRK(0x1043, 0x1b11, "ASUS UX431DA", ALC294_FIXUP_ASUS_COEF_1B), 7798 SND_PCI_QUIRK(0x1043, 0x1b13, "ASUS U41SV/GA403U", ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC), 7799 SND_PCI_QUIRK(0x1043, 0x1b93, "ASUS G614JVR/JIR", ALC245_FIXUP_CS35L41_SPI_2), 7800 SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE), 7801 SND_PCI_QUIRK(0x1043, 0x1c03, "ASUS UM3406HA", ALC294_FIXUP_ASUS_I2C_HEADSET_MIC), 7802 SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 7803 SND_PCI_QUIRK(0x1043, 0x1c33, "ASUS UX5304MA", ALC245_FIXUP_CS35L41_SPI_2), 7804 SND_PCI_QUIRK(0x1043, 0x1c43, "ASUS UX8406MA", ALC245_FIXUP_CS35L41_SPI_2), 7805 SND_PCI_QUIRK(0x1043, 0x1c62, "ASUS GU603", ALC289_FIXUP_ASUS_GA401), 7806 SND_PCI_QUIRK(0x1043, 0x1c63, "ASUS GU605M", ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1), 7807 SND_PCI_QUIRK(0x1043, 0x1c80, "ASUS VivoBook TP401", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE), 7808 SND_PCI_QUIRK(0x1043, 0x1c92, "ASUS ROG Strix G15", ALC285_FIXUP_ASUS_G533Z_PINS), 7809 SND_PCI_QUIRK(0x1043, 0x1c9f, "ASUS G614JU/JV/JI", ALC285_FIXUP_ASUS_HEADSET_MIC), 7810 SND_PCI_QUIRK(0x1043, 0x1caf, "ASUS G634JY/JZ/JI/JG", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS), 7811 SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE), 7812 SND_PCI_QUIRK(0x1043, 0x1ccf, "ASUS G814JU/JV/JI", ALC245_FIXUP_CS35L41_SPI_2), 7813 SND_PCI_QUIRK(0x1043, 0x1cdf, "ASUS G814JY/JZ/JG", ALC245_FIXUP_CS35L41_SPI_2), 7814 SND_PCI_QUIRK(0x1043, 0x1cef, "ASUS G834JY/JZ/JI/JG", ALC285_FIXUP_ASUS_HEADSET_MIC), 7815 SND_PCI_QUIRK(0x1043, 0x1d1f, "ASUS G713PI/PU/PV/PVN", ALC287_FIXUP_CS35L41_I2C_2), 7816 SND_PCI_QUIRK(0x1043, 0x1d42, "ASUS Zephyrus G14 2022", ALC289_FIXUP_ASUS_GA401), 7817 SND_PCI_QUIRK(0x1043, 0x1d4e, "ASUS TM420", ALC256_FIXUP_ASUS_HPE), 7818 SND_PCI_QUIRK(0x1043, 0x1da2, "ASUS UP6502ZA/ZD", ALC245_FIXUP_CS35L41_SPI_2), 7819 SND_PCI_QUIRK(0x1043, 0x1df3, "ASUS UM5606WA", ALC294_FIXUP_BASS_SPEAKER_15), 7820 SND_PCI_QUIRK(0x1043, 0x1264, "ASUS UM5606KA", ALC294_FIXUP_BASS_SPEAKER_15), 7821 SND_PCI_QUIRK(0x1043, 0x1e02, "ASUS UX3402ZA", ALC245_FIXUP_CS35L41_SPI_2), 7822 SND_PCI_QUIRK(0x1043, 0x1e10, "ASUS VivoBook X507UAR", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE), 7823 SND_PCI_QUIRK(0x1043, 0x1e3e, "ASUS VivoBook M515DA/X515DAP", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE), 7824 SND_PCI_QUIRK(0x1043, 0x1e11, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA502), 7825 SND_PCI_QUIRK(0x1043, 0x1e12, "ASUS UM3402", ALC287_FIXUP_CS35L41_I2C_2), 7826 SND_PCI_QUIRK(0x1043, 0x1e1f, "ASUS Vivobook 15 X1504VAP", ALC2XX_FIXUP_HEADSET_MIC), 7827 SND_PCI_QUIRK(0x1043, 0x1e51, "ASUS Zephyrus M15", ALC294_FIXUP_ASUS_GU502_PINS), 7828 SND_PCI_QUIRK(0x1043, 0x1e5e, "ASUS ROG Strix G513", ALC294_FIXUP_ASUS_G513_PINS), 7829 SND_PCI_QUIRK(0x1043, 0x1e63, "ASUS H7606W", ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1), 7830 SND_PCI_QUIRK(0x1043, 0x1e83, "ASUS GA605W", ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1), 7831 SND_PCI_QUIRK(0x1043, 0x1e8e, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA401), 7832 SND_PCI_QUIRK(0x1043, 0x1e93, "ASUS ExpertBook B9403CVAR", ALC294_FIXUP_ASUS_HPE), 7833 SND_PCI_QUIRK(0x1043, 0x1eb3, "ASUS Ally RC72LA", ALC287_FIXUP_ASUS_ALLY_X), 7834 SND_PCI_QUIRK(0x1043, 0x1ed3, "ASUS HN7306W", ALC287_FIXUP_CS35L41_I2C_2), 7835 SND_PCI_QUIRK(0x1043, 0x1ee2, "ASUS UM6702RA/RC", ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1), 7836 SND_PCI_QUIRK(0x1043, 0x1c52, "ASUS Zephyrus G15 2022", ALC289_FIXUP_ASUS_GA401), 7837 SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401), 7838 SND_PCI_QUIRK(0x1043, 0x1f12, "ASUS UM5302", ALC287_FIXUP_CS35L41_I2C_2), 7839 SND_PCI_QUIRK(0x1043, 0x1f1f, "ASUS H7604JI/JV/J3D", ALC245_FIXUP_CS35L41_SPI_2), 7840 SND_PCI_QUIRK(0x1043, 0x1f62, "ASUS UX7602ZM", ALC245_FIXUP_CS35L41_SPI_2), 7841 SND_PCI_QUIRK(0x1043, 0x1f63, "ASUS P5405CSA", ALC245_FIXUP_CS35L41_SPI_2), 7842 SND_PCI_QUIRK(0x1043, 0x1f92, "ASUS ROG Flow X16", ALC289_FIXUP_ASUS_GA401), 7843 SND_PCI_QUIRK(0x1043, 0x1fb3, "ASUS ROG Flow Z13 GZ302EA", ALC287_FIXUP_CS35L41_I2C_2), 7844 SND_PCI_QUIRK(0x1043, 0x3011, "ASUS B5605CVA", ALC245_FIXUP_CS35L41_SPI_2), 7845 SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2), 7846 SND_PCI_QUIRK(0x1043, 0x3061, "ASUS B3405CCA", ALC294_FIXUP_ASUS_CS35L41_SPI_2), 7847 SND_PCI_QUIRK(0x1043, 0x3071, "ASUS B5405CCA", ALC294_FIXUP_ASUS_CS35L41_SPI_2), 7848 SND_PCI_QUIRK(0x1043, 0x30c1, "ASUS B3605CCA / P3605CCA", ALC294_FIXUP_ASUS_CS35L41_SPI_2), 7849 SND_PCI_QUIRK(0x1043, 0x30d1, "ASUS B5405CCA", ALC294_FIXUP_ASUS_CS35L41_SPI_2), 7850 SND_PCI_QUIRK(0x1043, 0x30e1, "ASUS B5605CCA", ALC294_FIXUP_ASUS_CS35L41_SPI_2), 7851 SND_PCI_QUIRK(0x1043, 0x31d0, "ASUS Zen AIO 27 Z272SD_A272SD", ALC274_FIXUP_ASUS_ZEN_AIO_27), 7852 SND_PCI_QUIRK(0x1043, 0x31e1, "ASUS B5605CCA", ALC294_FIXUP_ASUS_CS35L41_SPI_2), 7853 SND_PCI_QUIRK(0x1043, 0x31f1, "ASUS B3605CCA", ALC294_FIXUP_ASUS_CS35L41_SPI_2), 7854 SND_PCI_QUIRK(0x1043, 0x3391, "ASUS PM3606CKA", ALC287_FIXUP_CS35L41_I2C_2), 7855 SND_PCI_QUIRK(0x1043, 0x3601, "ASUS PM5406CGA", ALC287_FIXUP_CS35L41_I2C_2), 7856 SND_PCI_QUIRK(0x1043, 0x3611, "ASUS PM5606CGA", ALC287_FIXUP_CS35L41_I2C_2), 7857 SND_PCI_QUIRK(0x1043, 0x3701, "ASUS P5406CCA", ALC245_FIXUP_CS35L41_SPI_2), 7858 SND_PCI_QUIRK(0x1043, 0x3711, "ASUS P5606CCA", ALC245_FIXUP_CS35L41_SPI_2), 7859 SND_PCI_QUIRK(0x1043, 0x3a20, "ASUS G614JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS), 7860 SND_PCI_QUIRK(0x1043, 0x3a30, "ASUS G814JVR/JIR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS), 7861 SND_PCI_QUIRK(0x1043, 0x3a40, "ASUS G814JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS), 7862 SND_PCI_QUIRK(0x1043, 0x3a50, "ASUS G834JYR/JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS), 7863 SND_PCI_QUIRK(0x1043, 0x3a60, "ASUS G634JYR/JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS), 7864 SND_PCI_QUIRK(0x1043, 0x3d78, "ASUS GA603KH", ALC287_FIXUP_CS35L41_I2C_2), 7865 SND_PCI_QUIRK(0x1043, 0x3d88, "ASUS GA603KM", ALC287_FIXUP_CS35L41_I2C_2), 7866 SND_PCI_QUIRK(0x1043, 0x3e00, "ASUS G814FH/FM/FP", ALC287_FIXUP_CS35L41_I2C_2), 7867 SND_PCI_QUIRK(0x1043, 0x3e20, "ASUS G814PH/PM/PP", ALC287_FIXUP_CS35L41_I2C_2), 7868 SND_PCI_QUIRK(0x1043, 0x3e30, "ASUS TP3607SA", ALC287_FIXUP_TAS2781_I2C), 7869 SND_PCI_QUIRK(0x1043, 0x3ee0, "ASUS Strix G815_JHR_JMR_JPR", ALC287_FIXUP_TXNW2781_I2C), 7870 SND_PCI_QUIRK(0x1043, 0x3ef0, "ASUS Strix G635LR_LW_LX", ALC287_FIXUP_TXNW2781_I2C), 7871 SND_PCI_QUIRK(0x1043, 0x3f00, "ASUS Strix G815LH_LM_LP", ALC287_FIXUP_TXNW2781_I2C), 7872 SND_PCI_QUIRK(0x1043, 0x3f10, "ASUS Strix G835LR_LW_LX", ALC287_FIXUP_TXNW2781_I2C), 7873 SND_PCI_QUIRK(0x1043, 0x3f20, "ASUS Strix G615LR_LW", ALC287_FIXUP_TXNW2781_I2C), 7874 SND_PCI_QUIRK(0x1043, 0x3f30, "ASUS Strix G815LR_LW", ALC287_FIXUP_TXNW2781_I2C), 7875 SND_PCI_QUIRK(0x1043, 0x3fd0, "ASUS B3605CVA", ALC245_FIXUP_CS35L41_SPI_2), 7876 SND_PCI_QUIRK(0x1043, 0x3ff0, "ASUS B5405CVA", ALC245_FIXUP_CS35L41_SPI_2), 7877 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC), 7878 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC), 7879 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC), 7880 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC), 7881 SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101), 7882 SND_PCI_QUIRK(0x1043, 0x88f4, "ASUS NUC14LNS", ALC245_FIXUP_CS35L41_SPI_1), 7883 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2), 7884 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ), 7885 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ), 7886 SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX), 7887 SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE), 7888 SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE), 7889 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK), 7890 SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT), 7891 SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN), 7892 SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC), 7893 SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN), 7894 SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC), 7895 SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE), 7896 SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE), 7897 SND_PCI_QUIRK(0x10ec, 0x119e, "Positivo SU C1400", ALC269_FIXUP_ASPIRE_HEADSET_MIC), 7898 SND_PCI_QUIRK(0x10ec, 0x11bc, "VAIO VJFE-IL", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 7899 SND_PCI_QUIRK(0x10ec, 0x1230, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 7900 SND_PCI_QUIRK(0x10ec, 0x124c, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 7901 SND_PCI_QUIRK(0x10ec, 0x1252, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 7902 SND_PCI_QUIRK(0x10ec, 0x1254, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 7903 SND_PCI_QUIRK(0x10ec, 0x12cc, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 7904 SND_PCI_QUIRK(0x10ec, 0x12f6, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 7905 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_ASPIRE_HEADSET_MIC), 7906 SND_PCI_QUIRK(0x1414, 0x9c20, "Microsoft Surface Pro 2/3", ALC288_FIXUP_SURFACE_SWAP_DACS), 7907 SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC), 7908 SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_AMP), 7909 SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_AMP), 7910 SND_PCI_QUIRK(0x144d, 0xc188, "Samsung Galaxy Book Flex (NT950QCT-A38A)", ALC298_FIXUP_SAMSUNG_AMP), 7911 SND_PCI_QUIRK(0x144d, 0xc189, "Samsung Galaxy Book Flex (NT950QCG-X716)", ALC298_FIXUP_SAMSUNG_AMP), 7912 SND_PCI_QUIRK(0x144d, 0xc18a, "Samsung Galaxy Book Ion (NP930XCJ-K01US)", ALC298_FIXUP_SAMSUNG_AMP), 7913 SND_PCI_QUIRK(0x144d, 0xc1ac, "Samsung Galaxy Book2 Pro 360 (NP950QED)", ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS), 7914 SND_PCI_QUIRK(0x144d, 0xc1a3, "Samsung Galaxy Book Pro (NP935XDB-KC1SE)", ALC298_FIXUP_SAMSUNG_AMP), 7915 SND_PCI_QUIRK(0x144d, 0xc1a4, "Samsung Galaxy Book Pro 360 (NT935QBD)", ALC298_FIXUP_SAMSUNG_AMP), 7916 SND_PCI_QUIRK(0x144d, 0xc1a6, "Samsung Galaxy Book Pro 360 (NP930QBD)", ALC298_FIXUP_SAMSUNG_AMP), 7917 SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8), 7918 SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_AMP), 7919 HDA_CODEC_QUIRK(0x144d, 0xc824, "Samsung ELECTRONICS (750XBE/730XBE)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), 7920 SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_AMP), 7921 SND_PCI_QUIRK(0x144d, 0xc832, "Samsung Galaxy Book Flex Alpha (NP730QCJ)", ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), 7922 SND_PCI_QUIRK(0x144d, 0xc876, "Samsung 730QED (NP730QED-KA2US)", ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), 7923 SND_PCI_QUIRK(0x144d, 0xca03, "Samsung Galaxy Book2 Pro 360 (NP930QED)", ALC298_FIXUP_SAMSUNG_AMP), 7924 SND_PCI_QUIRK(0x144d, 0xca06, "Samsung Galaxy Book3 360 (NP730QFG)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), 7925 SND_PCI_QUIRK(0x144d, 0xc868, "Samsung Galaxy Book2 Pro (NP930XED)", ALC298_FIXUP_SAMSUNG_AMP), 7926 SND_PCI_QUIRK(0x144d, 0xc870, "Samsung Galaxy Book2 Pro (NP950XED)", ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS), 7927 SND_PCI_QUIRK(0x144d, 0xc872, "Samsung Galaxy Book2 Pro (NP950XEE)", ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS), 7928 SND_PCI_QUIRK(0x144d, 0xc886, "Samsung Galaxy Book3 Pro (NP964XFG)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS), 7929 SND_PCI_QUIRK(0x144d, 0xc902, "Samsung Galaxy Book5 360 (NP750QHA)", ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), 7930 SND_PCI_QUIRK(0x144d, 0xc1ca, "Samsung Galaxy Book3 Pro 360 (NP960QFG)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS), 7931 SND_PCI_QUIRK(0x144d, 0xc1cb, "Samsung Galaxy Book3 Pro 360 (NP965QFG)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS), 7932 SND_PCI_QUIRK(0x144d, 0xc1cc, "Samsung Galaxy Book3 Ultra (NT960XFH)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS), 7933 SND_PCI_QUIRK(0x1458, 0x900e, "Gigabyte G5 KF5 (2023)", ALC2XX_FIXUP_HEADSET_MIC), 7934 SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC), 7935 SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC), 7936 SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC), 7937 SND_PCI_QUIRK(0x152d, 0x1082, "Quanta NL3", ALC269_FIXUP_LIFEBOOK), 7938 SND_PCI_QUIRK(0x152d, 0x1262, "Huawei NBLB-WAX9N", ALC2XX_FIXUP_HEADSET_MIC), 7939 SND_PCI_QUIRK(0x1558, 0x0353, "Clevo V35[05]SN[CDE]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7940 SND_PCI_QUIRK(0x1558, 0x1323, "Clevo N130ZU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7941 SND_PCI_QUIRK(0x1558, 0x1325, "Clevo N15[01][CW]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7942 SND_PCI_QUIRK(0x1558, 0x1401, "Clevo L140[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7943 SND_PCI_QUIRK(0x1558, 0x1403, "Clevo N140CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7944 SND_PCI_QUIRK(0x1558, 0x1404, "Clevo N150CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7945 SND_PCI_QUIRK(0x1558, 0x14a1, "Clevo L141MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7946 SND_PCI_QUIRK(0x1558, 0x2624, "Clevo L240TU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7947 SND_PCI_QUIRK(0x1558, 0x28c1, "Clevo V370VND", ALC2XX_FIXUP_HEADSET_MIC), 7948 SND_PCI_QUIRK(0x1558, 0x35a1, "Clevo V3[56]0EN[CDE]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7949 SND_PCI_QUIRK(0x1558, 0x35b1, "Clevo V3[57]0WN[MNP]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7950 SND_PCI_QUIRK(0x1558, 0x4018, "Clevo NV40M[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7951 SND_PCI_QUIRK(0x1558, 0x4019, "Clevo NV40MZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7952 SND_PCI_QUIRK(0x1558, 0x4020, "Clevo NV40MB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7953 SND_PCI_QUIRK(0x1558, 0x4041, "Clevo NV4[15]PZ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7954 SND_PCI_QUIRK(0x1558, 0x40a1, "Clevo NL40GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7955 SND_PCI_QUIRK(0x1558, 0x40c1, "Clevo NL40[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7956 SND_PCI_QUIRK(0x1558, 0x40d1, "Clevo NL41DU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7957 SND_PCI_QUIRK(0x1558, 0x5015, "Clevo NH5[58]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7958 SND_PCI_QUIRK(0x1558, 0x5017, "Clevo NH7[79]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7959 SND_PCI_QUIRK(0x1558, 0x50a3, "Clevo NJ51GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7960 SND_PCI_QUIRK(0x1558, 0x50b3, "Clevo NK50S[BEZ]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7961 SND_PCI_QUIRK(0x1558, 0x50b6, "Clevo NK50S5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7962 SND_PCI_QUIRK(0x1558, 0x50b8, "Clevo NK50SZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7963 SND_PCI_QUIRK(0x1558, 0x50d5, "Clevo NP50D5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7964 SND_PCI_QUIRK(0x1558, 0x50e1, "Clevo NH5[58]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7965 SND_PCI_QUIRK(0x1558, 0x50e2, "Clevo NH7[79]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7966 SND_PCI_QUIRK(0x1558, 0x50f0, "Clevo NH50A[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7967 SND_PCI_QUIRK(0x1558, 0x50f2, "Clevo NH50E[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7968 SND_PCI_QUIRK(0x1558, 0x50f3, "Clevo NH58DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7969 SND_PCI_QUIRK(0x1558, 0x50f5, "Clevo NH55EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7970 SND_PCI_QUIRK(0x1558, 0x50f6, "Clevo NH55DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7971 SND_PCI_QUIRK(0x1558, 0x5101, "Clevo S510WU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7972 SND_PCI_QUIRK(0x1558, 0x5157, "Clevo W517GU1", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7973 SND_PCI_QUIRK(0x1558, 0x51a1, "Clevo NS50MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7974 SND_PCI_QUIRK(0x1558, 0x51b1, "Clevo NS50AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7975 SND_PCI_QUIRK(0x1558, 0x51b3, "Clevo NS70AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7976 SND_PCI_QUIRK(0x1558, 0x5630, "Clevo NP50RNJS", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7977 SND_PCI_QUIRK(0x1558, 0x5700, "Clevo X560WN[RST]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7978 SND_PCI_QUIRK(0x1558, 0x6480, "Clevo V6xxAW", ALC245_FIXUP_CLEVO_NOISY_MIC), 7979 SND_PCI_QUIRK(0x1558, 0x70a1, "Clevo NB70T[HJK]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7980 SND_PCI_QUIRK(0x1558, 0x70b3, "Clevo NK70SB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7981 SND_PCI_QUIRK(0x1558, 0x70f2, "Clevo NH79EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7982 SND_PCI_QUIRK(0x1558, 0x70f3, "Clevo NH77DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7983 SND_PCI_QUIRK(0x1558, 0x70f4, "Clevo NH77EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7984 SND_PCI_QUIRK(0x1558, 0x70f6, "Clevo NH77DPQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7985 SND_PCI_QUIRK(0x1558, 0x7716, "Clevo NS50PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7986 SND_PCI_QUIRK(0x1558, 0x7717, "Clevo NS70PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7987 SND_PCI_QUIRK(0x1558, 0x7718, "Clevo L140PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7988 SND_PCI_QUIRK(0x1558, 0x7724, "Clevo L140AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7989 SND_PCI_QUIRK(0x1558, 0x8228, "Clevo NR40BU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7990 SND_PCI_QUIRK(0x1558, 0x8520, "Clevo NH50D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7991 SND_PCI_QUIRK(0x1558, 0x8521, "Clevo NH77D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7992 SND_PCI_QUIRK(0x1558, 0x8535, "Clevo NH50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7993 SND_PCI_QUIRK(0x1558, 0x8536, "Clevo NH79D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7994 SND_PCI_QUIRK(0x1558, 0x8550, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7995 SND_PCI_QUIRK(0x1558, 0x8551, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 7996 SND_PCI_QUIRK(0x1558, 0x8560, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC), 7997 SND_PCI_QUIRK(0x1558, 0x8561, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC), 7998 SND_PCI_QUIRK(0x1558, 0x8562, "Clevo NH[57][0-9]RZ[Q]", ALC269_FIXUP_DMIC), 7999 SND_PCI_QUIRK(0x1558, 0x8668, "Clevo NP50B[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 8000 SND_PCI_QUIRK(0x1558, 0x866d, "Clevo NP5[05]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 8001 SND_PCI_QUIRK(0x1558, 0x867c, "Clevo NP7[01]PNP", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 8002 SND_PCI_QUIRK(0x1558, 0x867d, "Clevo NP7[01]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 8003 SND_PCI_QUIRK(0x1558, 0x8680, "Clevo NJ50LU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 8004 SND_PCI_QUIRK(0x1558, 0x8686, "Clevo NH50[CZ]U", ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME), 8005 SND_PCI_QUIRK(0x1558, 0x8a20, "Clevo NH55DCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 8006 SND_PCI_QUIRK(0x1558, 0x8a51, "Clevo NH70RCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 8007 SND_PCI_QUIRK(0x1558, 0x8d50, "Clevo NH55RCQ-M", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 8008 SND_PCI_QUIRK(0x1558, 0x951d, "Clevo N950T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 8009 SND_PCI_QUIRK(0x1558, 0x9600, "Clevo N960K[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 8010 SND_PCI_QUIRK(0x1558, 0x961d, "Clevo N960S[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 8011 SND_PCI_QUIRK(0x1558, 0x971d, "Clevo N970T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 8012 SND_PCI_QUIRK(0x1558, 0xa500, "Clevo NL5[03]RU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 8013 SND_PCI_QUIRK(0x1558, 0xa554, "VAIO VJFH52", ALC269_FIXUP_VAIO_VJFH52_MIC_NO_PRESENCE), 8014 SND_PCI_QUIRK(0x1558, 0xa559, "VAIO RPL", ALC256_FIXUP_VAIO_RPL_MIC_NO_PRESENCE), 8015 SND_PCI_QUIRK(0x1558, 0xa600, "Clevo NL50NU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 8016 SND_PCI_QUIRK(0x1558, 0xa650, "Clevo NP[567]0SN[CD]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 8017 SND_PCI_QUIRK(0x1558, 0xa671, "Clevo NP70SN[CDE]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 8018 SND_PCI_QUIRK(0x1558, 0xa741, "Clevo V54x_6x_TNE", ALC245_FIXUP_CLEVO_NOISY_MIC), 8019 SND_PCI_QUIRK(0x1558, 0xa743, "Clevo V54x_6x_TU", ALC245_FIXUP_CLEVO_NOISY_MIC), 8020 SND_PCI_QUIRK(0x1558, 0xa763, "Clevo V54x_6x_TU", ALC245_FIXUP_CLEVO_NOISY_MIC), 8021 SND_PCI_QUIRK(0x1558, 0xb018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 8022 SND_PCI_QUIRK(0x1558, 0xb019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 8023 SND_PCI_QUIRK(0x1558, 0xb022, "Clevo NH77D[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 8024 SND_PCI_QUIRK(0x1558, 0xc018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 8025 SND_PCI_QUIRK(0x1558, 0xc019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 8026 SND_PCI_QUIRK(0x1558, 0xc022, "Clevo NH77[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 8027 SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS), 8028 SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340), 8029 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE), 8030 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE), 8031 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE), 8032 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE), 8033 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE), 8034 SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK), 8035 SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST), 8036 SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK), 8037 SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK), 8038 SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK), 8039 SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK), 8040 SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440), 8041 SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK), 8042 SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK), 8043 SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK), 8044 SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK), 8045 SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK), 8046 SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_THINKPAD_LIMIT_INT_MIC_BOOST), 8047 SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK), 8048 SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK), 8049 SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK), 8050 SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 8051 SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 8052 SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460), 8053 SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460), 8054 SND_PCI_QUIRK(0x17aa, 0x2234, "Thinkpad ICE-1", ALC287_FIXUP_TAS2781_I2C), 8055 SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK), 8056 SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 8057 SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 8058 SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460), 8059 SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 8060 SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 8061 SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 8062 SND_PCI_QUIRK(0x17aa, 0x225c, "Lenovo ThinkPad X1 Carbon 6th Gen", ALC285_LENOVO_DAC_RENAME), 8063 SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_THINKPAD_LIMIT_INT_MIC_BOOST), 8064 SND_PCI_QUIRK(0x17aa, 0x2288, "Thinkpad X390", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK), 8065 SND_PCI_QUIRK(0x17aa, 0x2292, "Thinkpad X1 Carbon 7th", ALC285_FIXUP_THINKPAD_HEADSET_JACK), 8066 SND_PCI_QUIRK(0x17aa, 0x22be, "Thinkpad X1 Carbon 8th", ALC285_FIXUP_THINKPAD_HEADSET_JACK), 8067 SND_PCI_QUIRK(0x17aa, 0x22c1, "Thinkpad P1 Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK), 8068 SND_PCI_QUIRK(0x17aa, 0x22c2, "Thinkpad X1 Extreme Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK), 8069 SND_PCI_QUIRK(0x17aa, 0x22f1, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 8070 SND_PCI_QUIRK(0x17aa, 0x22f2, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 8071 SND_PCI_QUIRK(0x17aa, 0x22f3, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 8072 SND_PCI_QUIRK(0x17aa, 0x2316, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 8073 SND_PCI_QUIRK(0x17aa, 0x2317, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 8074 SND_PCI_QUIRK(0x17aa, 0x2318, "Thinkpad Z13 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 8075 SND_PCI_QUIRK(0x17aa, 0x2319, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 8076 SND_PCI_QUIRK(0x17aa, 0x231a, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 8077 SND_PCI_QUIRK(0x17aa, 0x231e, "Thinkpad", ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318), 8078 SND_PCI_QUIRK(0x17aa, 0x231f, "Thinkpad", ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318), 8079 SND_PCI_QUIRK(0x17aa, 0x2326, "Hera2", ALC287_FIXUP_TAS2781_I2C), 8080 SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY), 8081 SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY), 8082 SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 8083 SND_PCI_QUIRK(0x17aa, 0x3111, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 8084 SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 8085 SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 8086 SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 8087 SND_PCI_QUIRK(0x17aa, 0x3151, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC), 8088 SND_PCI_QUIRK(0x17aa, 0x3176, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC), 8089 SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC), 8090 SND_PCI_QUIRK(0x17aa, 0x31af, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340), 8091 SND_PCI_QUIRK(0x17aa, 0x3341, "Lenovo ThinkCentre M90 Gen4", ALC233_FIXUP_LENOVO_GPIO2_MIC_HOTKEY), 8092 SND_PCI_QUIRK(0x17aa, 0x3342, "Lenovo ThinkCentre M90 Gen4", ALC233_FIXUP_LENOVO_GPIO2_MIC_HOTKEY), 8093 SND_PCI_QUIRK(0x17aa, 0x3343, "Lenovo ThinkCentre M70 Gen4", ALC233_FIXUP_LENOVO_GPIO2_MIC_HOTKEY), 8094 SND_PCI_QUIRK(0x17aa, 0x3344, "Lenovo ThinkCentre M70 Gen4", ALC233_FIXUP_LENOVO_GPIO2_MIC_HOTKEY), 8095 SND_PCI_QUIRK(0x17aa, 0x334b, "Lenovo ThinkCentre M70 Gen5", ALC283_FIXUP_HEADSET_MIC), 8096 SND_PCI_QUIRK(0x17aa, 0x334f, "Lenovo ThinkCentre M90a Gen5", ALC233_FIXUP_LENOVO_GPIO2_MIC_HOTKEY), 8097 SND_PCI_QUIRK(0x17aa, 0x3384, "ThinkCentre M90a PRO", ALC233_FIXUP_LENOVO_L2MH_LOW_ENLED), 8098 SND_PCI_QUIRK(0x17aa, 0x3386, "ThinkCentre M90a Gen6", ALC233_FIXUP_LENOVO_L2MH_LOW_ENLED), 8099 SND_PCI_QUIRK(0x17aa, 0x3387, "ThinkCentre M70a Gen6", ALC233_FIXUP_LENOVO_L2MH_LOW_ENLED), 8100 SND_PCI_QUIRK(0x17aa, 0x3801, "Lenovo Yoga9 14IAP7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN), 8101 HDA_CODEC_QUIRK(0x17aa, 0x3802, "DuetITL 2021", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS), 8102 SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo Yoga Pro 9 14IRP8", ALC287_FIXUP_TAS2781_I2C), 8103 /* Yoga Pro 9 16IMH9 and Legion 7 16ITHG6 share PCI SSID 17aa:3811 8104 * with Legion S7 15IMH05; use codec SSID to distinguish them 8105 */ 8106 HDA_CODEC_QUIRK(0x17aa, 0x38d5, "Lenovo Yoga Pro 9 16IMH9", ALC287_FIXUP_TAS2781_I2C), 8107 HDA_CODEC_QUIRK(0x17aa, 0x38d6, "Lenovo Yoga Pro 9 16IMH9", ALC287_FIXUP_TAS2781_I2C), 8108 HDA_CODEC_QUIRK(0x17aa, 0x3855, "Legion 7 16ITHG6", ALC287_FIXUP_LEGION_16ITHG6), 8109 SND_PCI_QUIRK(0x17aa, 0x3811, "Legion S7 15IMH05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS), 8110 SND_PCI_QUIRK(0x17aa, 0x3813, "Legion 7i 15IMHG05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS), 8111 SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940 / Yoga Duet 7", ALC298_FIXUP_LENOVO_C940_DUET7), 8112 SND_PCI_QUIRK(0x17aa, 0x3819, "Lenovo 13s Gen2 ITL", ALC287_FIXUP_13S_GEN2_SPEAKERS), 8113 HDA_CODEC_QUIRK(0x17aa, 0x3820, "IdeaPad 330-17IKB 81DM", ALC269_FIXUP_ASPIRE_HEADSET_MIC), 8114 SND_PCI_QUIRK(0x17aa, 0x3820, "Yoga Duet 7 13ITL6", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS), 8115 SND_PCI_QUIRK(0x17aa, 0x3824, "Legion Y9000X 2020", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS), 8116 SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF), 8117 SND_PCI_QUIRK(0x17aa, 0x3834, "Lenovo IdeaPad Slim 9i 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS), 8118 SND_PCI_QUIRK(0x17aa, 0x383d, "Legion Y9000X 2019", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS), 8119 SND_PCI_QUIRK(0x17aa, 0x3843, "Lenovo Yoga 9i / Yoga Book 9i", ALC287_FIXUP_LENOVO_YOGA_BOOK_9I), 8120 SND_PCI_QUIRK(0x17aa, 0x3846, "Lenovo Yoga Pro 9 16IAH10", ALC287_FIXUP_YOGA9_SPEAKER2_TO_DAC1), 8121 /* Yoga Pro 7 14IMH9 shares PCI SSID 17aa:3847 with Legion 7 16ACHG6; 8122 * use codec SSID to distinguish them 8123 */ 8124 HDA_CODEC_QUIRK(0x17aa, 0x38cf, "Lenovo Yoga Pro 7 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN), 8125 SND_PCI_QUIRK(0x17aa, 0x3847, "Legion 7 16ACHG6", ALC287_FIXUP_LEGION_16ACHG6), 8126 SND_PCI_QUIRK(0x17aa, 0x384a, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS), 8127 /* Yoga Pro 7 14IRH8 shares PCI SSID 17aa:3852 with Yoga 7 14ITL5; 8128 * use codec SSID to distinguish them 8129 */ 8130 HDA_CODEC_QUIRK(0x17aa, 0x38b1, "Lenovo Yoga Pro 7 14IRH8", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN), 8131 SND_PCI_QUIRK(0x17aa, 0x3852, "Lenovo Yoga 7 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS), 8132 SND_PCI_QUIRK(0x17aa, 0x3853, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS), 8133 SND_PCI_QUIRK(0x17aa, 0x3855, "Legion 7 16ITHG6", ALC287_FIXUP_LEGION_16ITHG6), 8134 SND_PCI_QUIRK(0x17aa, 0x3862, "Lenovo IdeaPad Slim 3 15ABR8", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 8135 SND_PCI_QUIRK(0x17aa, 0x3865, "Lenovo 13X", ALC287_FIXUP_CS35L41_I2C_2), 8136 SND_PCI_QUIRK(0x17aa, 0x3866, "Lenovo 13X", ALC287_FIXUP_CS35L41_I2C_2), 8137 SND_PCI_QUIRK(0x17aa, 0x3869, "Lenovo Yoga7 14IAL7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN), 8138 HDA_CODEC_QUIRK(0x17aa, 0x386a, "Lenovo Yoga 7 16IAP7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN), 8139 HDA_CODEC_QUIRK(0x17aa, 0x386e, "Legion Y9000X 2022 IAH7", ALC287_FIXUP_CS35L41_I2C_2), 8140 SND_PCI_QUIRK(0x17aa, 0x386e, "Yoga Pro 7 14ARP8", ALC285_FIXUP_YOGA_SPEAKER2_TO_DAC1), 8141 HDA_CODEC_QUIRK(0x17aa, 0x38a7, "Legion Pro 7 16ARX8H", ALC287_FIXUP_TAS2781_I2C), /* this must match before PCI SSID 17aa:386f below */ 8142 HDA_CODEC_QUIRK(0x17aa, 0x38a8, "Legion Pro 7 16ARX8H", ALC287_FIXUP_TAS2781_I2C), /* this must match before PCI SSID 17aa:386f below */ 8143 SND_PCI_QUIRK(0x17aa, 0x386f, "Legion Pro 7i 16IAX7", ALC287_FIXUP_CS35L41_I2C_2), 8144 SND_PCI_QUIRK(0x17aa, 0x3870, "Lenovo Yoga 7 14ARB7", ALC287_FIXUP_YOGA7_14ARB7_I2C), 8145 SND_PCI_QUIRK(0x17aa, 0x3874, "Legion 7i 16IAX7", ALC287_FIXUP_CS35L41_I2C_2), 8146 SND_PCI_QUIRK(0x17aa, 0x3877, "Lenovo Legion 7 Slim 16ARHA7", ALC287_FIXUP_CS35L41_I2C_2), 8147 SND_PCI_QUIRK(0x17aa, 0x3878, "Lenovo Legion 7 Slim 16ARHA7", ALC287_FIXUP_CS35L41_I2C_2), 8148 SND_PCI_QUIRK(0x17aa, 0x387d, "Yoga S780-16 pro Quad AAC", ALC287_FIXUP_TAS2781_I2C), 8149 SND_PCI_QUIRK(0x17aa, 0x387e, "Yoga S780-16 pro Quad YC", ALC287_FIXUP_TAS2781_I2C), 8150 SND_PCI_QUIRK(0x17aa, 0x387f, "Yoga S780-16 pro dual LX", ALC287_FIXUP_TAS2781_I2C), 8151 SND_PCI_QUIRK(0x17aa, 0x3880, "Yoga S780-16 pro dual YC", ALC287_FIXUP_TAS2781_I2C), 8152 SND_PCI_QUIRK(0x17aa, 0x3881, "YB9 dual power mode2 YC", ALC287_FIXUP_TAS2781_I2C), 8153 SND_PCI_QUIRK(0x17aa, 0x3882, "Lenovo Yoga Pro 7 14APH8", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN), 8154 SND_PCI_QUIRK(0x17aa, 0x3884, "Y780 YG DUAL", ALC287_FIXUP_TAS2781_I2C), 8155 SND_PCI_QUIRK(0x17aa, 0x3886, "Y780 VECO DUAL", ALC287_FIXUP_TAS2781_I2C), 8156 SND_PCI_QUIRK(0x17aa, 0x3891, "Lenovo Yoga Pro 7 14AHP9", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN), 8157 SND_PCI_QUIRK(0x17aa, 0x38a5, "Y580P AMD dual", ALC287_FIXUP_TAS2781_I2C), 8158 SND_PCI_QUIRK(0x17aa, 0x38a7, "Y780P AMD YG dual", ALC287_FIXUP_TAS2781_I2C), 8159 SND_PCI_QUIRK(0x17aa, 0x38a8, "Y780P AMD VECO dual", ALC287_FIXUP_TAS2781_I2C), 8160 SND_PCI_QUIRK(0x17aa, 0x38a9, "Thinkbook 16P", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 8161 SND_PCI_QUIRK(0x17aa, 0x38ab, "Thinkbook 16P", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 8162 /* Lenovo Yoga Slim 7 14AKP10 shares PCI SSID 17aa:38b4 with Legion Slim 7 8163 * 16IRH8; use codec SSID to distinguish them 8164 */ 8165 HDA_CODEC_QUIRK(0x17aa, 0x391a, "Lenovo Yoga Slim 7 14AKP10", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN), 8166 SND_PCI_QUIRK(0x17aa, 0x38b4, "Legion Slim 7 16IRH8", ALC287_FIXUP_CS35L41_I2C_2), 8167 HDA_CODEC_QUIRK(0x17aa, 0x391c, "Lenovo Yoga 7 2-in-1 14AKP10", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN), 8168 HDA_CODEC_QUIRK(0x17aa, 0x391d, "Lenovo Yoga 7 2-in-1 16AKP10", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN), 8169 SND_PCI_QUIRK(0x17aa, 0x38b5, "Legion Slim 7 16IRH8", ALC287_FIXUP_CS35L41_I2C_2), 8170 SND_PCI_QUIRK(0x17aa, 0x38b6, "Legion Slim 7 16APH8", ALC287_FIXUP_CS35L41_I2C_2), 8171 SND_PCI_QUIRK(0x17aa, 0x38b7, "Legion Slim 7 16APH8", ALC287_FIXUP_CS35L41_I2C_2), 8172 SND_PCI_QUIRK(0x17aa, 0x38b8, "Yoga S780-14.5 proX AMD YC Dual", ALC287_FIXUP_TAS2781_I2C), 8173 SND_PCI_QUIRK(0x17aa, 0x38b9, "Yoga S780-14.5 proX AMD LX Dual", ALC287_FIXUP_TAS2781_I2C), 8174 SND_PCI_QUIRK(0x17aa, 0x38ba, "Yoga S780-14.5 Air AMD quad YC", ALC287_FIXUP_TAS2781_I2C), 8175 HDA_CODEC_QUIRK(0x17aa, 0x3926, "Legion Pro 5 16ADR10", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN), 8176 /* Legion R9000P ADR10 shares PCI SSID 17aa:38bb with Yoga S780-14.5 Air AMD quad AAC; 8177 * use codec SSID to distinguish them 8178 */ 8179 HDA_CODEC_QUIRK(0x17aa, 0x3927, "Legion R9000P ADR10", ALC287_FIXUP_LENOVO_LEGION_AW88399), 8180 HDA_CODEC_QUIRK(0x17aa, 0x3928, "Legion R9000P ADR10", ALC287_FIXUP_LENOVO_LEGION_AW88399), 8181 SND_PCI_QUIRK(0x17aa, 0x38bb, "Yoga S780-14.5 Air AMD quad AAC", ALC287_FIXUP_TAS2781_I2C), 8182 SND_PCI_QUIRK(0x17aa, 0x38be, "Yoga S980-14.5 proX YC Dual", ALC287_FIXUP_TAS2781_I2C), 8183 SND_PCI_QUIRK(0x17aa, 0x38bf, "Yoga S980-14.5 proX LX Dual", ALC287_FIXUP_TAS2781_I2C), 8184 SND_PCI_QUIRK(0x17aa, 0x38c3, "Y980 DUAL", ALC287_FIXUP_TAS2781_I2C), 8185 SND_PCI_QUIRK(0x17aa, 0x38c7, "Thinkbook 13x Gen 4", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 8186 SND_PCI_QUIRK(0x17aa, 0x38c8, "Thinkbook 13x Gen 4", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 8187 SND_PCI_QUIRK(0x17aa, 0x38cb, "Y790 YG DUAL", ALC287_FIXUP_TAS2781_I2C), 8188 SND_PCI_QUIRK(0x17aa, 0x38cd, "Y790 VECO DUAL", ALC287_FIXUP_TAS2781_I2C), 8189 SND_PCI_QUIRK(0x17aa, 0x38d2, "Lenovo Yoga 9 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN), 8190 SND_PCI_QUIRK(0x17aa, 0x38d3, "Yoga S990-16 Pro IMH YC Dual", ALC287_FIXUP_TAS2781_I2C), 8191 SND_PCI_QUIRK(0x17aa, 0x38d4, "Yoga S990-16 Pro IMH VECO Dual", ALC287_FIXUP_TAS2781_I2C), 8192 SND_PCI_QUIRK(0x17aa, 0x38d5, "Yoga S990-16 Pro IMH YC Quad", ALC287_FIXUP_TAS2781_I2C), 8193 SND_PCI_QUIRK(0x17aa, 0x38d6, "Yoga S990-16 Pro IMH VECO Quad", ALC287_FIXUP_TAS2781_I2C), 8194 SND_PCI_QUIRK(0x17aa, 0x38d7, "Lenovo Yoga 9 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN), 8195 SND_PCI_QUIRK(0x17aa, 0x38df, "Yoga Y990 Intel YC Dual", ALC287_FIXUP_TAS2781_I2C), 8196 SND_PCI_QUIRK(0x17aa, 0x38e0, "Yoga Y990 Intel VECO Dual", ALC287_FIXUP_TAS2781_I2C), 8197 SND_PCI_QUIRK(0x17aa, 0x38f8, "Yoga Book 9i", ALC287_FIXUP_TAS2781_I2C), 8198 /* Legion 7 15ASH11 shares PCI SSID 17aa:38f9 with Thinkbook 16P Gen5; 8199 * use codec SSID to distinguish them 8200 */ 8201 HDA_CODEC_QUIRK(0x17aa, 0x395b, "Lenovo Legion 7 15ASH11", ALC287_FIXUP_LENOVO_YOGA_PRO7), 8202 SND_PCI_QUIRK(0x17aa, 0x38f9, "Thinkbook 16P Gen5", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 8203 SND_PCI_QUIRK(0x17aa, 0x38fa, "Thinkbook 16P Gen5", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 8204 SND_PCI_QUIRK(0x17aa, 0x38fc, "Lenovo Yoga Pro 7 15ASH11", ALC287_FIXUP_LENOVO_YOGA_PRO7), 8205 SND_PCI_QUIRK(0x17aa, 0x38fd, "ThinkBook plus Gen5 Hybrid", ALC287_FIXUP_TAS2781_I2C), 8206 SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI), 8207 HDA_CODEC_QUIRK(0x17aa, 0x3906, "Legion Pro 7i 16IAX10H / Y9000P IAX10", ALC287_FIXUP_LENOVO_LEGION_AW88399), 8208 HDA_CODEC_QUIRK(0x17aa, 0x3907, "Legion Pro 7i 16IAX10H / Y9000P IAX10", ALC287_FIXUP_LENOVO_LEGION_AW88399), 8209 SND_PCI_QUIRK(0x17aa, 0x390d, "Lenovo Yoga Pro 7 14ASP10", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN_HEADSET), 8210 SND_PCI_QUIRK(0x17aa, 0x3911, "Lenovo Yoga Pro 7 14IAH10", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN), 8211 SND_PCI_QUIRK(0x17aa, 0x3912, "Lenovo Xiaoxin 14 GT", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN), 8212 SND_PCI_QUIRK(0x17aa, 0x3913, "Lenovo 145", ALC236_FIXUP_LENOVO_INV_DMIC), 8213 SND_PCI_QUIRK(0x17aa, 0x391f, "Yoga S990-16 pro Quad YC Quad", ALC287_FIXUP_TXNW2781_I2C), 8214 SND_PCI_QUIRK(0x17aa, 0x3920, "Yoga S990-16 pro Quad VECO Quad", ALC287_FIXUP_TXNW2781_I2C), 8215 SND_PCI_QUIRK(0x17aa, 0x3929, "Thinkbook 13x Gen 5", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 8216 SND_PCI_QUIRK(0x17aa, 0x392b, "Thinkbook 13x Gen 5", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 8217 HDA_CODEC_QUIRK(0x17aa, 0x3936, "Legion R9000P ADR10H", ALC287_FIXUP_LENOVO_LEGION_AW88399), 8218 HDA_CODEC_QUIRK(0x17aa, 0x3937, "Legion R9000P ADR10H", ALC287_FIXUP_LENOVO_LEGION_AW88399), 8219 HDA_CODEC_QUIRK(0x17aa, 0x3938, "Legion Pro 7 16AFR10H", ALC287_FIXUP_LENOVO_LEGION_AW88399), 8220 HDA_CODEC_QUIRK(0x17aa, 0x3939, "Legion Pro 7 16AFR10H", ALC287_FIXUP_LENOVO_LEGION_AW88399), 8221 SND_PCI_QUIRK(0x17aa, 0x393e, "Lenovo ThinkBook 14 G8+ IPH", ALC287_FIXUP_LENOVO_XPAD_HEADSET_JACK), 8222 HDA_CODEC_QUIRK(0x17aa, 0x394c, "Lenovo Yoga Slim 7 14AGP11", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN), 8223 SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC), 8224 SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI), 8225 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K), 8226 SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_THINKPAD_LIMIT_INT_MIC_BOOST), 8227 SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC), 8228 SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK), 8229 SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_THINKPAD_LIMIT_INT_MIC_BOOST), 8230 SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK), 8231 SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK), 8232 SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK), 8233 SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK), 8234 SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE), 8235 SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460), 8236 SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460), 8237 SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460), 8238 SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 8239 SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 8240 SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 8241 SND_PCI_QUIRK(0x17aa, 0x508b, "Thinkpad X12 Gen 1", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS), 8242 SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_THINKPAD_LIMIT_INT_MIC_BOOST), 8243 SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 8244 SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 8245 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD), 8246 SND_PCI_QUIRK(0x17aa, 0x9e56, "Lenovo ZhaoYang CF4620Z", ALC286_FIXUP_SONY_MIC_NO_PRESENCE), 8247 SND_PCI_QUIRK(0x1849, 0x0269, "Positivo Master C6400", ALC269VB_FIXUP_ASUS_ZENBOOK), 8248 SND_PCI_QUIRK(0x1849, 0x1233, "ASRock NUC Box 1100", ALC233_FIXUP_NO_AUDIO_JACK), 8249 SND_PCI_QUIRK(0x1849, 0xa233, "Positivo Master C6300", ALC269_FIXUP_HEADSET_MIC), 8250 SND_PCI_QUIRK(0x1854, 0x0440, "LG CQ6", ALC256_FIXUP_HEADPHONE_AMP_VOL), 8251 SND_PCI_QUIRK(0x1854, 0x0441, "LG CQ6 AIO", ALC256_FIXUP_HEADPHONE_AMP_VOL), 8252 SND_PCI_QUIRK(0x1854, 0x0488, "LG gram 16 (16Z90R)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS), 8253 SND_PCI_QUIRK(0x1854, 0x0489, "LG gram 16 (16Z90R-A)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS), 8254 SND_PCI_QUIRK(0x1854, 0x048a, "LG gram 17 (17ZD90R)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS), 8255 SND_PCI_QUIRK(0x1854, 0x0490, "LG Gram Style 14 (14Z90RS)", ALC298_FIXUP_LG_GRAM_STYLE_14), 8256 SND_PCI_QUIRK(0x1854, 0x0554, "LG gram 16 (16Z90TR)", ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS), 8257 SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS), 8258 SND_PCI_QUIRK(0x19e5, 0x320f, "Huawei WRT-WX9 ", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE), 8259 SND_PCI_QUIRK(0x19e5, 0x3212, "Huawei KLV-WX9 ", ALC256_FIXUP_ACER_HEADSET_MIC), 8260 SND_PCI_QUIRK(0x1a58, 0x2023, "Razer Blade 16 (2025)", 8261 ALC298_FIXUP_RAZER_BLADE16_2025_PINS), 8262 SND_PCI_QUIRK(0x1a58, 0x300e, "Razer Blade 16 (2025)", 8263 ALC298_FIXUP_RAZER_BLADE16_2025_PINS), 8264 SND_PCI_QUIRK(0x1b35, 0x1235, "CZC B20", ALC269_FIXUP_CZC_B20), 8265 SND_PCI_QUIRK(0x1b35, 0x1236, "CZC TMI", ALC269_FIXUP_CZC_TMI), 8266 SND_PCI_QUIRK(0x1b35, 0x1237, "CZC L101", ALC269_FIXUP_CZC_L101), 8267 SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */ 8268 SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802), 8269 SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X), 8270 SND_PCI_QUIRK(0x1c6c, 0x122a, "Positivo N14AP7", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 8271 SND_PCI_QUIRK(0x1c6c, 0x1251, "Positivo N14KP6-TG", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE), 8272 SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_SET_COEF_DEFAULTS), 8273 SND_PCI_QUIRK(0x1d05, 0x1096, "TongFang GMxMRxx", ALC269_FIXUP_NO_SHUTUP), 8274 SND_PCI_QUIRK(0x1d05, 0x1100, "TongFang GKxNRxx", ALC269_FIXUP_NO_SHUTUP), 8275 SND_PCI_QUIRK(0x1d05, 0x1111, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP), 8276 SND_PCI_QUIRK(0x1d05, 0x1119, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP), 8277 SND_PCI_QUIRK(0x1d05, 0x1129, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP), 8278 SND_PCI_QUIRK(0x1d05, 0x1147, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP), 8279 SND_PCI_QUIRK(0x1d05, 0x115c, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP), 8280 SND_PCI_QUIRK(0x1d05, 0x121b, "TongFang GMxAGxx", ALC269_FIXUP_NO_SHUTUP), 8281 SND_PCI_QUIRK(0x1d05, 0x1387, "TongFang GMxIXxx", ALC2XX_FIXUP_HEADSET_MIC), 8282 SND_PCI_QUIRK(0x1d05, 0x1409, "TongFang GMxIXxx", ALC2XX_FIXUP_HEADSET_MIC), 8283 SND_PCI_QUIRK(0x1d05, 0x300f, "TongFang X6AR5xxY", ALC2XX_FIXUP_HEADSET_MIC), 8284 SND_PCI_QUIRK(0x1d05, 0x3019, "TongFang X6FR5xxY", ALC2XX_FIXUP_HEADSET_MIC), 8285 SND_PCI_QUIRK(0x1d05, 0x3031, "TongFang X6AR55xU", ALC2XX_FIXUP_HEADSET_MIC), 8286 SND_PCI_QUIRK(0x1d05, 0x3033, "TongFang X6SP45xU", ALC2XX_FIXUP_HEADSET_MIC), 8287 SND_PCI_QUIRK(0x1d05, 0x3034, "TongFang X6KK45xU", ALC2XX_FIXUP_HEADSET_MIC), 8288 SND_PCI_QUIRK(0x1d05, 0x30ba, "TongFang XxAF5xxx", ALC2XX_FIXUP_HEADSET_MIC), 8289 SND_PCI_QUIRK(0x1d17, 0x3288, "Haier Boyue G42", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS), 8290 SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC), 8291 SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE), 8292 SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC), 8293 SND_PCI_QUIRK(0x1d72, 0x1905, "Xiaomi Mi Laptop Pro 15", ALC256_FIXUP_XIAOMI_PRO15_RESUME), 8294 SND_PCI_QUIRK(0x1d72, 0x1945, "Redmi G", ALC256_FIXUP_ASUS_HEADSET_MIC), 8295 SND_PCI_QUIRK(0x1d72, 0x1947, "RedmiBook Air", ALC255_FIXUP_XIAOMI_HEADSET_MIC), 8296 SND_PCI_QUIRK(0x1e39, 0xca14, "MEDION NM14LNL", ALC233_FIXUP_MEDION_MTL_SPK), 8297 SND_PCI_QUIRK(0x1e50, 0x7007, "Positivo DN50E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 8298 SND_PCI_QUIRK(0x1e50, 0x7036, "Acer Gadget E10 ETBook", ALC233_FIXUP_WUJIE_SPEAKERS), 8299 SND_PCI_QUIRK(0x1e50, 0x7038, "Positivo DN140", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 8300 SND_PCI_QUIRK(0x1ee7, 0x2078, "HONOR BRB-X M1010", ALC2XX_FIXUP_HEADSET_MIC), 8301 SND_PCI_QUIRK(0x1ee7, 0x2081, "HONOR MRB-XXX M1020", ALC256_FIXUP_HONOR_MRB_XXX_M1020_AUDIO), 8302 SND_PCI_QUIRK(0x1f4c, 0xb020, "Minisforum AI X1 Pro", 8303 ALC245_FIXUP_MINISFORUM_JACK_DETECT), 8304 SND_PCI_QUIRK(0x1f4c, 0xe001, "Minisforum V3 (SE)", ALC245_FIXUP_BASS_HP_DAC), 8305 SND_PCI_QUIRK(0x1f66, 0x0105, "Ayaneo Portable Game Player", ALC287_FIXUP_CS35L41_I2C_2), 8306 SND_PCI_QUIRK(0x2014, 0x800a, "Positivo ARN50", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 8307 SND_PCI_QUIRK(0x2039, 0x0001, "Inspur S14-G1", ALC295_FIXUP_CHROME_BOOK), 8308 SND_PCI_QUIRK(0x2145, 0x0001, "Star Labs StarFighter", ALC233_FIXUP_STARLABS_STARFIGHTER), 8309 SND_PCI_QUIRK(0x2782, 0x0214, "VAIO VJFE-CL", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 8310 SND_PCI_QUIRK(0x2782, 0x0228, "Infinix ZERO BOOK 13", ALC269VB_FIXUP_INFINIX_ZERO_BOOK_13), 8311 SND_PCI_QUIRK(0x2782, 0x0232, "CHUWI CoreBook XPro", ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO), 8312 SND_PCI_QUIRK(0x2782, 0x0250, "Infinix INBOOK X3 Slim", ALC269VB_FIXUP_INFINIX_INBOOK_X3_SLIM), 8313 SND_PCI_QUIRK(0x2782, 0x1407, "Positivo P15X", ALC269_FIXUP_POSITIVO_P15X_HEADSET_MIC), 8314 SND_PCI_QUIRK(0x2782, 0x1409, "Positivo K116J", ALC269_FIXUP_POSITIVO_P15X_HEADSET_MIC), 8315 SND_PCI_QUIRK(0x2782, 0x1701, "Infinix Y4 Max", ALC269VC_FIXUP_INFINIX_Y4_MAX), 8316 SND_PCI_QUIRK(0x2782, 0x1705, "MEDION E15433", ALC269VC_FIXUP_INFINIX_Y4_MAX), 8317 SND_PCI_QUIRK(0x2782, 0x1707, "Vaio VJFE-ADL", ALC298_FIXUP_SPK_VOLUME), 8318 SND_PCI_QUIRK(0x2782, 0x4900, "MEDION E15443", ALC233_FIXUP_MEDION_MTL_SPK), 8319 SND_PCI_QUIRK(0x2782, 0xa128, "Positivo N15RPE-S", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 8320 SND_PCI_QUIRK(0x2782, 0xa212, "Lunnen Ground 14", ALC269VC_FIXUP_LUNNEN_GROUND_14), 8321 SND_PCI_QUIRK(0x7017, 0x2014, "Star Labs StarFighter", ALC233_FIXUP_STARLABS_STARFIGHTER), 8322 SND_PCI_QUIRK(0x8086, 0x2073, "Intel NUC 8 Hades Canyon", 8323 ALC700_FIXUP_INTEL_HADES_CANYON), 8324 SND_PCI_QUIRK(0x8086, 0x2074, "Intel NUC 8", ALC233_FIXUP_INTEL_NUC8_DMIC), 8325 SND_PCI_QUIRK(0x8086, 0x2080, "Intel NUC 8 Rugged", ALC256_FIXUP_INTEL_NUC8_RUGGED), 8326 SND_PCI_QUIRK(0x8086, 0x2081, "Intel NUC 10", ALC256_FIXUP_INTEL_NUC10), 8327 SND_PCI_QUIRK(0x8086, 0x3038, "Intel NUC 13", ALC295_FIXUP_CHROME_BOOK), 8328 SND_PCI_QUIRK(0xc011, 0x1d05, "MECHREVO WUJIE Series", ALC233_FIXUP_WUJIE_SPEAKERS), 8329 SND_PCI_QUIRK(0xf111, 0x0001, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE), 8330 SND_PCI_QUIRK(0xf111, 0x0006, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE), 8331 SND_PCI_QUIRK(0xf111, 0x0009, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE), 8332 SND_PCI_QUIRK(0xf111, 0x000b, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE), 8333 SND_PCI_QUIRK(0xf111, 0x000c, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE), 8334 SND_PCI_QUIRK(0xf111, 0x000f, "Framework Laptop 13 Pro PTL", ALC295_FIXUP_FRAMEWORK_LAPTOP_LIMIT_INT_MIC_BOOST), 8335 SND_PCI_QUIRK(0xf111, 0x010f, "Framework Laptop 13 PTL", ALC295_FIXUP_FRAMEWORK_LAPTOP_LIMIT_INT_MIC_BOOST), 8336 SND_PCI_QUIRK(0xf111, 0x0010, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_LIMIT_INT_MIC_BOOST), 8337 8338 #if 0 8339 /* Below is a quirk table taken from the old code. 8340 * Basically the device should work as is without the fixup table. 8341 * If BIOS doesn't give a proper info, enable the corresponding 8342 * fixup entry. 8343 */ 8344 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A", 8345 ALC269_FIXUP_AMIC), 8346 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC), 8347 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC), 8348 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC), 8349 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC), 8350 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC), 8351 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC), 8352 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC), 8353 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC), 8354 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC), 8355 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC), 8356 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC), 8357 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC), 8358 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC), 8359 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC), 8360 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC), 8361 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC), 8362 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC), 8363 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC), 8364 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC), 8365 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC), 8366 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC), 8367 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC), 8368 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC), 8369 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC), 8370 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC), 8371 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC), 8372 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC), 8373 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC), 8374 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC), 8375 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC), 8376 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC), 8377 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC), 8378 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC), 8379 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC), 8380 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC), 8381 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC), 8382 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC), 8383 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC), 8384 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC), 8385 #endif 8386 {} 8387 }; 8388 8389 static const struct hda_quirk alc269_fixup_vendor_tbl[] = { 8390 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC), 8391 SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED), 8392 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO), 8393 SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo XPAD", ALC269_FIXUP_LENOVO_XPAD_ACPI), 8394 SND_PCI_QUIRK_VENDOR(0x19e5, "Huawei Matebook", ALC255_FIXUP_MIC_MUTE_LED), 8395 SND_PCI_QUIRK_VENDOR(0x2145, "Star Labs", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 8396 {} 8397 }; 8398 8399 static const struct hda_model_fixup alc269_fixup_models[] = { 8400 {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"}, 8401 {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"}, 8402 {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"}, 8403 {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"}, 8404 {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"}, 8405 {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"}, 8406 {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"}, 8407 {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"}, 8408 {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"}, 8409 {.id = ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, .name = "lenovo-dock-limit-boost"}, 8410 {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"}, 8411 {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"}, 8412 {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"}, 8413 {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"}, 8414 {.id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, .name = "dell-headset3"}, 8415 {.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, .name = "dell-headset4"}, 8416 {.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET, .name = "dell-headset4-quiet"}, 8417 {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"}, 8418 {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"}, 8419 {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"}, 8420 {.id = ALC292_FIXUP_TPT440, .name = "tpt440"}, 8421 {.id = ALC292_FIXUP_TPT460, .name = "tpt460"}, 8422 {.id = ALC298_FIXUP_TPT470_DOCK_FIX, .name = "tpt470-dock-fix"}, 8423 {.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"}, 8424 {.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"}, 8425 {.id = ALC233_FIXUP_STARLABS_STARFIGHTER, .name = "starlabs-starfighter"}, 8426 {.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"}, 8427 {.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"}, 8428 {.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"}, 8429 {.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"}, 8430 {.id = ALC269_FIXUP_LENOVO_EAPD, .name = "lenovo-eapd"}, 8431 {.id = ALC275_FIXUP_SONY_HWEQ, .name = "sony-hweq"}, 8432 {.id = ALC269_FIXUP_PCM_44K, .name = "pcm44k"}, 8433 {.id = ALC269_FIXUP_LIFEBOOK, .name = "lifebook"}, 8434 {.id = ALC269_FIXUP_LIFEBOOK_EXTMIC, .name = "lifebook-extmic"}, 8435 {.id = ALC269_FIXUP_LIFEBOOK_HP_PIN, .name = "lifebook-hp-pin"}, 8436 {.id = ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, .name = "lifebook-u7x7"}, 8437 {.id = ALC269VB_FIXUP_AMIC, .name = "alc269vb-amic"}, 8438 {.id = ALC269VB_FIXUP_DMIC, .name = "alc269vb-dmic"}, 8439 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC1, .name = "hp-mute-led-mic1"}, 8440 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC2, .name = "hp-mute-led-mic2"}, 8441 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC3, .name = "hp-mute-led-mic3"}, 8442 {.id = ALC269_FIXUP_HP_GPIO_MIC1_LED, .name = "hp-gpio-mic1"}, 8443 {.id = ALC269_FIXUP_HP_LINE1_MIC1_LED, .name = "hp-line1-mic1"}, 8444 {.id = ALC269_FIXUP_NO_SHUTUP, .name = "noshutup"}, 8445 {.id = ALC286_FIXUP_SONY_MIC_NO_PRESENCE, .name = "sony-nomic"}, 8446 {.id = ALC269_FIXUP_ASPIRE_HEADSET_MIC, .name = "aspire-headset-mic"}, 8447 {.id = ALC269_FIXUP_ASUS_X101, .name = "asus-x101"}, 8448 {.id = ALC271_FIXUP_HP_GATE_MIC_JACK, .name = "acer-ao7xx"}, 8449 {.id = ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, .name = "acer-aspire-e1"}, 8450 {.id = ALC269_FIXUP_ACER_AC700, .name = "acer-ac700"}, 8451 {.id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, .name = "limit-mic-boost"}, 8452 {.id = ALC269VB_FIXUP_ASUS_ZENBOOK, .name = "asus-zenbook"}, 8453 {.id = ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, .name = "asus-zenbook-ux31a"}, 8454 {.id = ALC269VB_FIXUP_ORDISSIMO_EVE2, .name = "ordissimo"}, 8455 {.id = ALC282_FIXUP_ASUS_TX300, .name = "asus-tx300"}, 8456 {.id = ALC283_FIXUP_INT_MIC, .name = "alc283-int-mic"}, 8457 {.id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, .name = "mono-speakers"}, 8458 {.id = ALC290_FIXUP_SUBWOOFER_HSJACK, .name = "alc290-subwoofer"}, 8459 {.id = ALC269_FIXUP_THINKPAD_ACPI, .name = "thinkpad"}, 8460 {.id = ALC269_FIXUP_LENOVO_XPAD_ACPI, .name = "lenovo-xpad-led"}, 8461 {.id = ALC269_FIXUP_DMIC_THINKPAD_ACPI, .name = "dmic-thinkpad"}, 8462 {.id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, .name = "alc255-acer"}, 8463 {.id = ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc255-asus"}, 8464 {.id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc255-dell1"}, 8465 {.id = ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "alc255-dell2"}, 8466 {.id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc293-dell1"}, 8467 {.id = ALC283_FIXUP_HEADSET_MIC, .name = "alc283-headset"}, 8468 {.id = ALC255_FIXUP_MIC_MUTE_LED, .name = "alc255-dell-mute"}, 8469 {.id = ALC282_FIXUP_ASPIRE_V5_PINS, .name = "aspire-v5"}, 8470 {.id = ALC269VB_FIXUP_ASPIRE_E1_COEF, .name = "aspire-e1-coef"}, 8471 {.id = ALC280_FIXUP_HP_GPIO4, .name = "hp-gpio4"}, 8472 {.id = ALC286_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"}, 8473 {.id = ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, .name = "hp-gpio2-hotkey"}, 8474 {.id = ALC280_FIXUP_HP_DOCK_PINS, .name = "hp-dock-pins"}, 8475 {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic"}, 8476 {.id = ALC280_FIXUP_HP_9480M, .name = "hp-9480m"}, 8477 {.id = ALC288_FIXUP_DELL_HEADSET_MODE, .name = "alc288-dell-headset"}, 8478 {.id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc288-dell1"}, 8479 {.id = ALC288_FIXUP_DELL_XPS_13, .name = "alc288-dell-xps13"}, 8480 {.id = ALC292_FIXUP_DELL_E7X, .name = "dell-e7x"}, 8481 {.id = ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, .name = "alc293-dell"}, 8482 {.id = ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc298-dell1"}, 8483 {.id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, .name = "alc298-dell-aio"}, 8484 {.id = ALC275_FIXUP_DELL_XPS, .name = "alc275-dell-xps"}, 8485 {.id = ALC293_FIXUP_LENOVO_SPK_NOISE, .name = "lenovo-spk-noise"}, 8486 {.id = ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, .name = "lenovo-hotkey"}, 8487 {.id = ALC255_FIXUP_DELL_SPK_NOISE, .name = "dell-spk-noise"}, 8488 {.id = ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc225-dell1"}, 8489 {.id = ALC295_FIXUP_DISABLE_DAC3, .name = "alc295-disable-dac3"}, 8490 {.id = ALC285_FIXUP_SPEAKER2_TO_DAC1, .name = "alc285-speaker2-to-dac1"}, 8491 {.id = ALC280_FIXUP_HP_HEADSET_MIC, .name = "alc280-hp-headset"}, 8492 {.id = ALC221_FIXUP_HP_FRONT_MIC, .name = "alc221-hp-mic"}, 8493 {.id = ALC298_FIXUP_SPK_VOLUME, .name = "alc298-spk-volume"}, 8494 {.id = ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, .name = "dell-inspiron-7559"}, 8495 {.id = ALC269_FIXUP_ATIV_BOOK_8, .name = "ativ-book"}, 8496 {.id = ALC221_FIXUP_HP_MIC_NO_PRESENCE, .name = "alc221-hp-mic"}, 8497 {.id = ALC256_FIXUP_ASUS_HEADSET_MODE, .name = "alc256-asus-headset"}, 8498 {.id = ALC256_FIXUP_ASUS_MIC, .name = "alc256-asus-mic"}, 8499 {.id = ALC256_FIXUP_ASUS_AIO_GPIO2, .name = "alc256-asus-aio"}, 8500 {.id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc233-asus"}, 8501 {.id = ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, .name = "alc233-eapd"}, 8502 {.id = ALC294_FIXUP_LENOVO_MIC_LOCATION, .name = "alc294-lenovo-mic"}, 8503 {.id = ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, .name = "alc225-wyse"}, 8504 {.id = ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, .name = "alc274-dell-aio"}, 8505 {.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"}, 8506 {.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"}, 8507 {.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"}, 8508 {.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"}, 8509 {.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"}, 8510 {.id = ALC256_FIXUP_CHROME_BOOK, .name = "alc-2024y-chromebook"}, 8511 {.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"}, 8512 {.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"}, 8513 {.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"}, 8514 {.id = ALC298_FIXUP_SAMSUNG_AMP, .name = "alc298-samsung-amp"}, 8515 {.id = ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS, .name = "alc298-samsung-amp-v2-2-amps"}, 8516 {.id = ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS, .name = "alc298-samsung-amp-v2-4-amps"}, 8517 {.id = ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc256-samsung-headphone"}, 8518 {.id = ALC255_FIXUP_XIAOMI_HEADSET_MIC, .name = "alc255-xiaomi-headset"}, 8519 {.id = ALC274_FIXUP_HP_MIC, .name = "alc274-hp-mic-detect"}, 8520 {.id = ALC245_FIXUP_HP_X360_AMP, .name = "alc245-hp-x360-amp"}, 8521 {.id = ALC295_FIXUP_HP_OMEN, .name = "alc295-hp-omen"}, 8522 {.id = ALC285_FIXUP_HP_SPECTRE_X360, .name = "alc285-hp-spectre-x360"}, 8523 {.id = ALC285_FIXUP_HP_SPECTRE_X360_EB1, .name = "alc285-hp-spectre-x360-eb1"}, 8524 {.id = ALC285_FIXUP_HP_SPECTRE_X360_DF1, .name = "alc285-hp-spectre-x360-df1"}, 8525 {.id = ALC285_FIXUP_HP_ENVY_X360, .name = "alc285-hp-envy-x360"}, 8526 {.id = ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, .name = "alc287-ideapad-bass-spk-amp"}, 8527 {.id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN, .name = "alc287-yoga9-bass-spk-pin"}, 8528 {.id = ALC623_FIXUP_LENOVO_THINKSTATION_P340, .name = "alc623-lenovo-thinkstation-p340"}, 8529 {.id = ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, .name = "alc255-acer-headphone-and-mic"}, 8530 {.id = ALC285_FIXUP_HP_GPIO_AMP_INIT, .name = "alc285-hp-amp-init"}, 8531 {.id = ALC236_FIXUP_LENOVO_INV_DMIC, .name = "alc236-fixup-lenovo-inv-mic"}, 8532 {.id = ALC2XX_FIXUP_HEADSET_MIC, .name = "alc2xx-fixup-headset-mic"}, 8533 {.id = ALC245_FIXUP_BASS_HP_DAC, .name = "alc245-fixup-bass-hp-dac"}, 8534 {.id = ALC256_FIXUP_HONOR_MRB_XXX_M1020_AUDIO, .name = "alc256-honor-mrb-xxx-m1020-audio"}, 8535 {.id = ALC287_FIXUP_LENOVO_LEGION_AW88399, .name = "alc287-lenovo-legion-aw88399"}, 8536 {} 8537 }; 8538 #define ALC225_STANDARD_PINS \ 8539 {0x21, 0x04211020} 8540 8541 #define ALC256_STANDARD_PINS \ 8542 {0x12, 0x90a60140}, \ 8543 {0x14, 0x90170110}, \ 8544 {0x21, 0x02211020} 8545 8546 #define ALC282_STANDARD_PINS \ 8547 {0x14, 0x90170110} 8548 8549 #define ALC290_STANDARD_PINS \ 8550 {0x12, 0x99a30130} 8551 8552 #define ALC292_STANDARD_PINS \ 8553 {0x14, 0x90170110}, \ 8554 {0x15, 0x0221401f} 8555 8556 #define ALC295_STANDARD_PINS \ 8557 {0x12, 0xb7a60130}, \ 8558 {0x14, 0x90170110}, \ 8559 {0x21, 0x04211020} 8560 8561 #define ALC298_STANDARD_PINS \ 8562 {0x12, 0x90a60130}, \ 8563 {0x21, 0x03211020} 8564 8565 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = { 8566 SND_HDA_PIN_QUIRK(0x10ec0221, 0x103c, "HP Workstation", ALC221_FIXUP_HP_HEADSET_MIC, 8567 {0x14, 0x01014020}, 8568 {0x17, 0x90170110}, 8569 {0x18, 0x02a11030}, 8570 {0x19, 0x0181303F}, 8571 {0x21, 0x0221102f}), 8572 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE, 8573 {0x12, 0x90a601c0}, 8574 {0x14, 0x90171120}, 8575 {0x21, 0x02211030}), 8576 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, 8577 {0x14, 0x90170110}, 8578 {0x1b, 0x90a70130}, 8579 {0x21, 0x03211020}), 8580 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, 8581 {0x1a, 0x90a70130}, 8582 {0x1b, 0x90170110}, 8583 {0x21, 0x03211020}), 8584 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 8585 ALC225_STANDARD_PINS, 8586 {0x12, 0xb7a60130}, 8587 {0x14, 0x901701a0}), 8588 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 8589 ALC225_STANDARD_PINS, 8590 {0x12, 0xb7a60130}, 8591 {0x14, 0x901701b0}), 8592 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 8593 ALC225_STANDARD_PINS, 8594 {0x12, 0xb7a60150}, 8595 {0x14, 0x901701a0}), 8596 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 8597 ALC225_STANDARD_PINS, 8598 {0x12, 0xb7a60150}, 8599 {0x14, 0x901701b0}), 8600 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 8601 ALC225_STANDARD_PINS, 8602 {0x12, 0xb7a60130}, 8603 {0x1b, 0x90170110}), 8604 SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 8605 {0x1b, 0x01111010}, 8606 {0x1e, 0x01451130}, 8607 {0x21, 0x02211020}), 8608 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, 8609 {0x12, 0x90a60140}, 8610 {0x14, 0x90170110}, 8611 {0x19, 0x02a11030}, 8612 {0x21, 0x02211020}), 8613 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION, 8614 {0x14, 0x90170110}, 8615 {0x19, 0x02a11030}, 8616 {0x1a, 0x02a11040}, 8617 {0x1b, 0x01014020}, 8618 {0x21, 0x0221101f}), 8619 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION, 8620 {0x14, 0x90170110}, 8621 {0x19, 0x02a11030}, 8622 {0x1a, 0x02a11040}, 8623 {0x1b, 0x01011020}, 8624 {0x21, 0x0221101f}), 8625 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION, 8626 {0x14, 0x90170110}, 8627 {0x19, 0x02a11020}, 8628 {0x1a, 0x02a11030}, 8629 {0x21, 0x0221101f}), 8630 SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC, 8631 {0x21, 0x02211010}), 8632 SND_HDA_PIN_QUIRK(0x10ec0236, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC, 8633 {0x14, 0x90170110}, 8634 {0x19, 0x02a11020}, 8635 {0x21, 0x02211030}), 8636 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, 8637 {0x14, 0x90170110}, 8638 {0x21, 0x02211020}), 8639 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8640 {0x14, 0x90170130}, 8641 {0x21, 0x02211040}), 8642 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8643 {0x12, 0x90a60140}, 8644 {0x14, 0x90170110}, 8645 {0x21, 0x02211020}), 8646 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8647 {0x12, 0x90a60160}, 8648 {0x14, 0x90170120}, 8649 {0x21, 0x02211030}), 8650 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8651 {0x14, 0x90170110}, 8652 {0x1b, 0x02011020}, 8653 {0x21, 0x0221101f}), 8654 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8655 {0x14, 0x90170110}, 8656 {0x1b, 0x01011020}, 8657 {0x21, 0x0221101f}), 8658 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8659 {0x14, 0x90170130}, 8660 {0x1b, 0x01014020}, 8661 {0x21, 0x0221103f}), 8662 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8663 {0x14, 0x90170130}, 8664 {0x1b, 0x01011020}, 8665 {0x21, 0x0221103f}), 8666 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8667 {0x14, 0x90170130}, 8668 {0x1b, 0x02011020}, 8669 {0x21, 0x0221103f}), 8670 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8671 {0x14, 0x90170150}, 8672 {0x1b, 0x02011020}, 8673 {0x21, 0x0221105f}), 8674 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8675 {0x14, 0x90170110}, 8676 {0x1b, 0x01014020}, 8677 {0x21, 0x0221101f}), 8678 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8679 {0x12, 0x90a60160}, 8680 {0x14, 0x90170120}, 8681 {0x17, 0x90170140}, 8682 {0x21, 0x0321102f}), 8683 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8684 {0x12, 0x90a60160}, 8685 {0x14, 0x90170130}, 8686 {0x21, 0x02211040}), 8687 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8688 {0x12, 0x90a60160}, 8689 {0x14, 0x90170140}, 8690 {0x21, 0x02211050}), 8691 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8692 {0x12, 0x90a60170}, 8693 {0x14, 0x90170120}, 8694 {0x21, 0x02211030}), 8695 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8696 {0x12, 0x90a60170}, 8697 {0x14, 0x90170130}, 8698 {0x21, 0x02211040}), 8699 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8700 {0x12, 0x90a60170}, 8701 {0x14, 0x90171130}, 8702 {0x21, 0x02211040}), 8703 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8704 {0x12, 0x90a60170}, 8705 {0x14, 0x90170140}, 8706 {0x21, 0x02211050}), 8707 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8708 {0x12, 0x90a60180}, 8709 {0x14, 0x90170130}, 8710 {0x21, 0x02211040}), 8711 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8712 {0x12, 0x90a60180}, 8713 {0x14, 0x90170120}, 8714 {0x21, 0x02211030}), 8715 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8716 {0x1b, 0x01011020}, 8717 {0x21, 0x02211010}), 8718 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC, 8719 {0x14, 0x90170110}, 8720 {0x1b, 0x90a70130}, 8721 {0x21, 0x04211020}), 8722 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC, 8723 {0x14, 0x90170110}, 8724 {0x1b, 0x90a70130}, 8725 {0x21, 0x03211020}), 8726 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE, 8727 {0x12, 0x90a60130}, 8728 {0x14, 0x90170110}, 8729 {0x21, 0x03211020}), 8730 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE, 8731 {0x12, 0x90a60130}, 8732 {0x14, 0x90170110}, 8733 {0x21, 0x04211020}), 8734 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE, 8735 {0x1a, 0x90a70130}, 8736 {0x1b, 0x90170110}, 8737 {0x21, 0x03211020}), 8738 SND_HDA_PIN_QUIRK(0x10ec0256, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC, 8739 {0x14, 0x90170110}, 8740 {0x19, 0x02a11020}, 8741 {0x21, 0x0221101f}), 8742 SND_HDA_PIN_QUIRK(0x10ec0274, 0x103c, "HP", ALC274_FIXUP_HP_HEADSET_MIC, 8743 {0x17, 0x90170110}, 8744 {0x19, 0x03a11030}, 8745 {0x21, 0x03211020}), 8746 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4, 8747 {0x12, 0x90a60130}, 8748 {0x14, 0x90170110}, 8749 {0x15, 0x0421101f}, 8750 {0x1a, 0x04a11020}), 8751 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED, 8752 {0x12, 0x90a60140}, 8753 {0x14, 0x90170110}, 8754 {0x15, 0x0421101f}, 8755 {0x18, 0x02811030}, 8756 {0x1a, 0x04a1103f}, 8757 {0x1b, 0x02011020}), 8758 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1, 8759 ALC282_STANDARD_PINS, 8760 {0x12, 0x99a30130}, 8761 {0x19, 0x03a11020}, 8762 {0x21, 0x0321101f}), 8763 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 8764 ALC282_STANDARD_PINS, 8765 {0x12, 0x99a30130}, 8766 {0x19, 0x03a11020}, 8767 {0x21, 0x03211040}), 8768 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 8769 ALC282_STANDARD_PINS, 8770 {0x12, 0x99a30130}, 8771 {0x19, 0x03a11030}, 8772 {0x21, 0x03211020}), 8773 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 8774 ALC282_STANDARD_PINS, 8775 {0x12, 0x99a30130}, 8776 {0x19, 0x04a11020}, 8777 {0x21, 0x0421101f}), 8778 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED, 8779 ALC282_STANDARD_PINS, 8780 {0x12, 0x90a60140}, 8781 {0x19, 0x04a11030}, 8782 {0x21, 0x04211020}), 8783 SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT, 8784 ALC282_STANDARD_PINS, 8785 {0x12, 0x90a609c0}, 8786 {0x18, 0x03a11830}, 8787 {0x19, 0x04a19831}, 8788 {0x1a, 0x0481303f}, 8789 {0x1b, 0x04211020}, 8790 {0x21, 0x0321101f}), 8791 SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT, 8792 ALC282_STANDARD_PINS, 8793 {0x12, 0x90a60940}, 8794 {0x18, 0x03a11830}, 8795 {0x19, 0x04a19831}, 8796 {0x1a, 0x0481303f}, 8797 {0x1b, 0x04211020}, 8798 {0x21, 0x0321101f}), 8799 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 8800 ALC282_STANDARD_PINS, 8801 {0x12, 0x90a60130}, 8802 {0x21, 0x0321101f}), 8803 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 8804 {0x12, 0x90a60160}, 8805 {0x14, 0x90170120}, 8806 {0x21, 0x02211030}), 8807 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 8808 ALC282_STANDARD_PINS, 8809 {0x12, 0x90a60130}, 8810 {0x19, 0x03a11020}, 8811 {0x21, 0x0321101f}), 8812 SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE, 8813 {0x12, 0x90a60130}, 8814 {0x14, 0x90170110}, 8815 {0x19, 0x04a11040}, 8816 {0x21, 0x04211020}), 8817 SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE, 8818 {0x14, 0x90170110}, 8819 {0x19, 0x04a11040}, 8820 {0x1d, 0x40600001}, 8821 {0x21, 0x04211020}), 8822 SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK, 8823 {0x14, 0x90170110}, 8824 {0x19, 0x04a11040}, 8825 {0x21, 0x04211020}), 8826 SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_HEADSET_JACK, 8827 {0x14, 0x90170110}, 8828 {0x17, 0x90170111}, 8829 {0x19, 0x03a11030}, 8830 {0x21, 0x03211020}), 8831 SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK, 8832 {0x17, 0x90170110}, 8833 {0x19, 0x03a11030}, 8834 {0x21, 0x03211020}), 8835 SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK, 8836 {0x17, 0x90170110}, /* 0x231f with RTK I2S AMP */ 8837 {0x19, 0x04a11040}, 8838 {0x21, 0x04211020}), 8839 SND_HDA_PIN_QUIRK(0x10ec0286, 0x1025, "Acer", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE, 8840 {0x12, 0x90a60130}, 8841 {0x17, 0x90170110}, 8842 {0x21, 0x02211020}), 8843 SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, 8844 {0x12, 0x90a60120}, 8845 {0x14, 0x90170110}, 8846 {0x21, 0x0321101f}), 8847 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 8848 ALC290_STANDARD_PINS, 8849 {0x15, 0x04211040}, 8850 {0x18, 0x90170112}, 8851 {0x1a, 0x04a11020}), 8852 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 8853 ALC290_STANDARD_PINS, 8854 {0x15, 0x04211040}, 8855 {0x18, 0x90170110}, 8856 {0x1a, 0x04a11020}), 8857 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 8858 ALC290_STANDARD_PINS, 8859 {0x15, 0x0421101f}, 8860 {0x1a, 0x04a11020}), 8861 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 8862 ALC290_STANDARD_PINS, 8863 {0x15, 0x04211020}, 8864 {0x1a, 0x04a11040}), 8865 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 8866 ALC290_STANDARD_PINS, 8867 {0x14, 0x90170110}, 8868 {0x15, 0x04211020}, 8869 {0x1a, 0x04a11040}), 8870 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 8871 ALC290_STANDARD_PINS, 8872 {0x14, 0x90170110}, 8873 {0x15, 0x04211020}, 8874 {0x1a, 0x04a11020}), 8875 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 8876 ALC290_STANDARD_PINS, 8877 {0x14, 0x90170110}, 8878 {0x15, 0x0421101f}, 8879 {0x1a, 0x04a11020}), 8880 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, 8881 ALC292_STANDARD_PINS, 8882 {0x12, 0x90a60140}, 8883 {0x16, 0x01014020}, 8884 {0x19, 0x01a19030}), 8885 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, 8886 ALC292_STANDARD_PINS, 8887 {0x12, 0x90a60140}, 8888 {0x16, 0x01014020}, 8889 {0x18, 0x02a19031}, 8890 {0x19, 0x01a1903e}), 8891 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, 8892 ALC292_STANDARD_PINS, 8893 {0x12, 0x90a60140}), 8894 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, 8895 ALC292_STANDARD_PINS, 8896 {0x13, 0x90a60140}, 8897 {0x16, 0x21014020}, 8898 {0x19, 0x21a19030}), 8899 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, 8900 ALC292_STANDARD_PINS, 8901 {0x13, 0x90a60140}), 8902 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_HPE, 8903 {0x17, 0x90170110}, 8904 {0x21, 0x04211020}), 8905 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC, 8906 {0x14, 0x90170110}, 8907 {0x1b, 0x90a70130}, 8908 {0x21, 0x04211020}), 8909 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK, 8910 {0x12, 0x90a60130}, 8911 {0x17, 0x90170110}, 8912 {0x21, 0x03211020}), 8913 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK, 8914 {0x12, 0x90a60130}, 8915 {0x17, 0x90170110}, 8916 {0x21, 0x04211020}), 8917 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK, 8918 {0x12, 0x90a60130}, 8919 {0x17, 0x90170110}, 8920 {0x21, 0x03211020}), 8921 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, 8922 {0x12, 0x90a60120}, 8923 {0x17, 0x90170110}, 8924 {0x21, 0x04211030}), 8925 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, 8926 {0x12, 0x90a60130}, 8927 {0x17, 0x90170110}, 8928 {0x21, 0x03211020}), 8929 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, 8930 {0x12, 0x90a60130}, 8931 {0x17, 0x90170110}, 8932 {0x21, 0x03211020}), 8933 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 8934 ALC298_STANDARD_PINS, 8935 {0x17, 0x90170110}), 8936 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 8937 ALC298_STANDARD_PINS, 8938 {0x17, 0x90170140}), 8939 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 8940 ALC298_STANDARD_PINS, 8941 {0x17, 0x90170150}), 8942 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME, 8943 {0x12, 0xb7a60140}, 8944 {0x13, 0xb7a60150}, 8945 {0x17, 0x90170110}, 8946 {0x1a, 0x03011020}, 8947 {0x21, 0x03211030}), 8948 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE, 8949 {0x12, 0xb7a60140}, 8950 {0x17, 0x90170110}, 8951 {0x1a, 0x03a11030}, 8952 {0x21, 0x03211020}), 8953 SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 8954 ALC225_STANDARD_PINS, 8955 {0x12, 0xb7a60130}, 8956 {0x17, 0x90170110}), 8957 SND_HDA_PIN_QUIRK(0x10ec0623, 0x17aa, "Lenovo", ALC283_FIXUP_HEADSET_MIC, 8958 {0x14, 0x01014010}, 8959 {0x17, 0x90170120}, 8960 {0x18, 0x02a11030}, 8961 {0x19, 0x02a1103f}, 8962 {0x21, 0x0221101f}), 8963 {} 8964 }; 8965 8966 /* This is the fallback pin_fixup_tbl for alc269 family, to make the tbl match 8967 * more machines, don't need to match all valid pins, just need to match 8968 * all the pins defined in the tbl. Just because of this reason, it is possible 8969 * that a single machine matches multiple tbls, so there is one limitation: 8970 * at most one tbl is allowed to define for the same vendor and same codec 8971 */ 8972 static const struct snd_hda_pin_quirk alc269_fallback_pin_fixup_tbl[] = { 8973 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1025, "Acer", ALC2XX_FIXUP_HEADSET_MIC, 8974 {0x19, 0x40000000}), 8975 SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 8976 {0x19, 0x40000000}, 8977 {0x1b, 0x40000000}), 8978 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET, 8979 {0x19, 0x40000000}, 8980 {0x1b, 0x40000000}), 8981 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 8982 {0x19, 0x40000000}, 8983 {0x1a, 0x40000000}), 8984 SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_LIMIT_INT_MIC_BOOST, 8985 {0x19, 0x40000000}, 8986 {0x1a, 0x40000000}), 8987 SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC269_FIXUP_DELL1_LIMIT_INT_MIC_BOOST, 8988 {0x19, 0x40000000}, 8989 {0x1a, 0x40000000}), 8990 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC2XX_FIXUP_HEADSET_MIC, 8991 {0x19, 0x40000000}), 8992 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1558, "Clevo", ALC2XX_FIXUP_HEADSET_MIC, 8993 {0x19, 0x40000000}), 8994 {} 8995 }; 8996 8997 static void alc269_fill_coef(struct hda_codec *codec) 8998 { 8999 struct alc_spec *spec = codec->spec; 9000 int val; 9001 9002 if (spec->codec_variant != ALC269_TYPE_ALC269VB) 9003 return; 9004 9005 if ((alc_get_coef0(codec) & 0x00ff) < 0x015) { 9006 alc_write_coef_idx(codec, 0xf, 0x960b); 9007 alc_write_coef_idx(codec, 0xe, 0x8817); 9008 } 9009 9010 if ((alc_get_coef0(codec) & 0x00ff) == 0x016) { 9011 alc_write_coef_idx(codec, 0xf, 0x960b); 9012 alc_write_coef_idx(codec, 0xe, 0x8814); 9013 } 9014 9015 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) { 9016 /* Power up output pin */ 9017 alc_update_coef_idx(codec, 0x04, 0, 1<<11); 9018 } 9019 9020 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) { 9021 val = alc_read_coef_idx(codec, 0xd); 9022 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) { 9023 /* Capless ramp up clock control */ 9024 alc_write_coef_idx(codec, 0xd, val | (1<<10)); 9025 } 9026 val = alc_read_coef_idx(codec, 0x17); 9027 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) { 9028 /* Class D power on reset */ 9029 alc_write_coef_idx(codec, 0x17, val | (1<<7)); 9030 } 9031 } 9032 9033 /* HP */ 9034 alc_update_coef_idx(codec, 0x4, 0, 1<<11); 9035 } 9036 9037 static void alc269_remove(struct hda_codec *codec) 9038 { 9039 struct alc_spec *spec = codec->spec; 9040 9041 if (spec) 9042 hda_component_manager_free(&spec->comps, &comp_master_ops); 9043 9044 snd_hda_gen_remove(codec); 9045 } 9046 9047 /* 9048 */ 9049 static int alc269_probe(struct hda_codec *codec, const struct hda_device_id *id) 9050 { 9051 struct alc_spec *spec; 9052 int err; 9053 9054 err = alc_alloc_spec(codec, 0x0b); 9055 if (err < 0) 9056 return err; 9057 9058 spec = codec->spec; 9059 spec->gen.shared_mic_vref_pin = 0x18; 9060 codec->power_save_node = 0; 9061 spec->en_3kpull_low = true; 9062 9063 spec->shutup = alc_default_shutup; 9064 spec->init_hook = alc_default_init; 9065 9066 switch (codec->core.vendor_id) { 9067 case 0x10ec0269: 9068 spec->codec_variant = ALC269_TYPE_ALC269VA; 9069 switch (alc_get_coef0(codec) & 0x00f0) { 9070 case 0x0010: 9071 if (codec->bus->pci && 9072 codec->bus->pci->subsystem_vendor == 0x1025 && 9073 spec->cdefine.platform_type == 1) 9074 err = alc_codec_rename(codec, "ALC271X"); 9075 spec->codec_variant = ALC269_TYPE_ALC269VB; 9076 break; 9077 case 0x0020: 9078 if (codec->bus->pci && 9079 codec->bus->pci->subsystem_vendor == 0x17aa && 9080 codec->bus->pci->subsystem_device == 0x21f3) 9081 err = alc_codec_rename(codec, "ALC3202"); 9082 spec->codec_variant = ALC269_TYPE_ALC269VC; 9083 break; 9084 case 0x0030: 9085 spec->codec_variant = ALC269_TYPE_ALC269VD; 9086 break; 9087 default: 9088 alc_fix_pll_init(codec, 0x20, 0x04, 15); 9089 } 9090 if (err < 0) 9091 goto error; 9092 spec->shutup = alc269_shutup; 9093 spec->init_hook = alc269_fill_coef; 9094 alc269_fill_coef(codec); 9095 break; 9096 9097 case 0x10ec0280: 9098 case 0x10ec0290: 9099 spec->codec_variant = ALC269_TYPE_ALC280; 9100 break; 9101 case 0x10ec0282: 9102 spec->codec_variant = ALC269_TYPE_ALC282; 9103 spec->shutup = alc282_shutup; 9104 spec->init_hook = alc282_init; 9105 break; 9106 case 0x10ec0233: 9107 case 0x10ec0283: 9108 spec->codec_variant = ALC269_TYPE_ALC283; 9109 spec->shutup = alc283_shutup; 9110 spec->init_hook = alc283_init; 9111 break; 9112 case 0x10ec0284: 9113 case 0x10ec0292: 9114 spec->codec_variant = ALC269_TYPE_ALC284; 9115 break; 9116 case 0x10ec0293: 9117 spec->codec_variant = ALC269_TYPE_ALC293; 9118 break; 9119 case 0x10ec0286: 9120 case 0x10ec0288: 9121 spec->codec_variant = ALC269_TYPE_ALC286; 9122 break; 9123 case 0x10ec0298: 9124 spec->codec_variant = ALC269_TYPE_ALC298; 9125 break; 9126 case 0x10ec0235: 9127 case 0x10ec0255: 9128 spec->codec_variant = ALC269_TYPE_ALC255; 9129 spec->shutup = alc256_shutup; 9130 spec->init_hook = alc256_init; 9131 break; 9132 case 0x10ec0230: 9133 case 0x10ec0236: 9134 case 0x10ec0256: 9135 case 0x19e58326: 9136 spec->codec_variant = ALC269_TYPE_ALC256; 9137 spec->shutup = alc256_shutup; 9138 spec->init_hook = alc256_init; 9139 spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */ 9140 if (codec->core.vendor_id == 0x10ec0236 && 9141 codec->bus->pci && 9142 codec->bus->pci->vendor != PCI_VENDOR_ID_AMD) 9143 spec->en_3kpull_low = false; 9144 break; 9145 case 0x10ec0257: 9146 spec->codec_variant = ALC269_TYPE_ALC257; 9147 spec->shutup = alc256_shutup; 9148 spec->init_hook = alc256_init; 9149 spec->gen.mixer_nid = 0; 9150 spec->en_3kpull_low = false; 9151 break; 9152 case 0x10ec0215: 9153 case 0x10ec0245: 9154 case 0x10ec0285: 9155 case 0x10ec0289: 9156 if (alc_get_coef0(codec) & 0x0010) 9157 spec->codec_variant = ALC269_TYPE_ALC245; 9158 else 9159 spec->codec_variant = ALC269_TYPE_ALC215; 9160 spec->shutup = alc225_shutup; 9161 spec->init_hook = alc225_init; 9162 spec->gen.mixer_nid = 0; 9163 break; 9164 case 0x10ec0225: 9165 case 0x10ec0295: 9166 case 0x10ec0299: 9167 spec->codec_variant = ALC269_TYPE_ALC225; 9168 spec->shutup = alc225_shutup; 9169 spec->init_hook = alc225_init; 9170 spec->gen.mixer_nid = 0; /* no loopback on ALC225, ALC295 and ALC299 */ 9171 break; 9172 case 0x10ec0287: 9173 spec->codec_variant = ALC269_TYPE_ALC287; 9174 spec->shutup = alc225_shutup; 9175 spec->init_hook = alc225_init; 9176 spec->gen.mixer_nid = 0; /* no loopback on ALC287 */ 9177 break; 9178 case 0x10ec0234: 9179 case 0x10ec0274: 9180 case 0x10ec0294: 9181 spec->codec_variant = ALC269_TYPE_ALC294; 9182 spec->gen.mixer_nid = 0; /* ALC2x4 does not have any loopback mixer path */ 9183 alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3)); /* UAJ MIC Vref control by verb */ 9184 spec->init_hook = alc294_init; 9185 break; 9186 case 0x10ec0300: 9187 spec->codec_variant = ALC269_TYPE_ALC300; 9188 spec->gen.mixer_nid = 0; /* no loopback on ALC300 */ 9189 break; 9190 case 0x10ec0222: 9191 case 0x10ec0623: 9192 spec->codec_variant = ALC269_TYPE_ALC623; 9193 spec->shutup = alc222_shutup; 9194 spec->init_hook = alc222_init; 9195 break; 9196 case 0x10ec0700: 9197 case 0x10ec0701: 9198 case 0x10ec0703: 9199 case 0x10ec0711: 9200 spec->codec_variant = ALC269_TYPE_ALC700; 9201 spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */ 9202 alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */ 9203 spec->init_hook = alc294_init; 9204 break; 9205 9206 } 9207 9208 if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) { 9209 spec->has_alc5505_dsp = 1; 9210 spec->init_hook = alc5505_dsp_init; 9211 } 9212 9213 alc_pre_init(codec); 9214 9215 snd_hda_pick_fixup(codec, alc269_fixup_models, 9216 alc269_fixup_tbl, alc269_fixups); 9217 /* FIXME: both TX300 and ROG Strix G17 have the same SSID, and 9218 * the quirk breaks the latter (bko#214101). 9219 * Clear the wrong entry. 9220 */ 9221 if (codec->fixup_id == ALC282_FIXUP_ASUS_TX300 && 9222 codec->core.vendor_id == 0x10ec0294) { 9223 codec_dbg(codec, "Clear wrong fixup for ASUS ROG Strix G17\n"); 9224 codec->fixup_id = HDA_FIXUP_ID_NOT_SET; 9225 } 9226 9227 snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups, true); 9228 snd_hda_pick_pin_fixup(codec, alc269_fallback_pin_fixup_tbl, alc269_fixups, false); 9229 snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl, 9230 alc269_fixups); 9231 9232 /* 9233 * Check whether ACPI describes companion amplifiers that require 9234 * component binding 9235 */ 9236 find_cirrus_companion_amps(codec); 9237 9238 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 9239 9240 alc_auto_parse_customize_define(codec); 9241 9242 if (has_cdefine_beep(codec)) 9243 spec->gen.beep_nid = 0x01; 9244 9245 /* automatic parse from the BIOS config */ 9246 err = alc269_parse_auto_config(codec); 9247 if (err < 0) 9248 goto error; 9249 9250 if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) { 9251 err = set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT); 9252 if (err < 0) 9253 goto error; 9254 } 9255 9256 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 9257 9258 return 0; 9259 9260 error: 9261 alc269_remove(codec); 9262 return err; 9263 } 9264 9265 static const struct hda_codec_ops alc269_codec_ops = { 9266 .probe = alc269_probe, 9267 .remove = alc269_remove, 9268 .build_controls = alc_build_controls, 9269 .build_pcms = snd_hda_gen_build_pcms, 9270 .init = alc_init, 9271 .unsol_event = snd_hda_jack_unsol_event, 9272 .suspend = alc269_suspend, 9273 .resume = alc269_resume, 9274 .check_power_status = snd_hda_gen_check_power_status, 9275 .stream_pm = snd_hda_gen_stream_pm, 9276 }; 9277 9278 /* 9279 * driver entries 9280 */ 9281 static const struct hda_device_id snd_hda_id_alc269[] = { 9282 HDA_CODEC_ID(0x10ec0215, "ALC215"), 9283 HDA_CODEC_ID(0x10ec0221, "ALC221"), 9284 HDA_CODEC_ID(0x10ec0222, "ALC222"), 9285 HDA_CODEC_ID(0x10ec0225, "ALC225"), 9286 HDA_CODEC_ID(0x10ec0230, "ALC236"), 9287 HDA_CODEC_ID(0x10ec0231, "ALC231"), 9288 HDA_CODEC_ID(0x10ec0233, "ALC233"), 9289 HDA_CODEC_ID(0x10ec0234, "ALC234"), 9290 HDA_CODEC_ID(0x10ec0235, "ALC233"), 9291 HDA_CODEC_ID(0x10ec0236, "ALC236"), 9292 HDA_CODEC_ID(0x10ec0245, "ALC245"), 9293 HDA_CODEC_ID(0x10ec0255, "ALC255"), 9294 HDA_CODEC_ID(0x10ec0256, "ALC256"), 9295 HDA_CODEC_ID(0x10ec0257, "ALC257"), 9296 HDA_CODEC_ID(0x10ec0269, "ALC269"), 9297 HDA_CODEC_ID(0x10ec0270, "ALC270"), 9298 HDA_CODEC_ID(0x10ec0274, "ALC274"), 9299 HDA_CODEC_ID(0x10ec0275, "ALC275"), 9300 HDA_CODEC_ID(0x10ec0276, "ALC276"), 9301 HDA_CODEC_ID(0x10ec0280, "ALC280"), 9302 HDA_CODEC_ID(0x10ec0282, "ALC282"), 9303 HDA_CODEC_ID(0x10ec0283, "ALC283"), 9304 HDA_CODEC_ID(0x10ec0284, "ALC284"), 9305 HDA_CODEC_ID(0x10ec0285, "ALC285"), 9306 HDA_CODEC_ID(0x10ec0286, "ALC286"), 9307 HDA_CODEC_ID(0x10ec0287, "ALC287"), 9308 HDA_CODEC_ID(0x10ec0288, "ALC288"), 9309 HDA_CODEC_ID(0x10ec0289, "ALC289"), 9310 HDA_CODEC_ID(0x10ec0290, "ALC290"), 9311 HDA_CODEC_ID(0x10ec0292, "ALC292"), 9312 HDA_CODEC_ID(0x10ec0293, "ALC293"), 9313 HDA_CODEC_ID(0x10ec0294, "ALC294"), 9314 HDA_CODEC_ID(0x10ec0295, "ALC295"), 9315 HDA_CODEC_ID(0x10ec0298, "ALC298"), 9316 HDA_CODEC_ID(0x10ec0299, "ALC299"), 9317 HDA_CODEC_ID(0x10ec0300, "ALC300"), 9318 HDA_CODEC_ID(0x10ec0623, "ALC623"), 9319 HDA_CODEC_ID(0x10ec0700, "ALC700"), 9320 HDA_CODEC_ID(0x10ec0701, "ALC701"), 9321 HDA_CODEC_ID(0x10ec0703, "ALC703"), 9322 HDA_CODEC_ID(0x10ec0711, "ALC711"), 9323 HDA_CODEC_ID(0x19e58326, "HW8326"), 9324 {} /* terminator */ 9325 }; 9326 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_alc269); 9327 9328 MODULE_LICENSE("GPL"); 9329 MODULE_DESCRIPTION("Realtek ALC269 and compatible HD-audio codecs"); 9330 MODULE_IMPORT_NS("SND_HDA_CODEC_REALTEK"); 9331 MODULE_IMPORT_NS("SND_HDA_SCODEC_COMPONENT"); 9332 9333 static struct hda_codec_driver alc269_driver = { 9334 .id = snd_hda_id_alc269, 9335 .ops = &alc269_codec_ops, 9336 }; 9337 9338 module_hda_codec_driver(alc269_driver); 9339