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