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