1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Universal Interface for Intel High Definition Audio Codec 4 * 5 * HD audio interface patch for Realtek ALC codecs 6 * 7 * Copyright (c) 2004 Kailang Yang <[email protected]> 8 * PeiSen Hou <[email protected]> 9 * Takashi Iwai <[email protected]> 10 * Jonathan Woithe <[email protected]> 11 */ 12 13 #include <linux/acpi.h> 14 #include <linux/cleanup.h> 15 #include <linux/init.h> 16 #include <linux/delay.h> 17 #include <linux/slab.h> 18 #include <linux/pci.h> 19 #include <linux/dmi.h> 20 #include <linux/module.h> 21 #include <linux/i2c.h> 22 #include <linux/input.h> 23 #include <linux/leds.h> 24 #include <linux/ctype.h> 25 #include <linux/spi/spi.h> 26 #include <sound/core.h> 27 #include <sound/jack.h> 28 #include <sound/hda_codec.h> 29 #include "hda_local.h" 30 #include "hda_auto_parser.h" 31 #include "hda_jack.h" 32 #include "hda_generic.h" 33 #include "hda_component.h" 34 35 /* keep halting ALC5505 DSP, for power saving */ 36 #define HALT_REALTEK_ALC5505 37 38 /* extra amp-initialization sequence types */ 39 enum { 40 ALC_INIT_UNDEFINED, 41 ALC_INIT_NONE, 42 ALC_INIT_DEFAULT, 43 }; 44 45 enum { 46 ALC_HEADSET_MODE_UNKNOWN, 47 ALC_HEADSET_MODE_UNPLUGGED, 48 ALC_HEADSET_MODE_HEADSET, 49 ALC_HEADSET_MODE_MIC, 50 ALC_HEADSET_MODE_HEADPHONE, 51 }; 52 53 enum { 54 ALC_HEADSET_TYPE_UNKNOWN, 55 ALC_HEADSET_TYPE_CTIA, 56 ALC_HEADSET_TYPE_OMTP, 57 }; 58 59 enum { 60 ALC_KEY_MICMUTE_INDEX, 61 }; 62 63 struct alc_customize_define { 64 unsigned int sku_cfg; 65 unsigned char port_connectivity; 66 unsigned char check_sum; 67 unsigned char customization; 68 unsigned char external_amp; 69 unsigned int enable_pcbeep:1; 70 unsigned int platform_type:1; 71 unsigned int swap:1; 72 unsigned int override:1; 73 unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */ 74 }; 75 76 struct alc_coef_led { 77 unsigned int idx; 78 unsigned int mask; 79 unsigned int on; 80 unsigned int off; 81 }; 82 83 struct alc_spec { 84 struct hda_gen_spec gen; /* must be at head */ 85 86 /* codec parameterization */ 87 struct alc_customize_define cdefine; 88 unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */ 89 90 /* GPIO bits */ 91 unsigned int gpio_mask; 92 unsigned int gpio_dir; 93 unsigned int gpio_data; 94 bool gpio_write_delay; /* add a delay before writing gpio_data */ 95 96 /* mute LED for HP laptops, see vref_mute_led_set() */ 97 int mute_led_polarity; 98 int micmute_led_polarity; 99 hda_nid_t mute_led_nid; 100 hda_nid_t cap_mute_led_nid; 101 102 unsigned int gpio_mute_led_mask; 103 unsigned int gpio_mic_led_mask; 104 struct alc_coef_led mute_led_coef; 105 struct alc_coef_led mic_led_coef; 106 struct mutex coef_mutex; 107 108 hda_nid_t headset_mic_pin; 109 hda_nid_t headphone_mic_pin; 110 int current_headset_mode; 111 int current_headset_type; 112 113 /* hooks */ 114 void (*init_hook)(struct hda_codec *codec); 115 void (*power_hook)(struct hda_codec *codec); 116 void (*shutup)(struct hda_codec *codec); 117 118 int init_amp; 119 int codec_variant; /* flag for other variants */ 120 unsigned int has_alc5505_dsp:1; 121 unsigned int no_depop_delay:1; 122 unsigned int done_hp_init:1; 123 unsigned int no_shutup_pins:1; 124 unsigned int ultra_low_power:1; 125 unsigned int has_hs_key:1; 126 unsigned int no_internal_mic_pin:1; 127 unsigned int en_3kpull_low:1; 128 int num_speaker_amps; 129 130 /* for PLL fix */ 131 hda_nid_t pll_nid; 132 unsigned int pll_coef_idx, pll_coef_bit; 133 unsigned int coef0; 134 struct input_dev *kb_dev; 135 u8 alc_mute_keycode_map[1]; 136 137 /* component binding */ 138 struct hda_component_parent comps; 139 }; 140 141 /* 142 * COEF access helper functions 143 */ 144 145 static void coef_mutex_lock(struct hda_codec *codec) 146 { 147 struct alc_spec *spec = codec->spec; 148 149 snd_hda_power_up_pm(codec); 150 mutex_lock(&spec->coef_mutex); 151 } 152 153 static void coef_mutex_unlock(struct hda_codec *codec) 154 { 155 struct alc_spec *spec = codec->spec; 156 157 mutex_unlock(&spec->coef_mutex); 158 snd_hda_power_down_pm(codec); 159 } 160 161 static int __alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid, 162 unsigned int coef_idx) 163 { 164 unsigned int val; 165 166 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx); 167 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0); 168 return val; 169 } 170 171 static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid, 172 unsigned int coef_idx) 173 { 174 unsigned int val; 175 176 coef_mutex_lock(codec); 177 val = __alc_read_coefex_idx(codec, nid, coef_idx); 178 coef_mutex_unlock(codec); 179 return val; 180 } 181 182 #define alc_read_coef_idx(codec, coef_idx) \ 183 alc_read_coefex_idx(codec, 0x20, coef_idx) 184 185 static void __alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid, 186 unsigned int coef_idx, unsigned int coef_val) 187 { 188 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx); 189 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val); 190 } 191 192 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid, 193 unsigned int coef_idx, unsigned int coef_val) 194 { 195 coef_mutex_lock(codec); 196 __alc_write_coefex_idx(codec, nid, coef_idx, coef_val); 197 coef_mutex_unlock(codec); 198 } 199 200 #define alc_write_coef_idx(codec, coef_idx, coef_val) \ 201 alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val) 202 203 static void __alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid, 204 unsigned int coef_idx, unsigned int mask, 205 unsigned int bits_set) 206 { 207 unsigned int val = __alc_read_coefex_idx(codec, nid, coef_idx); 208 209 if (val != -1) 210 __alc_write_coefex_idx(codec, nid, coef_idx, 211 (val & ~mask) | bits_set); 212 } 213 214 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid, 215 unsigned int coef_idx, unsigned int mask, 216 unsigned int bits_set) 217 { 218 coef_mutex_lock(codec); 219 __alc_update_coefex_idx(codec, nid, coef_idx, mask, bits_set); 220 coef_mutex_unlock(codec); 221 } 222 223 #define alc_update_coef_idx(codec, coef_idx, mask, bits_set) \ 224 alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set) 225 226 /* a special bypass for COEF 0; read the cached value at the second time */ 227 static unsigned int alc_get_coef0(struct hda_codec *codec) 228 { 229 struct alc_spec *spec = codec->spec; 230 231 if (!spec->coef0) 232 spec->coef0 = alc_read_coef_idx(codec, 0); 233 return spec->coef0; 234 } 235 236 /* coef writes/updates batch */ 237 struct coef_fw { 238 unsigned char nid; 239 unsigned char idx; 240 unsigned short mask; 241 unsigned short val; 242 }; 243 244 #define UPDATE_COEFEX(_nid, _idx, _mask, _val) \ 245 { .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) } 246 #define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val) 247 #define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val) 248 #define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val) 249 250 static void alc_process_coef_fw(struct hda_codec *codec, 251 const struct coef_fw *fw) 252 { 253 coef_mutex_lock(codec); 254 for (; fw->nid; fw++) { 255 if (fw->mask == (unsigned short)-1) 256 __alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val); 257 else 258 __alc_update_coefex_idx(codec, fw->nid, fw->idx, 259 fw->mask, fw->val); 260 } 261 coef_mutex_unlock(codec); 262 } 263 264 /* 265 * GPIO setup tables, used in initialization 266 */ 267 268 /* Enable GPIO mask and set output */ 269 static void alc_setup_gpio(struct hda_codec *codec, unsigned int mask) 270 { 271 struct alc_spec *spec = codec->spec; 272 273 spec->gpio_mask |= mask; 274 spec->gpio_dir |= mask; 275 spec->gpio_data |= mask; 276 } 277 278 static void alc_write_gpio_data(struct hda_codec *codec) 279 { 280 struct alc_spec *spec = codec->spec; 281 282 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 283 spec->gpio_data); 284 } 285 286 static void alc_update_gpio_data(struct hda_codec *codec, unsigned int mask, 287 bool on) 288 { 289 struct alc_spec *spec = codec->spec; 290 unsigned int oldval = spec->gpio_data; 291 292 if (on) 293 spec->gpio_data |= mask; 294 else 295 spec->gpio_data &= ~mask; 296 if (oldval != spec->gpio_data) 297 alc_write_gpio_data(codec); 298 } 299 300 static void alc_write_gpio(struct hda_codec *codec) 301 { 302 struct alc_spec *spec = codec->spec; 303 304 if (!spec->gpio_mask) 305 return; 306 307 snd_hda_codec_write(codec, codec->core.afg, 0, 308 AC_VERB_SET_GPIO_MASK, spec->gpio_mask); 309 snd_hda_codec_write(codec, codec->core.afg, 0, 310 AC_VERB_SET_GPIO_DIRECTION, spec->gpio_dir); 311 if (spec->gpio_write_delay) 312 msleep(1); 313 alc_write_gpio_data(codec); 314 } 315 316 static void alc_fixup_gpio(struct hda_codec *codec, int action, 317 unsigned int mask) 318 { 319 if (action == HDA_FIXUP_ACT_PRE_PROBE) 320 alc_setup_gpio(codec, mask); 321 } 322 323 static void alc_fixup_gpio1(struct hda_codec *codec, 324 const struct hda_fixup *fix, int action) 325 { 326 alc_fixup_gpio(codec, action, 0x01); 327 } 328 329 static void alc_fixup_gpio2(struct hda_codec *codec, 330 const struct hda_fixup *fix, int action) 331 { 332 alc_fixup_gpio(codec, action, 0x02); 333 } 334 335 static void alc_fixup_gpio3(struct hda_codec *codec, 336 const struct hda_fixup *fix, int action) 337 { 338 alc_fixup_gpio(codec, action, 0x03); 339 } 340 341 static void alc_fixup_gpio4(struct hda_codec *codec, 342 const struct hda_fixup *fix, int action) 343 { 344 alc_fixup_gpio(codec, action, 0x04); 345 } 346 347 static void alc_fixup_micmute_led(struct hda_codec *codec, 348 const struct hda_fixup *fix, int action) 349 { 350 if (action == HDA_FIXUP_ACT_PRE_PROBE) 351 snd_hda_gen_add_micmute_led_cdev(codec, NULL); 352 } 353 354 /* 355 * Fix hardware PLL issue 356 * On some codecs, the analog PLL gating control must be off while 357 * the default value is 1. 358 */ 359 static void alc_fix_pll(struct hda_codec *codec) 360 { 361 struct alc_spec *spec = codec->spec; 362 363 if (spec->pll_nid) 364 alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx, 365 1 << spec->pll_coef_bit, 0); 366 } 367 368 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid, 369 unsigned int coef_idx, unsigned int coef_bit) 370 { 371 struct alc_spec *spec = codec->spec; 372 spec->pll_nid = nid; 373 spec->pll_coef_idx = coef_idx; 374 spec->pll_coef_bit = coef_bit; 375 alc_fix_pll(codec); 376 } 377 378 /* update the master volume per volume-knob's unsol event */ 379 static void alc_update_knob_master(struct hda_codec *codec, 380 struct hda_jack_callback *jack) 381 { 382 unsigned int val; 383 struct snd_kcontrol *kctl; 384 struct snd_ctl_elem_value *uctl; 385 386 kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume"); 387 if (!kctl) 388 return; 389 uctl = kzalloc(sizeof(*uctl), GFP_KERNEL); 390 if (!uctl) 391 return; 392 val = snd_hda_codec_read(codec, jack->nid, 0, 393 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0); 394 val &= HDA_AMP_VOLMASK; 395 uctl->value.integer.value[0] = val; 396 uctl->value.integer.value[1] = val; 397 kctl->put(kctl, uctl); 398 kfree(uctl); 399 } 400 401 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res) 402 { 403 /* For some reason, the res given from ALC880 is broken. 404 Here we adjust it properly. */ 405 snd_hda_jack_unsol_event(codec, res >> 2); 406 } 407 408 /* Change EAPD to verb control */ 409 static void alc_fill_eapd_coef(struct hda_codec *codec) 410 { 411 int coef; 412 413 coef = alc_get_coef0(codec); 414 415 switch (codec->core.vendor_id) { 416 case 0x10ec0262: 417 alc_update_coef_idx(codec, 0x7, 0, 1<<5); 418 break; 419 case 0x10ec0267: 420 case 0x10ec0268: 421 alc_update_coef_idx(codec, 0x7, 0, 1<<13); 422 break; 423 case 0x10ec0269: 424 if ((coef & 0x00f0) == 0x0010) 425 alc_update_coef_idx(codec, 0xd, 0, 1<<14); 426 if ((coef & 0x00f0) == 0x0020) 427 alc_update_coef_idx(codec, 0x4, 1<<15, 0); 428 if ((coef & 0x00f0) == 0x0030) 429 alc_update_coef_idx(codec, 0x10, 1<<9, 0); 430 break; 431 case 0x10ec0280: 432 case 0x10ec0284: 433 case 0x10ec0290: 434 case 0x10ec0292: 435 alc_update_coef_idx(codec, 0x4, 1<<15, 0); 436 break; 437 case 0x10ec0225: 438 case 0x10ec0295: 439 case 0x10ec0299: 440 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000); 441 fallthrough; 442 case 0x10ec0215: 443 case 0x10ec0285: 444 case 0x10ec0289: 445 alc_update_coef_idx(codec, 0x36, 1<<13, 0); 446 fallthrough; 447 case 0x10ec0230: 448 case 0x10ec0233: 449 case 0x10ec0235: 450 case 0x10ec0236: 451 case 0x10ec0245: 452 case 0x10ec0255: 453 case 0x10ec0256: 454 case 0x19e58326: 455 case 0x10ec0257: 456 case 0x10ec0282: 457 case 0x10ec0283: 458 case 0x10ec0286: 459 case 0x10ec0288: 460 case 0x10ec0298: 461 case 0x10ec0300: 462 alc_update_coef_idx(codec, 0x10, 1<<9, 0); 463 break; 464 case 0x10ec0275: 465 alc_update_coef_idx(codec, 0xe, 0, 1<<0); 466 break; 467 case 0x10ec0287: 468 alc_update_coef_idx(codec, 0x10, 1<<9, 0); 469 alc_write_coef_idx(codec, 0x8, 0x4ab7); 470 break; 471 case 0x10ec0293: 472 alc_update_coef_idx(codec, 0xa, 1<<13, 0); 473 break; 474 case 0x10ec0234: 475 case 0x10ec0274: 476 alc_write_coef_idx(codec, 0x6e, 0x0c25); 477 fallthrough; 478 case 0x10ec0294: 479 case 0x10ec0700: 480 case 0x10ec0701: 481 case 0x10ec0703: 482 case 0x10ec0711: 483 alc_update_coef_idx(codec, 0x10, 1<<15, 0); 484 break; 485 case 0x10ec0662: 486 if ((coef & 0x00f0) == 0x0030) 487 alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */ 488 break; 489 case 0x10ec0272: 490 case 0x10ec0273: 491 case 0x10ec0663: 492 case 0x10ec0665: 493 case 0x10ec0670: 494 case 0x10ec0671: 495 case 0x10ec0672: 496 alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */ 497 break; 498 case 0x10ec0222: 499 case 0x10ec0623: 500 alc_update_coef_idx(codec, 0x19, 1<<13, 0); 501 break; 502 case 0x10ec0668: 503 alc_update_coef_idx(codec, 0x7, 3<<13, 0); 504 break; 505 case 0x10ec0867: 506 alc_update_coef_idx(codec, 0x4, 1<<10, 0); 507 break; 508 case 0x10ec0888: 509 if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030) 510 alc_update_coef_idx(codec, 0x7, 1<<5, 0); 511 break; 512 case 0x10ec0892: 513 case 0x10ec0897: 514 alc_update_coef_idx(codec, 0x7, 1<<5, 0); 515 break; 516 case 0x10ec0899: 517 case 0x10ec0900: 518 case 0x10ec0b00: 519 case 0x10ec1168: 520 case 0x10ec1220: 521 alc_update_coef_idx(codec, 0x7, 1<<1, 0); 522 break; 523 } 524 } 525 526 /* additional initialization for ALC888 variants */ 527 static void alc888_coef_init(struct hda_codec *codec) 528 { 529 switch (alc_get_coef0(codec) & 0x00f0) { 530 /* alc888-VA */ 531 case 0x00: 532 /* alc888-VB */ 533 case 0x10: 534 alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */ 535 break; 536 } 537 } 538 539 /* turn on/off EAPD control (only if available) */ 540 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on) 541 { 542 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN) 543 return; 544 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD) 545 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE, 546 on ? 2 : 0); 547 } 548 549 /* turn on/off EAPD controls of the codec */ 550 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on) 551 { 552 /* We currently only handle front, HP */ 553 static const hda_nid_t pins[] = { 554 0x0f, 0x10, 0x14, 0x15, 0x17, 0 555 }; 556 const hda_nid_t *p; 557 for (p = pins; *p; p++) 558 set_eapd(codec, *p, on); 559 } 560 561 static int find_ext_mic_pin(struct hda_codec *codec); 562 563 static void alc_headset_mic_no_shutup(struct hda_codec *codec) 564 { 565 const struct hda_pincfg *pin; 566 int mic_pin = find_ext_mic_pin(codec); 567 int i; 568 569 /* don't shut up pins when unloading the driver; otherwise it breaks 570 * the default pin setup at the next load of the driver 571 */ 572 if (codec->bus->shutdown) 573 return; 574 575 snd_array_for_each(&codec->init_pins, i, pin) { 576 /* use read here for syncing after issuing each verb */ 577 if (pin->nid != mic_pin) 578 snd_hda_codec_read(codec, pin->nid, 0, 579 AC_VERB_SET_PIN_WIDGET_CONTROL, 0); 580 } 581 582 codec->pins_shutup = 1; 583 } 584 585 static void alc_shutup_pins(struct hda_codec *codec) 586 { 587 struct alc_spec *spec = codec->spec; 588 589 switch (codec->core.vendor_id) { 590 case 0x10ec0236: 591 case 0x10ec0256: 592 case 0x10ec0257: 593 case 0x19e58326: 594 case 0x10ec0283: 595 case 0x10ec0285: 596 case 0x10ec0286: 597 case 0x10ec0287: 598 case 0x10ec0288: 599 case 0x10ec0295: 600 case 0x10ec0298: 601 alc_headset_mic_no_shutup(codec); 602 break; 603 default: 604 if (!spec->no_shutup_pins) 605 snd_hda_shutup_pins(codec); 606 break; 607 } 608 } 609 610 /* generic shutup callback; 611 * just turning off EAPD and a little pause for avoiding pop-noise 612 */ 613 static void alc_eapd_shutup(struct hda_codec *codec) 614 { 615 struct alc_spec *spec = codec->spec; 616 617 alc_auto_setup_eapd(codec, false); 618 if (!spec->no_depop_delay) 619 msleep(200); 620 alc_shutup_pins(codec); 621 } 622 623 /* generic EAPD initialization */ 624 static void alc_auto_init_amp(struct hda_codec *codec, int type) 625 { 626 alc_auto_setup_eapd(codec, true); 627 alc_write_gpio(codec); 628 switch (type) { 629 case ALC_INIT_DEFAULT: 630 switch (codec->core.vendor_id) { 631 case 0x10ec0260: 632 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010); 633 break; 634 case 0x10ec0880: 635 case 0x10ec0882: 636 case 0x10ec0883: 637 case 0x10ec0885: 638 alc_update_coef_idx(codec, 7, 0, 0x2030); 639 break; 640 case 0x10ec0888: 641 alc888_coef_init(codec); 642 break; 643 } 644 break; 645 } 646 } 647 648 /* get a primary headphone pin if available */ 649 static hda_nid_t alc_get_hp_pin(struct alc_spec *spec) 650 { 651 if (spec->gen.autocfg.hp_pins[0]) 652 return spec->gen.autocfg.hp_pins[0]; 653 if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT) 654 return spec->gen.autocfg.line_out_pins[0]; 655 return 0; 656 } 657 658 /* 659 * Realtek SSID verification 660 */ 661 662 /* Could be any non-zero and even value. When used as fixup, tells 663 * the driver to ignore any present sku defines. 664 */ 665 #define ALC_FIXUP_SKU_IGNORE (2) 666 667 static void alc_fixup_sku_ignore(struct hda_codec *codec, 668 const struct hda_fixup *fix, int action) 669 { 670 struct alc_spec *spec = codec->spec; 671 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 672 spec->cdefine.fixup = 1; 673 spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE; 674 } 675 } 676 677 static void alc_fixup_no_depop_delay(struct hda_codec *codec, 678 const struct hda_fixup *fix, int action) 679 { 680 struct alc_spec *spec = codec->spec; 681 682 if (action == HDA_FIXUP_ACT_PROBE) { 683 spec->no_depop_delay = 1; 684 codec->depop_delay = 0; 685 } 686 } 687 688 static int alc_auto_parse_customize_define(struct hda_codec *codec) 689 { 690 unsigned int ass, tmp, i; 691 unsigned nid = 0; 692 struct alc_spec *spec = codec->spec; 693 694 spec->cdefine.enable_pcbeep = 1; /* assume always enabled */ 695 696 if (spec->cdefine.fixup) { 697 ass = spec->cdefine.sku_cfg; 698 if (ass == ALC_FIXUP_SKU_IGNORE) 699 return -1; 700 goto do_sku; 701 } 702 703 if (!codec->bus->pci) 704 return -1; 705 ass = codec->core.subsystem_id & 0xffff; 706 if (ass != codec->bus->pci->subsystem_device && (ass & 1)) 707 goto do_sku; 708 709 nid = 0x1d; 710 if (codec->core.vendor_id == 0x10ec0260) 711 nid = 0x17; 712 ass = snd_hda_codec_get_pincfg(codec, nid); 713 714 if (!(ass & 1)) { 715 codec_info(codec, "%s: SKU not ready 0x%08x\n", 716 codec->core.chip_name, ass); 717 return -1; 718 } 719 720 /* check sum */ 721 tmp = 0; 722 for (i = 1; i < 16; i++) { 723 if ((ass >> i) & 1) 724 tmp++; 725 } 726 if (((ass >> 16) & 0xf) != tmp) 727 return -1; 728 729 spec->cdefine.port_connectivity = ass >> 30; 730 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20; 731 spec->cdefine.check_sum = (ass >> 16) & 0xf; 732 spec->cdefine.customization = ass >> 8; 733 do_sku: 734 spec->cdefine.sku_cfg = ass; 735 spec->cdefine.external_amp = (ass & 0x38) >> 3; 736 spec->cdefine.platform_type = (ass & 0x4) >> 2; 737 spec->cdefine.swap = (ass & 0x2) >> 1; 738 spec->cdefine.override = ass & 0x1; 739 740 codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n", 741 nid, spec->cdefine.sku_cfg); 742 codec_dbg(codec, "SKU: port_connectivity=0x%x\n", 743 spec->cdefine.port_connectivity); 744 codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep); 745 codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum); 746 codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization); 747 codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp); 748 codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type); 749 codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap); 750 codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override); 751 752 return 0; 753 } 754 755 /* return the position of NID in the list, or -1 if not found */ 756 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums) 757 { 758 int i; 759 for (i = 0; i < nums; i++) 760 if (list[i] == nid) 761 return i; 762 return -1; 763 } 764 /* return true if the given NID is found in the list */ 765 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums) 766 { 767 return find_idx_in_nid_list(nid, list, nums) >= 0; 768 } 769 770 /* check subsystem ID and set up device-specific initialization; 771 * return 1 if initialized, 0 if invalid SSID 772 */ 773 /* 32-bit subsystem ID for BIOS loading in HD Audio codec. 774 * 31 ~ 16 : Manufacture ID 775 * 15 ~ 8 : SKU ID 776 * 7 ~ 0 : Assembly ID 777 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36 778 */ 779 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports) 780 { 781 unsigned int ass, tmp, i; 782 unsigned nid; 783 struct alc_spec *spec = codec->spec; 784 785 if (spec->cdefine.fixup) { 786 ass = spec->cdefine.sku_cfg; 787 if (ass == ALC_FIXUP_SKU_IGNORE) 788 return 0; 789 goto do_sku; 790 } 791 792 ass = codec->core.subsystem_id & 0xffff; 793 if (codec->bus->pci && 794 ass != codec->bus->pci->subsystem_device && (ass & 1)) 795 goto do_sku; 796 797 /* invalid SSID, check the special NID pin defcfg instead */ 798 /* 799 * 31~30 : port connectivity 800 * 29~21 : reserve 801 * 20 : PCBEEP input 802 * 19~16 : Check sum (15:1) 803 * 15~1 : Custom 804 * 0 : override 805 */ 806 nid = 0x1d; 807 if (codec->core.vendor_id == 0x10ec0260) 808 nid = 0x17; 809 ass = snd_hda_codec_get_pincfg(codec, nid); 810 codec_dbg(codec, 811 "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n", 812 ass, nid); 813 if (!(ass & 1)) 814 return 0; 815 if ((ass >> 30) != 1) /* no physical connection */ 816 return 0; 817 818 /* check sum */ 819 tmp = 0; 820 for (i = 1; i < 16; i++) { 821 if ((ass >> i) & 1) 822 tmp++; 823 } 824 if (((ass >> 16) & 0xf) != tmp) 825 return 0; 826 do_sku: 827 codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n", 828 ass & 0xffff, codec->core.vendor_id); 829 /* 830 * 0 : override 831 * 1 : Swap Jack 832 * 2 : 0 --> Desktop, 1 --> Laptop 833 * 3~5 : External Amplifier control 834 * 7~6 : Reserved 835 */ 836 tmp = (ass & 0x38) >> 3; /* external Amp control */ 837 if (spec->init_amp == ALC_INIT_UNDEFINED) { 838 switch (tmp) { 839 case 1: 840 alc_setup_gpio(codec, 0x01); 841 break; 842 case 3: 843 alc_setup_gpio(codec, 0x02); 844 break; 845 case 7: 846 alc_setup_gpio(codec, 0x04); 847 break; 848 case 5: 849 default: 850 spec->init_amp = ALC_INIT_DEFAULT; 851 break; 852 } 853 } 854 855 /* is laptop or Desktop and enable the function "Mute internal speaker 856 * when the external headphone out jack is plugged" 857 */ 858 if (!(ass & 0x8000)) 859 return 1; 860 /* 861 * 10~8 : Jack location 862 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered 863 * 14~13: Resvered 864 * 15 : 1 --> enable the function "Mute internal speaker 865 * when the external headphone out jack is plugged" 866 */ 867 if (!alc_get_hp_pin(spec)) { 868 hda_nid_t nid; 869 tmp = (ass >> 11) & 0x3; /* HP to chassis */ 870 nid = ports[tmp]; 871 if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins, 872 spec->gen.autocfg.line_outs)) 873 return 1; 874 spec->gen.autocfg.hp_pins[0] = nid; 875 } 876 return 1; 877 } 878 879 /* Check the validity of ALC subsystem-id 880 * ports contains an array of 4 pin NIDs for port-A, E, D and I */ 881 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports) 882 { 883 if (!alc_subsystem_id(codec, ports)) { 884 struct alc_spec *spec = codec->spec; 885 if (spec->init_amp == ALC_INIT_UNDEFINED) { 886 codec_dbg(codec, 887 "realtek: Enable default setup for auto mode as fallback\n"); 888 spec->init_amp = ALC_INIT_DEFAULT; 889 } 890 } 891 } 892 893 /* inverted digital-mic */ 894 static void alc_fixup_inv_dmic(struct hda_codec *codec, 895 const struct hda_fixup *fix, int action) 896 { 897 struct alc_spec *spec = codec->spec; 898 899 spec->gen.inv_dmic_split = 1; 900 } 901 902 903 static int alc_build_controls(struct hda_codec *codec) 904 { 905 int err; 906 907 err = snd_hda_gen_build_controls(codec); 908 if (err < 0) 909 return err; 910 911 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD); 912 return 0; 913 } 914 915 916 /* 917 * Common callbacks 918 */ 919 920 static void alc_pre_init(struct hda_codec *codec) 921 { 922 alc_fill_eapd_coef(codec); 923 } 924 925 #define is_s3_resume(codec) \ 926 ((codec)->core.dev.power.power_state.event == PM_EVENT_RESUME) 927 #define is_s4_resume(codec) \ 928 ((codec)->core.dev.power.power_state.event == PM_EVENT_RESTORE) 929 #define is_s4_suspend(codec) \ 930 ((codec)->core.dev.power.power_state.event == PM_EVENT_FREEZE) 931 932 static int alc_init(struct hda_codec *codec) 933 { 934 struct alc_spec *spec = codec->spec; 935 936 /* hibernation resume needs the full chip initialization */ 937 if (is_s4_resume(codec)) 938 alc_pre_init(codec); 939 940 if (spec->init_hook) 941 spec->init_hook(codec); 942 943 spec->gen.skip_verbs = 1; /* applied in below */ 944 snd_hda_gen_init(codec); 945 alc_fix_pll(codec); 946 alc_auto_init_amp(codec, spec->init_amp); 947 snd_hda_apply_verbs(codec); /* apply verbs here after own init */ 948 949 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT); 950 951 return 0; 952 } 953 954 /* forward declaration */ 955 static const struct component_master_ops comp_master_ops; 956 957 static void alc_free(struct hda_codec *codec) 958 { 959 struct alc_spec *spec = codec->spec; 960 961 if (spec) 962 hda_component_manager_free(&spec->comps, &comp_master_ops); 963 964 snd_hda_gen_free(codec); 965 } 966 967 static inline void alc_shutup(struct hda_codec *codec) 968 { 969 struct alc_spec *spec = codec->spec; 970 971 if (!snd_hda_get_bool_hint(codec, "shutup")) 972 return; /* disabled explicitly by hints */ 973 974 if (spec && spec->shutup) 975 spec->shutup(codec); 976 else 977 alc_shutup_pins(codec); 978 } 979 980 static void alc_power_eapd(struct hda_codec *codec) 981 { 982 alc_auto_setup_eapd(codec, false); 983 } 984 985 static int alc_suspend(struct hda_codec *codec) 986 { 987 struct alc_spec *spec = codec->spec; 988 alc_shutup(codec); 989 if (spec && spec->power_hook) 990 spec->power_hook(codec); 991 return 0; 992 } 993 994 static int alc_resume(struct hda_codec *codec) 995 { 996 struct alc_spec *spec = codec->spec; 997 998 if (!spec->no_depop_delay) 999 msleep(150); /* to avoid pop noise */ 1000 codec->patch_ops.init(codec); 1001 snd_hda_regmap_sync(codec); 1002 hda_call_check_power_status(codec, 0x01); 1003 return 0; 1004 } 1005 1006 /* 1007 */ 1008 static const struct hda_codec_ops alc_patch_ops = { 1009 .build_controls = alc_build_controls, 1010 .build_pcms = snd_hda_gen_build_pcms, 1011 .init = alc_init, 1012 .free = alc_free, 1013 .unsol_event = snd_hda_jack_unsol_event, 1014 .resume = alc_resume, 1015 .suspend = alc_suspend, 1016 .check_power_status = snd_hda_gen_check_power_status, 1017 }; 1018 1019 1020 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name) 1021 1022 /* 1023 * Rename codecs appropriately from COEF value or subvendor id 1024 */ 1025 struct alc_codec_rename_table { 1026 unsigned int vendor_id; 1027 unsigned short coef_mask; 1028 unsigned short coef_bits; 1029 const char *name; 1030 }; 1031 1032 struct alc_codec_rename_pci_table { 1033 unsigned int codec_vendor_id; 1034 unsigned short pci_subvendor; 1035 unsigned short pci_subdevice; 1036 const char *name; 1037 }; 1038 1039 static const struct alc_codec_rename_table rename_tbl[] = { 1040 { 0x10ec0221, 0xf00f, 0x1003, "ALC231" }, 1041 { 0x10ec0269, 0xfff0, 0x3010, "ALC277" }, 1042 { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" }, 1043 { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" }, 1044 { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" }, 1045 { 0x10ec0269, 0xffff, 0xa023, "ALC259" }, 1046 { 0x10ec0269, 0xffff, 0x6023, "ALC281X" }, 1047 { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" }, 1048 { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" }, 1049 { 0x10ec0662, 0xffff, 0x4020, "ALC656" }, 1050 { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" }, 1051 { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" }, 1052 { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" }, 1053 { 0x10ec0899, 0x2000, 0x2000, "ALC899" }, 1054 { 0x10ec0892, 0xffff, 0x8020, "ALC661" }, 1055 { 0x10ec0892, 0xffff, 0x8011, "ALC661" }, 1056 { 0x10ec0892, 0xffff, 0x4011, "ALC656" }, 1057 { } /* terminator */ 1058 }; 1059 1060 static const struct alc_codec_rename_pci_table rename_pci_tbl[] = { 1061 { 0x10ec0280, 0x1028, 0, "ALC3220" }, 1062 { 0x10ec0282, 0x1028, 0, "ALC3221" }, 1063 { 0x10ec0283, 0x1028, 0, "ALC3223" }, 1064 { 0x10ec0288, 0x1028, 0, "ALC3263" }, 1065 { 0x10ec0292, 0x1028, 0, "ALC3226" }, 1066 { 0x10ec0293, 0x1028, 0, "ALC3235" }, 1067 { 0x10ec0255, 0x1028, 0, "ALC3234" }, 1068 { 0x10ec0668, 0x1028, 0, "ALC3661" }, 1069 { 0x10ec0275, 0x1028, 0, "ALC3260" }, 1070 { 0x10ec0899, 0x1028, 0, "ALC3861" }, 1071 { 0x10ec0298, 0x1028, 0, "ALC3266" }, 1072 { 0x10ec0236, 0x1028, 0, "ALC3204" }, 1073 { 0x10ec0256, 0x1028, 0, "ALC3246" }, 1074 { 0x10ec0225, 0x1028, 0, "ALC3253" }, 1075 { 0x10ec0295, 0x1028, 0, "ALC3254" }, 1076 { 0x10ec0299, 0x1028, 0, "ALC3271" }, 1077 { 0x10ec0670, 0x1025, 0, "ALC669X" }, 1078 { 0x10ec0676, 0x1025, 0, "ALC679X" }, 1079 { 0x10ec0282, 0x1043, 0, "ALC3229" }, 1080 { 0x10ec0233, 0x1043, 0, "ALC3236" }, 1081 { 0x10ec0280, 0x103c, 0, "ALC3228" }, 1082 { 0x10ec0282, 0x103c, 0, "ALC3227" }, 1083 { 0x10ec0286, 0x103c, 0, "ALC3242" }, 1084 { 0x10ec0290, 0x103c, 0, "ALC3241" }, 1085 { 0x10ec0668, 0x103c, 0, "ALC3662" }, 1086 { 0x10ec0283, 0x17aa, 0, "ALC3239" }, 1087 { 0x10ec0292, 0x17aa, 0, "ALC3232" }, 1088 { } /* terminator */ 1089 }; 1090 1091 static int alc_codec_rename_from_preset(struct hda_codec *codec) 1092 { 1093 const struct alc_codec_rename_table *p; 1094 const struct alc_codec_rename_pci_table *q; 1095 1096 for (p = rename_tbl; p->vendor_id; p++) { 1097 if (p->vendor_id != codec->core.vendor_id) 1098 continue; 1099 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits) 1100 return alc_codec_rename(codec, p->name); 1101 } 1102 1103 if (!codec->bus->pci) 1104 return 0; 1105 for (q = rename_pci_tbl; q->codec_vendor_id; q++) { 1106 if (q->codec_vendor_id != codec->core.vendor_id) 1107 continue; 1108 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor) 1109 continue; 1110 if (!q->pci_subdevice || 1111 q->pci_subdevice == codec->bus->pci->subsystem_device) 1112 return alc_codec_rename(codec, q->name); 1113 } 1114 1115 return 0; 1116 } 1117 1118 1119 /* 1120 * Digital-beep handlers 1121 */ 1122 #ifdef CONFIG_SND_HDA_INPUT_BEEP 1123 1124 /* additional beep mixers; private_value will be overwritten */ 1125 static const struct snd_kcontrol_new alc_beep_mixer[] = { 1126 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT), 1127 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT), 1128 }; 1129 1130 /* set up and create beep controls */ 1131 static int set_beep_amp(struct alc_spec *spec, hda_nid_t nid, 1132 int idx, int dir) 1133 { 1134 struct snd_kcontrol_new *knew; 1135 unsigned int beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir); 1136 int i; 1137 1138 for (i = 0; i < ARRAY_SIZE(alc_beep_mixer); i++) { 1139 knew = snd_hda_gen_add_kctl(&spec->gen, NULL, 1140 &alc_beep_mixer[i]); 1141 if (!knew) 1142 return -ENOMEM; 1143 knew->private_value = beep_amp; 1144 } 1145 return 0; 1146 } 1147 1148 static const struct snd_pci_quirk beep_allow_list[] = { 1149 SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1), 1150 SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1), 1151 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1), 1152 SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1), 1153 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1), 1154 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1), 1155 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1), 1156 SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1), 1157 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1), 1158 /* denylist -- no beep available */ 1159 SND_PCI_QUIRK(0x17aa, 0x309e, "Lenovo ThinkCentre M73", 0), 1160 SND_PCI_QUIRK(0x17aa, 0x30a3, "Lenovo ThinkCentre M93", 0), 1161 {} 1162 }; 1163 1164 static inline int has_cdefine_beep(struct hda_codec *codec) 1165 { 1166 struct alc_spec *spec = codec->spec; 1167 const struct snd_pci_quirk *q; 1168 q = snd_pci_quirk_lookup(codec->bus->pci, beep_allow_list); 1169 if (q) 1170 return q->value; 1171 return spec->cdefine.enable_pcbeep; 1172 } 1173 #else 1174 #define set_beep_amp(spec, nid, idx, dir) 0 1175 #define has_cdefine_beep(codec) 0 1176 #endif 1177 1178 /* parse the BIOS configuration and set up the alc_spec */ 1179 /* return 1 if successful, 0 if the proper config is not found, 1180 * or a negative error code 1181 */ 1182 static int alc_parse_auto_config(struct hda_codec *codec, 1183 const hda_nid_t *ignore_nids, 1184 const hda_nid_t *ssid_nids) 1185 { 1186 struct alc_spec *spec = codec->spec; 1187 struct auto_pin_cfg *cfg = &spec->gen.autocfg; 1188 int err; 1189 1190 err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids, 1191 spec->parse_flags); 1192 if (err < 0) 1193 return err; 1194 1195 if (ssid_nids) 1196 alc_ssid_check(codec, ssid_nids); 1197 1198 err = snd_hda_gen_parse_auto_config(codec, cfg); 1199 if (err < 0) 1200 return err; 1201 1202 return 1; 1203 } 1204 1205 /* common preparation job for alc_spec */ 1206 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid) 1207 { 1208 struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL); 1209 int err; 1210 1211 if (!spec) 1212 return -ENOMEM; 1213 codec->spec = spec; 1214 snd_hda_gen_spec_init(&spec->gen); 1215 spec->gen.mixer_nid = mixer_nid; 1216 spec->gen.own_eapd_ctl = 1; 1217 codec->single_adc_amp = 1; 1218 /* FIXME: do we need this for all Realtek codec models? */ 1219 codec->spdif_status_reset = 1; 1220 codec->forced_resume = 1; 1221 codec->patch_ops = alc_patch_ops; 1222 mutex_init(&spec->coef_mutex); 1223 1224 err = alc_codec_rename_from_preset(codec); 1225 if (err < 0) { 1226 kfree(spec); 1227 return err; 1228 } 1229 return 0; 1230 } 1231 1232 static int alc880_parse_auto_config(struct hda_codec *codec) 1233 { 1234 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 }; 1235 static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 1236 return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids); 1237 } 1238 1239 /* 1240 * ALC880 fix-ups 1241 */ 1242 enum { 1243 ALC880_FIXUP_GPIO1, 1244 ALC880_FIXUP_GPIO2, 1245 ALC880_FIXUP_MEDION_RIM, 1246 ALC880_FIXUP_LG, 1247 ALC880_FIXUP_LG_LW25, 1248 ALC880_FIXUP_W810, 1249 ALC880_FIXUP_EAPD_COEF, 1250 ALC880_FIXUP_TCL_S700, 1251 ALC880_FIXUP_VOL_KNOB, 1252 ALC880_FIXUP_FUJITSU, 1253 ALC880_FIXUP_F1734, 1254 ALC880_FIXUP_UNIWILL, 1255 ALC880_FIXUP_UNIWILL_DIG, 1256 ALC880_FIXUP_Z71V, 1257 ALC880_FIXUP_ASUS_W5A, 1258 ALC880_FIXUP_3ST_BASE, 1259 ALC880_FIXUP_3ST, 1260 ALC880_FIXUP_3ST_DIG, 1261 ALC880_FIXUP_5ST_BASE, 1262 ALC880_FIXUP_5ST, 1263 ALC880_FIXUP_5ST_DIG, 1264 ALC880_FIXUP_6ST_BASE, 1265 ALC880_FIXUP_6ST, 1266 ALC880_FIXUP_6ST_DIG, 1267 ALC880_FIXUP_6ST_AUTOMUTE, 1268 }; 1269 1270 /* enable the volume-knob widget support on NID 0x21 */ 1271 static void alc880_fixup_vol_knob(struct hda_codec *codec, 1272 const struct hda_fixup *fix, int action) 1273 { 1274 if (action == HDA_FIXUP_ACT_PROBE) 1275 snd_hda_jack_detect_enable_callback(codec, 0x21, 1276 alc_update_knob_master); 1277 } 1278 1279 static const struct hda_fixup alc880_fixups[] = { 1280 [ALC880_FIXUP_GPIO1] = { 1281 .type = HDA_FIXUP_FUNC, 1282 .v.func = alc_fixup_gpio1, 1283 }, 1284 [ALC880_FIXUP_GPIO2] = { 1285 .type = HDA_FIXUP_FUNC, 1286 .v.func = alc_fixup_gpio2, 1287 }, 1288 [ALC880_FIXUP_MEDION_RIM] = { 1289 .type = HDA_FIXUP_VERBS, 1290 .v.verbs = (const struct hda_verb[]) { 1291 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 1292 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 }, 1293 { } 1294 }, 1295 .chained = true, 1296 .chain_id = ALC880_FIXUP_GPIO2, 1297 }, 1298 [ALC880_FIXUP_LG] = { 1299 .type = HDA_FIXUP_PINS, 1300 .v.pins = (const struct hda_pintbl[]) { 1301 /* disable bogus unused pins */ 1302 { 0x16, 0x411111f0 }, 1303 { 0x18, 0x411111f0 }, 1304 { 0x1a, 0x411111f0 }, 1305 { } 1306 } 1307 }, 1308 [ALC880_FIXUP_LG_LW25] = { 1309 .type = HDA_FIXUP_PINS, 1310 .v.pins = (const struct hda_pintbl[]) { 1311 { 0x1a, 0x0181344f }, /* line-in */ 1312 { 0x1b, 0x0321403f }, /* headphone */ 1313 { } 1314 } 1315 }, 1316 [ALC880_FIXUP_W810] = { 1317 .type = HDA_FIXUP_PINS, 1318 .v.pins = (const struct hda_pintbl[]) { 1319 /* disable bogus unused pins */ 1320 { 0x17, 0x411111f0 }, 1321 { } 1322 }, 1323 .chained = true, 1324 .chain_id = ALC880_FIXUP_GPIO2, 1325 }, 1326 [ALC880_FIXUP_EAPD_COEF] = { 1327 .type = HDA_FIXUP_VERBS, 1328 .v.verbs = (const struct hda_verb[]) { 1329 /* change to EAPD mode */ 1330 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 1331 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 }, 1332 {} 1333 }, 1334 }, 1335 [ALC880_FIXUP_TCL_S700] = { 1336 .type = HDA_FIXUP_VERBS, 1337 .v.verbs = (const struct hda_verb[]) { 1338 /* change to EAPD mode */ 1339 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 1340 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 }, 1341 {} 1342 }, 1343 .chained = true, 1344 .chain_id = ALC880_FIXUP_GPIO2, 1345 }, 1346 [ALC880_FIXUP_VOL_KNOB] = { 1347 .type = HDA_FIXUP_FUNC, 1348 .v.func = alc880_fixup_vol_knob, 1349 }, 1350 [ALC880_FIXUP_FUJITSU] = { 1351 /* override all pins as BIOS on old Amilo is broken */ 1352 .type = HDA_FIXUP_PINS, 1353 .v.pins = (const struct hda_pintbl[]) { 1354 { 0x14, 0x0121401f }, /* HP */ 1355 { 0x15, 0x99030120 }, /* speaker */ 1356 { 0x16, 0x99030130 }, /* bass speaker */ 1357 { 0x17, 0x411111f0 }, /* N/A */ 1358 { 0x18, 0x411111f0 }, /* N/A */ 1359 { 0x19, 0x01a19950 }, /* mic-in */ 1360 { 0x1a, 0x411111f0 }, /* N/A */ 1361 { 0x1b, 0x411111f0 }, /* N/A */ 1362 { 0x1c, 0x411111f0 }, /* N/A */ 1363 { 0x1d, 0x411111f0 }, /* N/A */ 1364 { 0x1e, 0x01454140 }, /* SPDIF out */ 1365 { } 1366 }, 1367 .chained = true, 1368 .chain_id = ALC880_FIXUP_VOL_KNOB, 1369 }, 1370 [ALC880_FIXUP_F1734] = { 1371 /* almost compatible with FUJITSU, but no bass and SPDIF */ 1372 .type = HDA_FIXUP_PINS, 1373 .v.pins = (const struct hda_pintbl[]) { 1374 { 0x14, 0x0121401f }, /* HP */ 1375 { 0x15, 0x99030120 }, /* speaker */ 1376 { 0x16, 0x411111f0 }, /* N/A */ 1377 { 0x17, 0x411111f0 }, /* N/A */ 1378 { 0x18, 0x411111f0 }, /* N/A */ 1379 { 0x19, 0x01a19950 }, /* mic-in */ 1380 { 0x1a, 0x411111f0 }, /* N/A */ 1381 { 0x1b, 0x411111f0 }, /* N/A */ 1382 { 0x1c, 0x411111f0 }, /* N/A */ 1383 { 0x1d, 0x411111f0 }, /* N/A */ 1384 { 0x1e, 0x411111f0 }, /* N/A */ 1385 { } 1386 }, 1387 .chained = true, 1388 .chain_id = ALC880_FIXUP_VOL_KNOB, 1389 }, 1390 [ALC880_FIXUP_UNIWILL] = { 1391 /* need to fix HP and speaker pins to be parsed correctly */ 1392 .type = HDA_FIXUP_PINS, 1393 .v.pins = (const struct hda_pintbl[]) { 1394 { 0x14, 0x0121411f }, /* HP */ 1395 { 0x15, 0x99030120 }, /* speaker */ 1396 { 0x16, 0x99030130 }, /* bass speaker */ 1397 { } 1398 }, 1399 }, 1400 [ALC880_FIXUP_UNIWILL_DIG] = { 1401 .type = HDA_FIXUP_PINS, 1402 .v.pins = (const struct hda_pintbl[]) { 1403 /* disable bogus unused pins */ 1404 { 0x17, 0x411111f0 }, 1405 { 0x19, 0x411111f0 }, 1406 { 0x1b, 0x411111f0 }, 1407 { 0x1f, 0x411111f0 }, 1408 { } 1409 } 1410 }, 1411 [ALC880_FIXUP_Z71V] = { 1412 .type = HDA_FIXUP_PINS, 1413 .v.pins = (const struct hda_pintbl[]) { 1414 /* set up the whole pins as BIOS is utterly broken */ 1415 { 0x14, 0x99030120 }, /* speaker */ 1416 { 0x15, 0x0121411f }, /* HP */ 1417 { 0x16, 0x411111f0 }, /* N/A */ 1418 { 0x17, 0x411111f0 }, /* N/A */ 1419 { 0x18, 0x01a19950 }, /* mic-in */ 1420 { 0x19, 0x411111f0 }, /* N/A */ 1421 { 0x1a, 0x01813031 }, /* line-in */ 1422 { 0x1b, 0x411111f0 }, /* N/A */ 1423 { 0x1c, 0x411111f0 }, /* N/A */ 1424 { 0x1d, 0x411111f0 }, /* N/A */ 1425 { 0x1e, 0x0144111e }, /* SPDIF */ 1426 { } 1427 } 1428 }, 1429 [ALC880_FIXUP_ASUS_W5A] = { 1430 .type = HDA_FIXUP_PINS, 1431 .v.pins = (const struct hda_pintbl[]) { 1432 /* set up the whole pins as BIOS is utterly broken */ 1433 { 0x14, 0x0121411f }, /* HP */ 1434 { 0x15, 0x411111f0 }, /* N/A */ 1435 { 0x16, 0x411111f0 }, /* N/A */ 1436 { 0x17, 0x411111f0 }, /* N/A */ 1437 { 0x18, 0x90a60160 }, /* mic */ 1438 { 0x19, 0x411111f0 }, /* N/A */ 1439 { 0x1a, 0x411111f0 }, /* N/A */ 1440 { 0x1b, 0x411111f0 }, /* N/A */ 1441 { 0x1c, 0x411111f0 }, /* N/A */ 1442 { 0x1d, 0x411111f0 }, /* N/A */ 1443 { 0x1e, 0xb743111e }, /* SPDIF out */ 1444 { } 1445 }, 1446 .chained = true, 1447 .chain_id = ALC880_FIXUP_GPIO1, 1448 }, 1449 [ALC880_FIXUP_3ST_BASE] = { 1450 .type = HDA_FIXUP_PINS, 1451 .v.pins = (const struct hda_pintbl[]) { 1452 { 0x14, 0x01014010 }, /* line-out */ 1453 { 0x15, 0x411111f0 }, /* N/A */ 1454 { 0x16, 0x411111f0 }, /* N/A */ 1455 { 0x17, 0x411111f0 }, /* N/A */ 1456 { 0x18, 0x01a19c30 }, /* mic-in */ 1457 { 0x19, 0x0121411f }, /* HP */ 1458 { 0x1a, 0x01813031 }, /* line-in */ 1459 { 0x1b, 0x02a19c40 }, /* front-mic */ 1460 { 0x1c, 0x411111f0 }, /* N/A */ 1461 { 0x1d, 0x411111f0 }, /* N/A */ 1462 /* 0x1e is filled in below */ 1463 { 0x1f, 0x411111f0 }, /* N/A */ 1464 { } 1465 } 1466 }, 1467 [ALC880_FIXUP_3ST] = { 1468 .type = HDA_FIXUP_PINS, 1469 .v.pins = (const struct hda_pintbl[]) { 1470 { 0x1e, 0x411111f0 }, /* N/A */ 1471 { } 1472 }, 1473 .chained = true, 1474 .chain_id = ALC880_FIXUP_3ST_BASE, 1475 }, 1476 [ALC880_FIXUP_3ST_DIG] = { 1477 .type = HDA_FIXUP_PINS, 1478 .v.pins = (const struct hda_pintbl[]) { 1479 { 0x1e, 0x0144111e }, /* SPDIF */ 1480 { } 1481 }, 1482 .chained = true, 1483 .chain_id = ALC880_FIXUP_3ST_BASE, 1484 }, 1485 [ALC880_FIXUP_5ST_BASE] = { 1486 .type = HDA_FIXUP_PINS, 1487 .v.pins = (const struct hda_pintbl[]) { 1488 { 0x14, 0x01014010 }, /* front */ 1489 { 0x15, 0x411111f0 }, /* N/A */ 1490 { 0x16, 0x01011411 }, /* CLFE */ 1491 { 0x17, 0x01016412 }, /* surr */ 1492 { 0x18, 0x01a19c30 }, /* mic-in */ 1493 { 0x19, 0x0121411f }, /* HP */ 1494 { 0x1a, 0x01813031 }, /* line-in */ 1495 { 0x1b, 0x02a19c40 }, /* front-mic */ 1496 { 0x1c, 0x411111f0 }, /* N/A */ 1497 { 0x1d, 0x411111f0 }, /* N/A */ 1498 /* 0x1e is filled in below */ 1499 { 0x1f, 0x411111f0 }, /* N/A */ 1500 { } 1501 } 1502 }, 1503 [ALC880_FIXUP_5ST] = { 1504 .type = HDA_FIXUP_PINS, 1505 .v.pins = (const struct hda_pintbl[]) { 1506 { 0x1e, 0x411111f0 }, /* N/A */ 1507 { } 1508 }, 1509 .chained = true, 1510 .chain_id = ALC880_FIXUP_5ST_BASE, 1511 }, 1512 [ALC880_FIXUP_5ST_DIG] = { 1513 .type = HDA_FIXUP_PINS, 1514 .v.pins = (const struct hda_pintbl[]) { 1515 { 0x1e, 0x0144111e }, /* SPDIF */ 1516 { } 1517 }, 1518 .chained = true, 1519 .chain_id = ALC880_FIXUP_5ST_BASE, 1520 }, 1521 [ALC880_FIXUP_6ST_BASE] = { 1522 .type = HDA_FIXUP_PINS, 1523 .v.pins = (const struct hda_pintbl[]) { 1524 { 0x14, 0x01014010 }, /* front */ 1525 { 0x15, 0x01016412 }, /* surr */ 1526 { 0x16, 0x01011411 }, /* CLFE */ 1527 { 0x17, 0x01012414 }, /* side */ 1528 { 0x18, 0x01a19c30 }, /* mic-in */ 1529 { 0x19, 0x02a19c40 }, /* front-mic */ 1530 { 0x1a, 0x01813031 }, /* line-in */ 1531 { 0x1b, 0x0121411f }, /* HP */ 1532 { 0x1c, 0x411111f0 }, /* N/A */ 1533 { 0x1d, 0x411111f0 }, /* N/A */ 1534 /* 0x1e is filled in below */ 1535 { 0x1f, 0x411111f0 }, /* N/A */ 1536 { } 1537 } 1538 }, 1539 [ALC880_FIXUP_6ST] = { 1540 .type = HDA_FIXUP_PINS, 1541 .v.pins = (const struct hda_pintbl[]) { 1542 { 0x1e, 0x411111f0 }, /* N/A */ 1543 { } 1544 }, 1545 .chained = true, 1546 .chain_id = ALC880_FIXUP_6ST_BASE, 1547 }, 1548 [ALC880_FIXUP_6ST_DIG] = { 1549 .type = HDA_FIXUP_PINS, 1550 .v.pins = (const struct hda_pintbl[]) { 1551 { 0x1e, 0x0144111e }, /* SPDIF */ 1552 { } 1553 }, 1554 .chained = true, 1555 .chain_id = ALC880_FIXUP_6ST_BASE, 1556 }, 1557 [ALC880_FIXUP_6ST_AUTOMUTE] = { 1558 .type = HDA_FIXUP_PINS, 1559 .v.pins = (const struct hda_pintbl[]) { 1560 { 0x1b, 0x0121401f }, /* HP with jack detect */ 1561 { } 1562 }, 1563 .chained_before = true, 1564 .chain_id = ALC880_FIXUP_6ST_BASE, 1565 }, 1566 }; 1567 1568 static const struct hda_quirk alc880_fixup_tbl[] = { 1569 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810), 1570 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A), 1571 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V), 1572 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1), 1573 SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE), 1574 SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2), 1575 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF), 1576 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG), 1577 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734), 1578 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL), 1579 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB), 1580 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810), 1581 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM), 1582 SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE), 1583 SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU), 1584 SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU), 1585 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734), 1586 SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU), 1587 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG), 1588 SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG), 1589 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG), 1590 SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25), 1591 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700), 1592 1593 /* Below is the copied entries from alc880_quirks.c. 1594 * It's not quite sure whether BIOS sets the correct pin-config table 1595 * on these machines, thus they are kept to be compatible with 1596 * the old static quirks. Once when it's confirmed to work without 1597 * these overrides, it'd be better to remove. 1598 */ 1599 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG), 1600 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST), 1601 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG), 1602 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG), 1603 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG), 1604 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG), 1605 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG), 1606 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST), 1607 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG), 1608 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST), 1609 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST), 1610 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST), 1611 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST), 1612 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST), 1613 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG), 1614 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG), 1615 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG), 1616 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG), 1617 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG), 1618 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG), 1619 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG), 1620 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */ 1621 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG), 1622 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1623 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1624 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1625 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG), 1626 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1627 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG), 1628 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG), 1629 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1630 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1631 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1632 /* default Intel */ 1633 SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST), 1634 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG), 1635 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG), 1636 {} 1637 }; 1638 1639 static const struct hda_model_fixup alc880_fixup_models[] = { 1640 {.id = ALC880_FIXUP_3ST, .name = "3stack"}, 1641 {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"}, 1642 {.id = ALC880_FIXUP_5ST, .name = "5stack"}, 1643 {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"}, 1644 {.id = ALC880_FIXUP_6ST, .name = "6stack"}, 1645 {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"}, 1646 {.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"}, 1647 {} 1648 }; 1649 1650 1651 /* 1652 * OK, here we have finally the patch for ALC880 1653 */ 1654 static int patch_alc880(struct hda_codec *codec) 1655 { 1656 struct alc_spec *spec; 1657 int err; 1658 1659 err = alc_alloc_spec(codec, 0x0b); 1660 if (err < 0) 1661 return err; 1662 1663 spec = codec->spec; 1664 spec->gen.need_dac_fix = 1; 1665 spec->gen.beep_nid = 0x01; 1666 1667 codec->patch_ops.unsol_event = alc880_unsol_event; 1668 1669 alc_pre_init(codec); 1670 1671 snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl, 1672 alc880_fixups); 1673 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 1674 1675 /* automatic parse from the BIOS config */ 1676 err = alc880_parse_auto_config(codec); 1677 if (err < 0) 1678 goto error; 1679 1680 if (!spec->gen.no_analog) { 1681 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 1682 if (err < 0) 1683 goto error; 1684 } 1685 1686 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 1687 1688 return 0; 1689 1690 error: 1691 alc_free(codec); 1692 return err; 1693 } 1694 1695 1696 /* 1697 * ALC260 support 1698 */ 1699 static int alc260_parse_auto_config(struct hda_codec *codec) 1700 { 1701 static const hda_nid_t alc260_ignore[] = { 0x17, 0 }; 1702 static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 }; 1703 return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids); 1704 } 1705 1706 /* 1707 * Pin config fixes 1708 */ 1709 enum { 1710 ALC260_FIXUP_HP_DC5750, 1711 ALC260_FIXUP_HP_PIN_0F, 1712 ALC260_FIXUP_COEF, 1713 ALC260_FIXUP_GPIO1, 1714 ALC260_FIXUP_GPIO1_TOGGLE, 1715 ALC260_FIXUP_REPLACER, 1716 ALC260_FIXUP_HP_B1900, 1717 ALC260_FIXUP_KN1, 1718 ALC260_FIXUP_FSC_S7020, 1719 ALC260_FIXUP_FSC_S7020_JWSE, 1720 ALC260_FIXUP_VAIO_PINS, 1721 }; 1722 1723 static void alc260_gpio1_automute(struct hda_codec *codec) 1724 { 1725 struct alc_spec *spec = codec->spec; 1726 1727 alc_update_gpio_data(codec, 0x01, spec->gen.hp_jack_present); 1728 } 1729 1730 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec, 1731 const struct hda_fixup *fix, int action) 1732 { 1733 struct alc_spec *spec = codec->spec; 1734 if (action == HDA_FIXUP_ACT_PROBE) { 1735 /* although the machine has only one output pin, we need to 1736 * toggle GPIO1 according to the jack state 1737 */ 1738 spec->gen.automute_hook = alc260_gpio1_automute; 1739 spec->gen.detect_hp = 1; 1740 spec->gen.automute_speaker = 1; 1741 spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */ 1742 snd_hda_jack_detect_enable_callback(codec, 0x0f, 1743 snd_hda_gen_hp_automute); 1744 alc_setup_gpio(codec, 0x01); 1745 } 1746 } 1747 1748 static void alc260_fixup_kn1(struct hda_codec *codec, 1749 const struct hda_fixup *fix, int action) 1750 { 1751 struct alc_spec *spec = codec->spec; 1752 static const struct hda_pintbl pincfgs[] = { 1753 { 0x0f, 0x02214000 }, /* HP/speaker */ 1754 { 0x12, 0x90a60160 }, /* int mic */ 1755 { 0x13, 0x02a19000 }, /* ext mic */ 1756 { 0x18, 0x01446000 }, /* SPDIF out */ 1757 /* disable bogus I/O pins */ 1758 { 0x10, 0x411111f0 }, 1759 { 0x11, 0x411111f0 }, 1760 { 0x14, 0x411111f0 }, 1761 { 0x15, 0x411111f0 }, 1762 { 0x16, 0x411111f0 }, 1763 { 0x17, 0x411111f0 }, 1764 { 0x19, 0x411111f0 }, 1765 { } 1766 }; 1767 1768 switch (action) { 1769 case HDA_FIXUP_ACT_PRE_PROBE: 1770 snd_hda_apply_pincfgs(codec, pincfgs); 1771 spec->init_amp = ALC_INIT_NONE; 1772 break; 1773 } 1774 } 1775 1776 static void alc260_fixup_fsc_s7020(struct hda_codec *codec, 1777 const struct hda_fixup *fix, int action) 1778 { 1779 struct alc_spec *spec = codec->spec; 1780 if (action == HDA_FIXUP_ACT_PRE_PROBE) 1781 spec->init_amp = ALC_INIT_NONE; 1782 } 1783 1784 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec, 1785 const struct hda_fixup *fix, int action) 1786 { 1787 struct alc_spec *spec = codec->spec; 1788 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1789 spec->gen.add_jack_modes = 1; 1790 spec->gen.hp_mic = 1; 1791 } 1792 } 1793 1794 static const struct hda_fixup alc260_fixups[] = { 1795 [ALC260_FIXUP_HP_DC5750] = { 1796 .type = HDA_FIXUP_PINS, 1797 .v.pins = (const struct hda_pintbl[]) { 1798 { 0x11, 0x90130110 }, /* speaker */ 1799 { } 1800 } 1801 }, 1802 [ALC260_FIXUP_HP_PIN_0F] = { 1803 .type = HDA_FIXUP_PINS, 1804 .v.pins = (const struct hda_pintbl[]) { 1805 { 0x0f, 0x01214000 }, /* HP */ 1806 { } 1807 } 1808 }, 1809 [ALC260_FIXUP_COEF] = { 1810 .type = HDA_FIXUP_VERBS, 1811 .v.verbs = (const struct hda_verb[]) { 1812 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 }, 1813 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3040 }, 1814 { } 1815 }, 1816 }, 1817 [ALC260_FIXUP_GPIO1] = { 1818 .type = HDA_FIXUP_FUNC, 1819 .v.func = alc_fixup_gpio1, 1820 }, 1821 [ALC260_FIXUP_GPIO1_TOGGLE] = { 1822 .type = HDA_FIXUP_FUNC, 1823 .v.func = alc260_fixup_gpio1_toggle, 1824 .chained = true, 1825 .chain_id = ALC260_FIXUP_HP_PIN_0F, 1826 }, 1827 [ALC260_FIXUP_REPLACER] = { 1828 .type = HDA_FIXUP_VERBS, 1829 .v.verbs = (const struct hda_verb[]) { 1830 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 }, 1831 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3050 }, 1832 { } 1833 }, 1834 .chained = true, 1835 .chain_id = ALC260_FIXUP_GPIO1_TOGGLE, 1836 }, 1837 [ALC260_FIXUP_HP_B1900] = { 1838 .type = HDA_FIXUP_FUNC, 1839 .v.func = alc260_fixup_gpio1_toggle, 1840 .chained = true, 1841 .chain_id = ALC260_FIXUP_COEF, 1842 }, 1843 [ALC260_FIXUP_KN1] = { 1844 .type = HDA_FIXUP_FUNC, 1845 .v.func = alc260_fixup_kn1, 1846 }, 1847 [ALC260_FIXUP_FSC_S7020] = { 1848 .type = HDA_FIXUP_FUNC, 1849 .v.func = alc260_fixup_fsc_s7020, 1850 }, 1851 [ALC260_FIXUP_FSC_S7020_JWSE] = { 1852 .type = HDA_FIXUP_FUNC, 1853 .v.func = alc260_fixup_fsc_s7020_jwse, 1854 .chained = true, 1855 .chain_id = ALC260_FIXUP_FSC_S7020, 1856 }, 1857 [ALC260_FIXUP_VAIO_PINS] = { 1858 .type = HDA_FIXUP_PINS, 1859 .v.pins = (const struct hda_pintbl[]) { 1860 /* Pin configs are missing completely on some VAIOs */ 1861 { 0x0f, 0x01211020 }, 1862 { 0x10, 0x0001003f }, 1863 { 0x11, 0x411111f0 }, 1864 { 0x12, 0x01a15930 }, 1865 { 0x13, 0x411111f0 }, 1866 { 0x14, 0x411111f0 }, 1867 { 0x15, 0x411111f0 }, 1868 { 0x16, 0x411111f0 }, 1869 { 0x17, 0x411111f0 }, 1870 { 0x18, 0x411111f0 }, 1871 { 0x19, 0x411111f0 }, 1872 { } 1873 } 1874 }, 1875 }; 1876 1877 static const struct hda_quirk alc260_fixup_tbl[] = { 1878 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1), 1879 SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF), 1880 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1), 1881 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750), 1882 SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900), 1883 SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS), 1884 SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F), 1885 SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020), 1886 SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1), 1887 SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1), 1888 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER), 1889 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF), 1890 {} 1891 }; 1892 1893 static const struct hda_model_fixup alc260_fixup_models[] = { 1894 {.id = ALC260_FIXUP_GPIO1, .name = "gpio1"}, 1895 {.id = ALC260_FIXUP_COEF, .name = "coef"}, 1896 {.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"}, 1897 {.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"}, 1898 {} 1899 }; 1900 1901 /* 1902 */ 1903 static int patch_alc260(struct hda_codec *codec) 1904 { 1905 struct alc_spec *spec; 1906 int err; 1907 1908 err = alc_alloc_spec(codec, 0x07); 1909 if (err < 0) 1910 return err; 1911 1912 spec = codec->spec; 1913 /* as quite a few machines require HP amp for speaker outputs, 1914 * it's easier to enable it unconditionally; even if it's unneeded, 1915 * it's almost harmless. 1916 */ 1917 spec->gen.prefer_hp_amp = 1; 1918 spec->gen.beep_nid = 0x01; 1919 1920 spec->shutup = alc_eapd_shutup; 1921 1922 alc_pre_init(codec); 1923 1924 snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl, 1925 alc260_fixups); 1926 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 1927 1928 /* automatic parse from the BIOS config */ 1929 err = alc260_parse_auto_config(codec); 1930 if (err < 0) 1931 goto error; 1932 1933 if (!spec->gen.no_analog) { 1934 err = set_beep_amp(spec, 0x07, 0x05, HDA_INPUT); 1935 if (err < 0) 1936 goto error; 1937 } 1938 1939 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 1940 1941 return 0; 1942 1943 error: 1944 alc_free(codec); 1945 return err; 1946 } 1947 1948 1949 /* 1950 * ALC882/883/885/888/889 support 1951 * 1952 * ALC882 is almost identical with ALC880 but has cleaner and more flexible 1953 * configuration. Each pin widget can choose any input DACs and a mixer. 1954 * Each ADC is connected from a mixer of all inputs. This makes possible 1955 * 6-channel independent captures. 1956 * 1957 * In addition, an independent DAC for the multi-playback (not used in this 1958 * driver yet). 1959 */ 1960 1961 /* 1962 * Pin config fixes 1963 */ 1964 enum { 1965 ALC882_FIXUP_ABIT_AW9D_MAX, 1966 ALC882_FIXUP_LENOVO_Y530, 1967 ALC882_FIXUP_PB_M5210, 1968 ALC882_FIXUP_ACER_ASPIRE_7736, 1969 ALC882_FIXUP_ASUS_W90V, 1970 ALC889_FIXUP_CD, 1971 ALC889_FIXUP_FRONT_HP_NO_PRESENCE, 1972 ALC889_FIXUP_VAIO_TT, 1973 ALC888_FIXUP_EEE1601, 1974 ALC886_FIXUP_EAPD, 1975 ALC882_FIXUP_EAPD, 1976 ALC883_FIXUP_EAPD, 1977 ALC883_FIXUP_ACER_EAPD, 1978 ALC882_FIXUP_GPIO1, 1979 ALC882_FIXUP_GPIO2, 1980 ALC882_FIXUP_GPIO3, 1981 ALC889_FIXUP_COEF, 1982 ALC882_FIXUP_ASUS_W2JC, 1983 ALC882_FIXUP_ACER_ASPIRE_4930G, 1984 ALC882_FIXUP_ACER_ASPIRE_8930G, 1985 ALC882_FIXUP_ASPIRE_8930G_VERBS, 1986 ALC885_FIXUP_MACPRO_GPIO, 1987 ALC889_FIXUP_DAC_ROUTE, 1988 ALC889_FIXUP_MBP_VREF, 1989 ALC889_FIXUP_IMAC91_VREF, 1990 ALC889_FIXUP_MBA11_VREF, 1991 ALC889_FIXUP_MBA21_VREF, 1992 ALC889_FIXUP_MP11_VREF, 1993 ALC889_FIXUP_MP41_VREF, 1994 ALC882_FIXUP_INV_DMIC, 1995 ALC882_FIXUP_NO_PRIMARY_HP, 1996 ALC887_FIXUP_ASUS_BASS, 1997 ALC887_FIXUP_BASS_CHMAP, 1998 ALC1220_FIXUP_GB_DUAL_CODECS, 1999 ALC1220_FIXUP_GB_X570, 2000 ALC1220_FIXUP_CLEVO_P950, 2001 ALC1220_FIXUP_CLEVO_PB51ED, 2002 ALC1220_FIXUP_CLEVO_PB51ED_PINS, 2003 ALC887_FIXUP_ASUS_AUDIO, 2004 ALC887_FIXUP_ASUS_HMIC, 2005 ALCS1200A_FIXUP_MIC_VREF, 2006 ALC888VD_FIXUP_MIC_100VREF, 2007 }; 2008 2009 static void alc889_fixup_coef(struct hda_codec *codec, 2010 const struct hda_fixup *fix, int action) 2011 { 2012 if (action != HDA_FIXUP_ACT_INIT) 2013 return; 2014 alc_update_coef_idx(codec, 7, 0, 0x2030); 2015 } 2016 2017 /* set up GPIO at initialization */ 2018 static void alc885_fixup_macpro_gpio(struct hda_codec *codec, 2019 const struct hda_fixup *fix, int action) 2020 { 2021 struct alc_spec *spec = codec->spec; 2022 2023 spec->gpio_write_delay = true; 2024 alc_fixup_gpio3(codec, fix, action); 2025 } 2026 2027 /* Fix the connection of some pins for ALC889: 2028 * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't 2029 * work correctly (bko#42740) 2030 */ 2031 static void alc889_fixup_dac_route(struct hda_codec *codec, 2032 const struct hda_fixup *fix, int action) 2033 { 2034 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2035 /* fake the connections during parsing the tree */ 2036 static const hda_nid_t conn1[] = { 0x0c, 0x0d }; 2037 static const hda_nid_t conn2[] = { 0x0e, 0x0f }; 2038 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1); 2039 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1); 2040 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn2), conn2); 2041 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn2), conn2); 2042 } else if (action == HDA_FIXUP_ACT_PROBE) { 2043 /* restore the connections */ 2044 static const hda_nid_t conn[] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 }; 2045 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn); 2046 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn), conn); 2047 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn), conn); 2048 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn), conn); 2049 } 2050 } 2051 2052 /* Set VREF on HP pin */ 2053 static void alc889_fixup_mbp_vref(struct hda_codec *codec, 2054 const struct hda_fixup *fix, int action) 2055 { 2056 static const hda_nid_t nids[] = { 0x14, 0x15, 0x19 }; 2057 struct alc_spec *spec = codec->spec; 2058 int i; 2059 2060 if (action != HDA_FIXUP_ACT_INIT) 2061 return; 2062 for (i = 0; i < ARRAY_SIZE(nids); i++) { 2063 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]); 2064 if (get_defcfg_device(val) != AC_JACK_HP_OUT) 2065 continue; 2066 val = snd_hda_codec_get_pin_target(codec, nids[i]); 2067 val |= AC_PINCTL_VREF_80; 2068 snd_hda_set_pin_ctl(codec, nids[i], val); 2069 spec->gen.keep_vref_in_automute = 1; 2070 break; 2071 } 2072 } 2073 2074 static void alc889_fixup_mac_pins(struct hda_codec *codec, 2075 const hda_nid_t *nids, int num_nids) 2076 { 2077 struct alc_spec *spec = codec->spec; 2078 int i; 2079 2080 for (i = 0; i < num_nids; i++) { 2081 unsigned int val; 2082 val = snd_hda_codec_get_pin_target(codec, nids[i]); 2083 val |= AC_PINCTL_VREF_50; 2084 snd_hda_set_pin_ctl(codec, nids[i], val); 2085 } 2086 spec->gen.keep_vref_in_automute = 1; 2087 } 2088 2089 /* Set VREF on speaker pins on imac91 */ 2090 static void alc889_fixup_imac91_vref(struct hda_codec *codec, 2091 const struct hda_fixup *fix, int action) 2092 { 2093 static const hda_nid_t nids[] = { 0x18, 0x1a }; 2094 2095 if (action == HDA_FIXUP_ACT_INIT) 2096 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids)); 2097 } 2098 2099 /* Set VREF on speaker pins on mba11 */ 2100 static void alc889_fixup_mba11_vref(struct hda_codec *codec, 2101 const struct hda_fixup *fix, int action) 2102 { 2103 static const hda_nid_t nids[] = { 0x18 }; 2104 2105 if (action == HDA_FIXUP_ACT_INIT) 2106 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids)); 2107 } 2108 2109 /* Set VREF on speaker pins on mba21 */ 2110 static void alc889_fixup_mba21_vref(struct hda_codec *codec, 2111 const struct hda_fixup *fix, int action) 2112 { 2113 static const hda_nid_t nids[] = { 0x18, 0x19 }; 2114 2115 if (action == HDA_FIXUP_ACT_INIT) 2116 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids)); 2117 } 2118 2119 /* Don't take HP output as primary 2120 * Strangely, the speaker output doesn't work on Vaio Z and some Vaio 2121 * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05 2122 */ 2123 static void alc882_fixup_no_primary_hp(struct hda_codec *codec, 2124 const struct hda_fixup *fix, int action) 2125 { 2126 struct alc_spec *spec = codec->spec; 2127 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2128 spec->gen.no_primary_hp = 1; 2129 spec->gen.no_multi_io = 1; 2130 } 2131 } 2132 2133 static void alc_fixup_bass_chmap(struct hda_codec *codec, 2134 const struct hda_fixup *fix, int action); 2135 2136 /* For dual-codec configuration, we need to disable some features to avoid 2137 * conflicts of kctls and PCM streams 2138 */ 2139 static void alc_fixup_dual_codecs(struct hda_codec *codec, 2140 const struct hda_fixup *fix, int action) 2141 { 2142 struct alc_spec *spec = codec->spec; 2143 2144 if (action != HDA_FIXUP_ACT_PRE_PROBE) 2145 return; 2146 /* disable vmaster */ 2147 spec->gen.suppress_vmaster = 1; 2148 /* auto-mute and auto-mic switch don't work with multiple codecs */ 2149 spec->gen.suppress_auto_mute = 1; 2150 spec->gen.suppress_auto_mic = 1; 2151 /* disable aamix as well */ 2152 spec->gen.mixer_nid = 0; 2153 /* add location prefix to avoid conflicts */ 2154 codec->force_pin_prefix = 1; 2155 } 2156 2157 static void rename_ctl(struct hda_codec *codec, const char *oldname, 2158 const char *newname) 2159 { 2160 struct snd_kcontrol *kctl; 2161 2162 kctl = snd_hda_find_mixer_ctl(codec, oldname); 2163 if (kctl) 2164 snd_ctl_rename(codec->card, kctl, newname); 2165 } 2166 2167 static void alc1220_fixup_gb_dual_codecs(struct hda_codec *codec, 2168 const struct hda_fixup *fix, 2169 int action) 2170 { 2171 alc_fixup_dual_codecs(codec, fix, action); 2172 switch (action) { 2173 case HDA_FIXUP_ACT_PRE_PROBE: 2174 /* override card longname to provide a unique UCM profile */ 2175 strcpy(codec->card->longname, "HDAudio-Gigabyte-ALC1220DualCodecs"); 2176 break; 2177 case HDA_FIXUP_ACT_BUILD: 2178 /* rename Capture controls depending on the codec */ 2179 rename_ctl(codec, "Capture Volume", 2180 codec->addr == 0 ? 2181 "Rear-Panel Capture Volume" : 2182 "Front-Panel Capture Volume"); 2183 rename_ctl(codec, "Capture Switch", 2184 codec->addr == 0 ? 2185 "Rear-Panel Capture Switch" : 2186 "Front-Panel Capture Switch"); 2187 break; 2188 } 2189 } 2190 2191 static void alc1220_fixup_gb_x570(struct hda_codec *codec, 2192 const struct hda_fixup *fix, 2193 int action) 2194 { 2195 static const hda_nid_t conn1[] = { 0x0c }; 2196 static const struct coef_fw gb_x570_coefs[] = { 2197 WRITE_COEF(0x07, 0x03c0), 2198 WRITE_COEF(0x1a, 0x01c1), 2199 WRITE_COEF(0x1b, 0x0202), 2200 WRITE_COEF(0x43, 0x3005), 2201 {} 2202 }; 2203 2204 switch (action) { 2205 case HDA_FIXUP_ACT_PRE_PROBE: 2206 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1); 2207 snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1); 2208 break; 2209 case HDA_FIXUP_ACT_INIT: 2210 alc_process_coef_fw(codec, gb_x570_coefs); 2211 break; 2212 } 2213 } 2214 2215 static void alc1220_fixup_clevo_p950(struct hda_codec *codec, 2216 const struct hda_fixup *fix, 2217 int action) 2218 { 2219 static const hda_nid_t conn1[] = { 0x0c }; 2220 2221 if (action != HDA_FIXUP_ACT_PRE_PROBE) 2222 return; 2223 2224 alc_update_coef_idx(codec, 0x7, 0, 0x3c3); 2225 /* We therefore want to make sure 0x14 (front headphone) and 2226 * 0x1b (speakers) use the stereo DAC 0x02 2227 */ 2228 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1); 2229 snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1); 2230 } 2231 2232 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec, 2233 const struct hda_fixup *fix, int action); 2234 2235 static void alc1220_fixup_clevo_pb51ed(struct hda_codec *codec, 2236 const struct hda_fixup *fix, 2237 int action) 2238 { 2239 alc1220_fixup_clevo_p950(codec, fix, action); 2240 alc_fixup_headset_mode_no_hp_mic(codec, fix, action); 2241 } 2242 2243 static void alc887_asus_hp_automute_hook(struct hda_codec *codec, 2244 struct hda_jack_callback *jack) 2245 { 2246 struct alc_spec *spec = codec->spec; 2247 unsigned int vref; 2248 2249 snd_hda_gen_hp_automute(codec, jack); 2250 2251 if (spec->gen.hp_jack_present) 2252 vref = AC_PINCTL_VREF_80; 2253 else 2254 vref = AC_PINCTL_VREF_HIZ; 2255 snd_hda_set_pin_ctl(codec, 0x19, PIN_HP | vref); 2256 } 2257 2258 static void alc887_fixup_asus_jack(struct hda_codec *codec, 2259 const struct hda_fixup *fix, int action) 2260 { 2261 struct alc_spec *spec = codec->spec; 2262 if (action != HDA_FIXUP_ACT_PROBE) 2263 return; 2264 snd_hda_set_pin_ctl_cache(codec, 0x1b, PIN_HP); 2265 spec->gen.hp_automute_hook = alc887_asus_hp_automute_hook; 2266 } 2267 2268 static const struct hda_fixup alc882_fixups[] = { 2269 [ALC882_FIXUP_ABIT_AW9D_MAX] = { 2270 .type = HDA_FIXUP_PINS, 2271 .v.pins = (const struct hda_pintbl[]) { 2272 { 0x15, 0x01080104 }, /* side */ 2273 { 0x16, 0x01011012 }, /* rear */ 2274 { 0x17, 0x01016011 }, /* clfe */ 2275 { } 2276 } 2277 }, 2278 [ALC882_FIXUP_LENOVO_Y530] = { 2279 .type = HDA_FIXUP_PINS, 2280 .v.pins = (const struct hda_pintbl[]) { 2281 { 0x15, 0x99130112 }, /* rear int speakers */ 2282 { 0x16, 0x99130111 }, /* subwoofer */ 2283 { } 2284 } 2285 }, 2286 [ALC882_FIXUP_PB_M5210] = { 2287 .type = HDA_FIXUP_PINCTLS, 2288 .v.pins = (const struct hda_pintbl[]) { 2289 { 0x19, PIN_VREF50 }, 2290 {} 2291 } 2292 }, 2293 [ALC882_FIXUP_ACER_ASPIRE_7736] = { 2294 .type = HDA_FIXUP_FUNC, 2295 .v.func = alc_fixup_sku_ignore, 2296 }, 2297 [ALC882_FIXUP_ASUS_W90V] = { 2298 .type = HDA_FIXUP_PINS, 2299 .v.pins = (const struct hda_pintbl[]) { 2300 { 0x16, 0x99130110 }, /* fix sequence for CLFE */ 2301 { } 2302 } 2303 }, 2304 [ALC889_FIXUP_CD] = { 2305 .type = HDA_FIXUP_PINS, 2306 .v.pins = (const struct hda_pintbl[]) { 2307 { 0x1c, 0x993301f0 }, /* CD */ 2308 { } 2309 } 2310 }, 2311 [ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = { 2312 .type = HDA_FIXUP_PINS, 2313 .v.pins = (const struct hda_pintbl[]) { 2314 { 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */ 2315 { } 2316 }, 2317 .chained = true, 2318 .chain_id = ALC889_FIXUP_CD, 2319 }, 2320 [ALC889_FIXUP_VAIO_TT] = { 2321 .type = HDA_FIXUP_PINS, 2322 .v.pins = (const struct hda_pintbl[]) { 2323 { 0x17, 0x90170111 }, /* hidden surround speaker */ 2324 { } 2325 } 2326 }, 2327 [ALC888_FIXUP_EEE1601] = { 2328 .type = HDA_FIXUP_VERBS, 2329 .v.verbs = (const struct hda_verb[]) { 2330 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b }, 2331 { 0x20, AC_VERB_SET_PROC_COEF, 0x0838 }, 2332 { } 2333 } 2334 }, 2335 [ALC886_FIXUP_EAPD] = { 2336 .type = HDA_FIXUP_VERBS, 2337 .v.verbs = (const struct hda_verb[]) { 2338 /* change to EAPD mode */ 2339 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2340 { 0x20, AC_VERB_SET_PROC_COEF, 0x0068 }, 2341 { } 2342 } 2343 }, 2344 [ALC882_FIXUP_EAPD] = { 2345 .type = HDA_FIXUP_VERBS, 2346 .v.verbs = (const struct hda_verb[]) { 2347 /* change to EAPD mode */ 2348 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2349 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 }, 2350 { } 2351 } 2352 }, 2353 [ALC883_FIXUP_EAPD] = { 2354 .type = HDA_FIXUP_VERBS, 2355 .v.verbs = (const struct hda_verb[]) { 2356 /* change to EAPD mode */ 2357 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2358 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 }, 2359 { } 2360 } 2361 }, 2362 [ALC883_FIXUP_ACER_EAPD] = { 2363 .type = HDA_FIXUP_VERBS, 2364 .v.verbs = (const struct hda_verb[]) { 2365 /* eanable EAPD on Acer laptops */ 2366 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2367 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 }, 2368 { } 2369 } 2370 }, 2371 [ALC882_FIXUP_GPIO1] = { 2372 .type = HDA_FIXUP_FUNC, 2373 .v.func = alc_fixup_gpio1, 2374 }, 2375 [ALC882_FIXUP_GPIO2] = { 2376 .type = HDA_FIXUP_FUNC, 2377 .v.func = alc_fixup_gpio2, 2378 }, 2379 [ALC882_FIXUP_GPIO3] = { 2380 .type = HDA_FIXUP_FUNC, 2381 .v.func = alc_fixup_gpio3, 2382 }, 2383 [ALC882_FIXUP_ASUS_W2JC] = { 2384 .type = HDA_FIXUP_FUNC, 2385 .v.func = alc_fixup_gpio1, 2386 .chained = true, 2387 .chain_id = ALC882_FIXUP_EAPD, 2388 }, 2389 [ALC889_FIXUP_COEF] = { 2390 .type = HDA_FIXUP_FUNC, 2391 .v.func = alc889_fixup_coef, 2392 }, 2393 [ALC882_FIXUP_ACER_ASPIRE_4930G] = { 2394 .type = HDA_FIXUP_PINS, 2395 .v.pins = (const struct hda_pintbl[]) { 2396 { 0x16, 0x99130111 }, /* CLFE speaker */ 2397 { 0x17, 0x99130112 }, /* surround speaker */ 2398 { } 2399 }, 2400 .chained = true, 2401 .chain_id = ALC882_FIXUP_GPIO1, 2402 }, 2403 [ALC882_FIXUP_ACER_ASPIRE_8930G] = { 2404 .type = HDA_FIXUP_PINS, 2405 .v.pins = (const struct hda_pintbl[]) { 2406 { 0x16, 0x99130111 }, /* CLFE speaker */ 2407 { 0x1b, 0x99130112 }, /* surround speaker */ 2408 { } 2409 }, 2410 .chained = true, 2411 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS, 2412 }, 2413 [ALC882_FIXUP_ASPIRE_8930G_VERBS] = { 2414 /* additional init verbs for Acer Aspire 8930G */ 2415 .type = HDA_FIXUP_VERBS, 2416 .v.verbs = (const struct hda_verb[]) { 2417 /* Enable all DACs */ 2418 /* DAC DISABLE/MUTE 1? */ 2419 /* setting bits 1-5 disables DAC nids 0x02-0x06 2420 * apparently. Init=0x38 */ 2421 { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 }, 2422 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 }, 2423 /* DAC DISABLE/MUTE 2? */ 2424 /* some bit here disables the other DACs. 2425 * Init=0x4900 */ 2426 { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 }, 2427 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 }, 2428 /* DMIC fix 2429 * This laptop has a stereo digital microphone. 2430 * The mics are only 1cm apart which makes the stereo 2431 * useless. However, either the mic or the ALC889 2432 * makes the signal become a difference/sum signal 2433 * instead of standard stereo, which is annoying. 2434 * So instead we flip this bit which makes the 2435 * codec replicate the sum signal to both channels, 2436 * turning it into a normal mono mic. 2437 */ 2438 /* DMIC_CONTROL? Init value = 0x0001 */ 2439 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b }, 2440 { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 }, 2441 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2442 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 }, 2443 { } 2444 }, 2445 .chained = true, 2446 .chain_id = ALC882_FIXUP_GPIO1, 2447 }, 2448 [ALC885_FIXUP_MACPRO_GPIO] = { 2449 .type = HDA_FIXUP_FUNC, 2450 .v.func = alc885_fixup_macpro_gpio, 2451 }, 2452 [ALC889_FIXUP_DAC_ROUTE] = { 2453 .type = HDA_FIXUP_FUNC, 2454 .v.func = alc889_fixup_dac_route, 2455 }, 2456 [ALC889_FIXUP_MBP_VREF] = { 2457 .type = HDA_FIXUP_FUNC, 2458 .v.func = alc889_fixup_mbp_vref, 2459 .chained = true, 2460 .chain_id = ALC882_FIXUP_GPIO1, 2461 }, 2462 [ALC889_FIXUP_IMAC91_VREF] = { 2463 .type = HDA_FIXUP_FUNC, 2464 .v.func = alc889_fixup_imac91_vref, 2465 .chained = true, 2466 .chain_id = ALC882_FIXUP_GPIO1, 2467 }, 2468 [ALC889_FIXUP_MBA11_VREF] = { 2469 .type = HDA_FIXUP_FUNC, 2470 .v.func = alc889_fixup_mba11_vref, 2471 .chained = true, 2472 .chain_id = ALC889_FIXUP_MBP_VREF, 2473 }, 2474 [ALC889_FIXUP_MBA21_VREF] = { 2475 .type = HDA_FIXUP_FUNC, 2476 .v.func = alc889_fixup_mba21_vref, 2477 .chained = true, 2478 .chain_id = ALC889_FIXUP_MBP_VREF, 2479 }, 2480 [ALC889_FIXUP_MP11_VREF] = { 2481 .type = HDA_FIXUP_FUNC, 2482 .v.func = alc889_fixup_mba11_vref, 2483 .chained = true, 2484 .chain_id = ALC885_FIXUP_MACPRO_GPIO, 2485 }, 2486 [ALC889_FIXUP_MP41_VREF] = { 2487 .type = HDA_FIXUP_FUNC, 2488 .v.func = alc889_fixup_mbp_vref, 2489 .chained = true, 2490 .chain_id = ALC885_FIXUP_MACPRO_GPIO, 2491 }, 2492 [ALC882_FIXUP_INV_DMIC] = { 2493 .type = HDA_FIXUP_FUNC, 2494 .v.func = alc_fixup_inv_dmic, 2495 }, 2496 [ALC882_FIXUP_NO_PRIMARY_HP] = { 2497 .type = HDA_FIXUP_FUNC, 2498 .v.func = alc882_fixup_no_primary_hp, 2499 }, 2500 [ALC887_FIXUP_ASUS_BASS] = { 2501 .type = HDA_FIXUP_PINS, 2502 .v.pins = (const struct hda_pintbl[]) { 2503 {0x16, 0x99130130}, /* bass speaker */ 2504 {} 2505 }, 2506 .chained = true, 2507 .chain_id = ALC887_FIXUP_BASS_CHMAP, 2508 }, 2509 [ALC887_FIXUP_BASS_CHMAP] = { 2510 .type = HDA_FIXUP_FUNC, 2511 .v.func = alc_fixup_bass_chmap, 2512 }, 2513 [ALC1220_FIXUP_GB_DUAL_CODECS] = { 2514 .type = HDA_FIXUP_FUNC, 2515 .v.func = alc1220_fixup_gb_dual_codecs, 2516 }, 2517 [ALC1220_FIXUP_GB_X570] = { 2518 .type = HDA_FIXUP_FUNC, 2519 .v.func = alc1220_fixup_gb_x570, 2520 }, 2521 [ALC1220_FIXUP_CLEVO_P950] = { 2522 .type = HDA_FIXUP_FUNC, 2523 .v.func = alc1220_fixup_clevo_p950, 2524 }, 2525 [ALC1220_FIXUP_CLEVO_PB51ED] = { 2526 .type = HDA_FIXUP_FUNC, 2527 .v.func = alc1220_fixup_clevo_pb51ed, 2528 }, 2529 [ALC1220_FIXUP_CLEVO_PB51ED_PINS] = { 2530 .type = HDA_FIXUP_PINS, 2531 .v.pins = (const struct hda_pintbl[]) { 2532 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 2533 {} 2534 }, 2535 .chained = true, 2536 .chain_id = ALC1220_FIXUP_CLEVO_PB51ED, 2537 }, 2538 [ALC887_FIXUP_ASUS_AUDIO] = { 2539 .type = HDA_FIXUP_PINS, 2540 .v.pins = (const struct hda_pintbl[]) { 2541 { 0x15, 0x02a14150 }, /* use as headset mic, without its own jack detect */ 2542 { 0x19, 0x22219420 }, 2543 {} 2544 }, 2545 }, 2546 [ALC887_FIXUP_ASUS_HMIC] = { 2547 .type = HDA_FIXUP_FUNC, 2548 .v.func = alc887_fixup_asus_jack, 2549 .chained = true, 2550 .chain_id = ALC887_FIXUP_ASUS_AUDIO, 2551 }, 2552 [ALCS1200A_FIXUP_MIC_VREF] = { 2553 .type = HDA_FIXUP_PINCTLS, 2554 .v.pins = (const struct hda_pintbl[]) { 2555 { 0x18, PIN_VREF50 }, /* rear mic */ 2556 { 0x19, PIN_VREF50 }, /* front mic */ 2557 {} 2558 } 2559 }, 2560 [ALC888VD_FIXUP_MIC_100VREF] = { 2561 .type = HDA_FIXUP_PINCTLS, 2562 .v.pins = (const struct hda_pintbl[]) { 2563 { 0x18, PIN_VREF100 }, /* headset mic */ 2564 {} 2565 } 2566 }, 2567 }; 2568 2569 static const struct hda_quirk alc882_fixup_tbl[] = { 2570 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD), 2571 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD), 2572 SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD), 2573 SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD), 2574 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD), 2575 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD), 2576 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD), 2577 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G", 2578 ALC882_FIXUP_ACER_ASPIRE_4930G), 2579 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G", 2580 ALC882_FIXUP_ACER_ASPIRE_4930G), 2581 SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G", 2582 ALC882_FIXUP_ACER_ASPIRE_8930G), 2583 SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G", 2584 ALC882_FIXUP_ACER_ASPIRE_8930G), 2585 SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G", 2586 ALC882_FIXUP_ACER_ASPIRE_4930G), 2587 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210), 2588 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G", 2589 ALC882_FIXUP_ACER_ASPIRE_4930G), 2590 SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G", 2591 ALC882_FIXUP_ACER_ASPIRE_4930G), 2592 SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G", 2593 ALC882_FIXUP_ACER_ASPIRE_4930G), 2594 SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE), 2595 SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G), 2596 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736), 2597 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD), 2598 SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V), 2599 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC), 2600 SND_PCI_QUIRK(0x1043, 0x2390, "Asus D700SA", ALC887_FIXUP_ASUS_HMIC), 2601 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601), 2602 SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS), 2603 SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3), 2604 SND_PCI_QUIRK(0x1043, 0x8797, "ASUS TUF B550M-PLUS", ALCS1200A_FIXUP_MIC_VREF), 2605 SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP), 2606 SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP), 2607 SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT), 2608 SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP), 2609 SND_PCI_QUIRK(0x104d, 0x9060, "Sony Vaio VPCL14M1R", ALC882_FIXUP_NO_PRIMARY_HP), 2610 2611 /* All Apple entries are in codec SSIDs */ 2612 SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF), 2613 SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF), 2614 SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF), 2615 SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF), 2616 SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO), 2617 SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO), 2618 SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF), 2619 SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF), 2620 SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD), 2621 SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF), 2622 SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF), 2623 SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF), 2624 SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF), 2625 SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO), 2626 SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF), 2627 SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF), 2628 SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF), 2629 SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF), 2630 SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF), 2631 SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF), 2632 SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF), 2633 SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF), 2634 2635 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD), 2636 SND_PCI_QUIRK(0x10ec, 0x12d8, "iBase Elo Touch", ALC888VD_FIXUP_MIC_100VREF), 2637 SND_PCI_QUIRK(0x13fe, 0x1009, "Advantech MIT-W101", ALC886_FIXUP_EAPD), 2638 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE), 2639 SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS), 2640 SND_PCI_QUIRK(0x1458, 0xa0cd, "Gigabyte X570 Aorus Master", ALC1220_FIXUP_GB_X570), 2641 SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_GB_X570), 2642 SND_PCI_QUIRK(0x1458, 0xa0d5, "Gigabyte X570S Aorus Master", ALC1220_FIXUP_GB_X570), 2643 SND_PCI_QUIRK(0x1462, 0x11f7, "MSI-GE63", ALC1220_FIXUP_CLEVO_P950), 2644 SND_PCI_QUIRK(0x1462, 0x1228, "MSI-GP63", ALC1220_FIXUP_CLEVO_P950), 2645 SND_PCI_QUIRK(0x1462, 0x1229, "MSI-GP73", ALC1220_FIXUP_CLEVO_P950), 2646 SND_PCI_QUIRK(0x1462, 0x1275, "MSI-GL63", ALC1220_FIXUP_CLEVO_P950), 2647 SND_PCI_QUIRK(0x1462, 0x1276, "MSI-GL73", ALC1220_FIXUP_CLEVO_P950), 2648 SND_PCI_QUIRK(0x1462, 0x1293, "MSI-GP65", ALC1220_FIXUP_CLEVO_P950), 2649 SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD), 2650 SND_PCI_QUIRK(0x1462, 0xcc34, "MSI Godlike X570", ALC1220_FIXUP_GB_DUAL_CODECS), 2651 SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS), 2652 SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3), 2653 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX), 2654 SND_PCI_QUIRK(0x1558, 0x3702, "Clevo X370SN[VW]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2655 SND_PCI_QUIRK(0x1558, 0x50d3, "Clevo PC50[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2656 SND_PCI_QUIRK(0x1558, 0x65d1, "Clevo PB51[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2657 SND_PCI_QUIRK(0x1558, 0x65d2, "Clevo PB51R[CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2658 SND_PCI_QUIRK(0x1558, 0x65e1, "Clevo PB51[ED][DF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2659 SND_PCI_QUIRK(0x1558, 0x65e5, "Clevo PC50D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2660 SND_PCI_QUIRK(0x1558, 0x65f1, "Clevo PC50HS", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2661 SND_PCI_QUIRK(0x1558, 0x65f5, "Clevo PD50PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2662 SND_PCI_QUIRK(0x1558, 0x66a2, "Clevo PE60RNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2663 SND_PCI_QUIRK(0x1558, 0x66a6, "Clevo PE60SN[CDE]-[GS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2664 SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2665 SND_PCI_QUIRK(0x1558, 0x67e1, "Clevo PB71[DE][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2666 SND_PCI_QUIRK(0x1558, 0x67e5, "Clevo PC70D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2667 SND_PCI_QUIRK(0x1558, 0x67f1, "Clevo PC70H[PRS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2668 SND_PCI_QUIRK(0x1558, 0x67f5, "Clevo PD70PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2669 SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2670 SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170SM", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2671 SND_PCI_QUIRK(0x1558, 0x7715, "Clevo X170KM-G", ALC1220_FIXUP_CLEVO_PB51ED), 2672 SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950), 2673 SND_PCI_QUIRK(0x1558, 0x9506, "Clevo P955HQ", ALC1220_FIXUP_CLEVO_P950), 2674 SND_PCI_QUIRK(0x1558, 0x950a, "Clevo P955H[PR]", ALC1220_FIXUP_CLEVO_P950), 2675 SND_PCI_QUIRK(0x1558, 0x95e1, "Clevo P95xER", ALC1220_FIXUP_CLEVO_P950), 2676 SND_PCI_QUIRK(0x1558, 0x95e2, "Clevo P950ER", ALC1220_FIXUP_CLEVO_P950), 2677 SND_PCI_QUIRK(0x1558, 0x95e3, "Clevo P955[ER]T", ALC1220_FIXUP_CLEVO_P950), 2678 SND_PCI_QUIRK(0x1558, 0x95e4, "Clevo P955ER", ALC1220_FIXUP_CLEVO_P950), 2679 SND_PCI_QUIRK(0x1558, 0x95e5, "Clevo P955EE6", ALC1220_FIXUP_CLEVO_P950), 2680 SND_PCI_QUIRK(0x1558, 0x95e6, "Clevo P950R[CDF]", ALC1220_FIXUP_CLEVO_P950), 2681 SND_PCI_QUIRK(0x1558, 0x96e1, "Clevo P960[ER][CDFN]-K", ALC1220_FIXUP_CLEVO_P950), 2682 SND_PCI_QUIRK(0x1558, 0x97e1, "Clevo P970[ER][CDFN]", ALC1220_FIXUP_CLEVO_P950), 2683 SND_PCI_QUIRK(0x1558, 0x97e2, "Clevo P970RC-M", ALC1220_FIXUP_CLEVO_P950), 2684 SND_PCI_QUIRK(0x1558, 0xd502, "Clevo PD50SNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2685 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD), 2686 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD), 2687 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530), 2688 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF), 2689 {} 2690 }; 2691 2692 static const struct hda_model_fixup alc882_fixup_models[] = { 2693 {.id = ALC882_FIXUP_ABIT_AW9D_MAX, .name = "abit-aw9d"}, 2694 {.id = ALC882_FIXUP_LENOVO_Y530, .name = "lenovo-y530"}, 2695 {.id = ALC882_FIXUP_ACER_ASPIRE_7736, .name = "acer-aspire-7736"}, 2696 {.id = ALC882_FIXUP_ASUS_W90V, .name = "asus-w90v"}, 2697 {.id = ALC889_FIXUP_CD, .name = "cd"}, 2698 {.id = ALC889_FIXUP_FRONT_HP_NO_PRESENCE, .name = "no-front-hp"}, 2699 {.id = ALC889_FIXUP_VAIO_TT, .name = "vaio-tt"}, 2700 {.id = ALC888_FIXUP_EEE1601, .name = "eee1601"}, 2701 {.id = ALC882_FIXUP_EAPD, .name = "alc882-eapd"}, 2702 {.id = ALC883_FIXUP_EAPD, .name = "alc883-eapd"}, 2703 {.id = ALC882_FIXUP_GPIO1, .name = "gpio1"}, 2704 {.id = ALC882_FIXUP_GPIO2, .name = "gpio2"}, 2705 {.id = ALC882_FIXUP_GPIO3, .name = "gpio3"}, 2706 {.id = ALC889_FIXUP_COEF, .name = "alc889-coef"}, 2707 {.id = ALC882_FIXUP_ASUS_W2JC, .name = "asus-w2jc"}, 2708 {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"}, 2709 {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"}, 2710 {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"}, 2711 {.id = ALC885_FIXUP_MACPRO_GPIO, .name = "macpro-gpio"}, 2712 {.id = ALC889_FIXUP_DAC_ROUTE, .name = "dac-route"}, 2713 {.id = ALC889_FIXUP_MBP_VREF, .name = "mbp-vref"}, 2714 {.id = ALC889_FIXUP_IMAC91_VREF, .name = "imac91-vref"}, 2715 {.id = ALC889_FIXUP_MBA11_VREF, .name = "mba11-vref"}, 2716 {.id = ALC889_FIXUP_MBA21_VREF, .name = "mba21-vref"}, 2717 {.id = ALC889_FIXUP_MP11_VREF, .name = "mp11-vref"}, 2718 {.id = ALC889_FIXUP_MP41_VREF, .name = "mp41-vref"}, 2719 {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"}, 2720 {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"}, 2721 {.id = ALC887_FIXUP_ASUS_BASS, .name = "asus-bass"}, 2722 {.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"}, 2723 {.id = ALC1220_FIXUP_GB_X570, .name = "gb-x570"}, 2724 {.id = ALC1220_FIXUP_CLEVO_P950, .name = "clevo-p950"}, 2725 {} 2726 }; 2727 2728 static const struct snd_hda_pin_quirk alc882_pin_fixup_tbl[] = { 2729 SND_HDA_PIN_QUIRK(0x10ec1220, 0x1043, "ASUS", ALC1220_FIXUP_CLEVO_P950, 2730 {0x14, 0x01014010}, 2731 {0x15, 0x01011012}, 2732 {0x16, 0x01016011}, 2733 {0x18, 0x01a19040}, 2734 {0x19, 0x02a19050}, 2735 {0x1a, 0x0181304f}, 2736 {0x1b, 0x0221401f}, 2737 {0x1e, 0x01456130}), 2738 SND_HDA_PIN_QUIRK(0x10ec1220, 0x1462, "MS-7C35", ALC1220_FIXUP_CLEVO_P950, 2739 {0x14, 0x01015010}, 2740 {0x15, 0x01011012}, 2741 {0x16, 0x01011011}, 2742 {0x18, 0x01a11040}, 2743 {0x19, 0x02a19050}, 2744 {0x1a, 0x0181104f}, 2745 {0x1b, 0x0221401f}, 2746 {0x1e, 0x01451130}), 2747 {} 2748 }; 2749 2750 /* 2751 * BIOS auto configuration 2752 */ 2753 /* almost identical with ALC880 parser... */ 2754 static int alc882_parse_auto_config(struct hda_codec *codec) 2755 { 2756 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 }; 2757 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 2758 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids); 2759 } 2760 2761 /* 2762 */ 2763 static int patch_alc882(struct hda_codec *codec) 2764 { 2765 struct alc_spec *spec; 2766 int err; 2767 2768 err = alc_alloc_spec(codec, 0x0b); 2769 if (err < 0) 2770 return err; 2771 2772 spec = codec->spec; 2773 2774 switch (codec->core.vendor_id) { 2775 case 0x10ec0882: 2776 case 0x10ec0885: 2777 case 0x10ec0900: 2778 case 0x10ec0b00: 2779 case 0x10ec1220: 2780 break; 2781 default: 2782 /* ALC883 and variants */ 2783 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 2784 break; 2785 } 2786 2787 alc_pre_init(codec); 2788 2789 snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl, 2790 alc882_fixups); 2791 snd_hda_pick_pin_fixup(codec, alc882_pin_fixup_tbl, alc882_fixups, true); 2792 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 2793 2794 alc_auto_parse_customize_define(codec); 2795 2796 if (has_cdefine_beep(codec)) 2797 spec->gen.beep_nid = 0x01; 2798 2799 /* automatic parse from the BIOS config */ 2800 err = alc882_parse_auto_config(codec); 2801 if (err < 0) 2802 goto error; 2803 2804 if (!spec->gen.no_analog && spec->gen.beep_nid) { 2805 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 2806 if (err < 0) 2807 goto error; 2808 } 2809 2810 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 2811 2812 return 0; 2813 2814 error: 2815 alc_free(codec); 2816 return err; 2817 } 2818 2819 2820 /* 2821 * ALC262 support 2822 */ 2823 static int alc262_parse_auto_config(struct hda_codec *codec) 2824 { 2825 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 }; 2826 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 2827 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids); 2828 } 2829 2830 /* 2831 * Pin config fixes 2832 */ 2833 enum { 2834 ALC262_FIXUP_FSC_H270, 2835 ALC262_FIXUP_FSC_S7110, 2836 ALC262_FIXUP_HP_Z200, 2837 ALC262_FIXUP_TYAN, 2838 ALC262_FIXUP_LENOVO_3000, 2839 ALC262_FIXUP_BENQ, 2840 ALC262_FIXUP_BENQ_T31, 2841 ALC262_FIXUP_INV_DMIC, 2842 ALC262_FIXUP_INTEL_BAYLEYBAY, 2843 }; 2844 2845 static const struct hda_fixup alc262_fixups[] = { 2846 [ALC262_FIXUP_FSC_H270] = { 2847 .type = HDA_FIXUP_PINS, 2848 .v.pins = (const struct hda_pintbl[]) { 2849 { 0x14, 0x99130110 }, /* speaker */ 2850 { 0x15, 0x0221142f }, /* front HP */ 2851 { 0x1b, 0x0121141f }, /* rear HP */ 2852 { } 2853 } 2854 }, 2855 [ALC262_FIXUP_FSC_S7110] = { 2856 .type = HDA_FIXUP_PINS, 2857 .v.pins = (const struct hda_pintbl[]) { 2858 { 0x15, 0x90170110 }, /* speaker */ 2859 { } 2860 }, 2861 .chained = true, 2862 .chain_id = ALC262_FIXUP_BENQ, 2863 }, 2864 [ALC262_FIXUP_HP_Z200] = { 2865 .type = HDA_FIXUP_PINS, 2866 .v.pins = (const struct hda_pintbl[]) { 2867 { 0x16, 0x99130120 }, /* internal speaker */ 2868 { } 2869 } 2870 }, 2871 [ALC262_FIXUP_TYAN] = { 2872 .type = HDA_FIXUP_PINS, 2873 .v.pins = (const struct hda_pintbl[]) { 2874 { 0x14, 0x1993e1f0 }, /* int AUX */ 2875 { } 2876 } 2877 }, 2878 [ALC262_FIXUP_LENOVO_3000] = { 2879 .type = HDA_FIXUP_PINCTLS, 2880 .v.pins = (const struct hda_pintbl[]) { 2881 { 0x19, PIN_VREF50 }, 2882 {} 2883 }, 2884 .chained = true, 2885 .chain_id = ALC262_FIXUP_BENQ, 2886 }, 2887 [ALC262_FIXUP_BENQ] = { 2888 .type = HDA_FIXUP_VERBS, 2889 .v.verbs = (const struct hda_verb[]) { 2890 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2891 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 }, 2892 {} 2893 } 2894 }, 2895 [ALC262_FIXUP_BENQ_T31] = { 2896 .type = HDA_FIXUP_VERBS, 2897 .v.verbs = (const struct hda_verb[]) { 2898 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2899 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 }, 2900 {} 2901 } 2902 }, 2903 [ALC262_FIXUP_INV_DMIC] = { 2904 .type = HDA_FIXUP_FUNC, 2905 .v.func = alc_fixup_inv_dmic, 2906 }, 2907 [ALC262_FIXUP_INTEL_BAYLEYBAY] = { 2908 .type = HDA_FIXUP_FUNC, 2909 .v.func = alc_fixup_no_depop_delay, 2910 }, 2911 }; 2912 2913 static const struct hda_quirk alc262_fixup_tbl[] = { 2914 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200), 2915 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110), 2916 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ), 2917 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN), 2918 SND_PCI_QUIRK(0x1734, 0x1141, "FSC ESPRIMO U9210", ALC262_FIXUP_FSC_H270), 2919 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270), 2920 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000), 2921 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ), 2922 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31), 2923 SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY), 2924 {} 2925 }; 2926 2927 static const struct hda_model_fixup alc262_fixup_models[] = { 2928 {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"}, 2929 {.id = ALC262_FIXUP_FSC_H270, .name = "fsc-h270"}, 2930 {.id = ALC262_FIXUP_FSC_S7110, .name = "fsc-s7110"}, 2931 {.id = ALC262_FIXUP_HP_Z200, .name = "hp-z200"}, 2932 {.id = ALC262_FIXUP_TYAN, .name = "tyan"}, 2933 {.id = ALC262_FIXUP_LENOVO_3000, .name = "lenovo-3000"}, 2934 {.id = ALC262_FIXUP_BENQ, .name = "benq"}, 2935 {.id = ALC262_FIXUP_BENQ_T31, .name = "benq-t31"}, 2936 {.id = ALC262_FIXUP_INTEL_BAYLEYBAY, .name = "bayleybay"}, 2937 {} 2938 }; 2939 2940 /* 2941 */ 2942 static int patch_alc262(struct hda_codec *codec) 2943 { 2944 struct alc_spec *spec; 2945 int err; 2946 2947 err = alc_alloc_spec(codec, 0x0b); 2948 if (err < 0) 2949 return err; 2950 2951 spec = codec->spec; 2952 spec->gen.shared_mic_vref_pin = 0x18; 2953 2954 spec->shutup = alc_eapd_shutup; 2955 2956 #if 0 2957 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is 2958 * under-run 2959 */ 2960 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80); 2961 #endif 2962 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 2963 2964 alc_pre_init(codec); 2965 2966 snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl, 2967 alc262_fixups); 2968 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 2969 2970 alc_auto_parse_customize_define(codec); 2971 2972 if (has_cdefine_beep(codec)) 2973 spec->gen.beep_nid = 0x01; 2974 2975 /* automatic parse from the BIOS config */ 2976 err = alc262_parse_auto_config(codec); 2977 if (err < 0) 2978 goto error; 2979 2980 if (!spec->gen.no_analog && spec->gen.beep_nid) { 2981 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 2982 if (err < 0) 2983 goto error; 2984 } 2985 2986 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 2987 2988 return 0; 2989 2990 error: 2991 alc_free(codec); 2992 return err; 2993 } 2994 2995 /* 2996 * ALC268 2997 */ 2998 /* bind Beep switches of both NID 0x0f and 0x10 */ 2999 static int alc268_beep_switch_put(struct snd_kcontrol *kcontrol, 3000 struct snd_ctl_elem_value *ucontrol) 3001 { 3002 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3003 unsigned long pval; 3004 int err; 3005 3006 mutex_lock(&codec->control_mutex); 3007 pval = kcontrol->private_value; 3008 kcontrol->private_value = (pval & ~0xff) | 0x0f; 3009 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); 3010 if (err >= 0) { 3011 kcontrol->private_value = (pval & ~0xff) | 0x10; 3012 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); 3013 } 3014 kcontrol->private_value = pval; 3015 mutex_unlock(&codec->control_mutex); 3016 return err; 3017 } 3018 3019 static const struct snd_kcontrol_new alc268_beep_mixer[] = { 3020 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT), 3021 { 3022 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3023 .name = "Beep Playback Switch", 3024 .subdevice = HDA_SUBDEV_AMP_FLAG, 3025 .info = snd_hda_mixer_amp_switch_info, 3026 .get = snd_hda_mixer_amp_switch_get, 3027 .put = alc268_beep_switch_put, 3028 .private_value = HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT) 3029 }, 3030 }; 3031 3032 /* set PCBEEP vol = 0, mute connections */ 3033 static const struct hda_verb alc268_beep_init_verbs[] = { 3034 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3035 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 3036 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 3037 { } 3038 }; 3039 3040 enum { 3041 ALC268_FIXUP_INV_DMIC, 3042 ALC268_FIXUP_HP_EAPD, 3043 ALC268_FIXUP_SPDIF, 3044 }; 3045 3046 static const struct hda_fixup alc268_fixups[] = { 3047 [ALC268_FIXUP_INV_DMIC] = { 3048 .type = HDA_FIXUP_FUNC, 3049 .v.func = alc_fixup_inv_dmic, 3050 }, 3051 [ALC268_FIXUP_HP_EAPD] = { 3052 .type = HDA_FIXUP_VERBS, 3053 .v.verbs = (const struct hda_verb[]) { 3054 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0}, 3055 {} 3056 } 3057 }, 3058 [ALC268_FIXUP_SPDIF] = { 3059 .type = HDA_FIXUP_PINS, 3060 .v.pins = (const struct hda_pintbl[]) { 3061 { 0x1e, 0x014b1180 }, /* enable SPDIF out */ 3062 {} 3063 } 3064 }, 3065 }; 3066 3067 static const struct hda_model_fixup alc268_fixup_models[] = { 3068 {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"}, 3069 {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"}, 3070 {.id = ALC268_FIXUP_SPDIF, .name = "spdif"}, 3071 {} 3072 }; 3073 3074 static const struct hda_quirk alc268_fixup_tbl[] = { 3075 SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF), 3076 SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC), 3077 /* below is codec SSID since multiple Toshiba laptops have the 3078 * same PCI SSID 1179:ff00 3079 */ 3080 SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD), 3081 {} 3082 }; 3083 3084 /* 3085 * BIOS auto configuration 3086 */ 3087 static int alc268_parse_auto_config(struct hda_codec *codec) 3088 { 3089 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 3090 return alc_parse_auto_config(codec, NULL, alc268_ssids); 3091 } 3092 3093 /* 3094 */ 3095 static int patch_alc268(struct hda_codec *codec) 3096 { 3097 struct alc_spec *spec; 3098 int i, err; 3099 3100 /* ALC268 has no aa-loopback mixer */ 3101 err = alc_alloc_spec(codec, 0); 3102 if (err < 0) 3103 return err; 3104 3105 spec = codec->spec; 3106 if (has_cdefine_beep(codec)) 3107 spec->gen.beep_nid = 0x01; 3108 3109 spec->shutup = alc_eapd_shutup; 3110 3111 alc_pre_init(codec); 3112 3113 snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups); 3114 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 3115 3116 /* automatic parse from the BIOS config */ 3117 err = alc268_parse_auto_config(codec); 3118 if (err < 0) 3119 goto error; 3120 3121 if (err > 0 && !spec->gen.no_analog && 3122 spec->gen.autocfg.speaker_pins[0] != 0x1d) { 3123 for (i = 0; i < ARRAY_SIZE(alc268_beep_mixer); i++) { 3124 if (!snd_hda_gen_add_kctl(&spec->gen, NULL, 3125 &alc268_beep_mixer[i])) { 3126 err = -ENOMEM; 3127 goto error; 3128 } 3129 } 3130 snd_hda_add_verbs(codec, alc268_beep_init_verbs); 3131 if (!query_amp_caps(codec, 0x1d, HDA_INPUT)) 3132 /* override the amp caps for beep generator */ 3133 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT, 3134 (0x0c << AC_AMPCAP_OFFSET_SHIFT) | 3135 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) | 3136 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) | 3137 (0 << AC_AMPCAP_MUTE_SHIFT)); 3138 } 3139 3140 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 3141 3142 return 0; 3143 3144 error: 3145 alc_free(codec); 3146 return err; 3147 } 3148 3149 /* 3150 * ALC269 3151 */ 3152 3153 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = { 3154 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */ 3155 }; 3156 3157 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = { 3158 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */ 3159 }; 3160 3161 /* different alc269-variants */ 3162 enum { 3163 ALC269_TYPE_ALC269VA, 3164 ALC269_TYPE_ALC269VB, 3165 ALC269_TYPE_ALC269VC, 3166 ALC269_TYPE_ALC269VD, 3167 ALC269_TYPE_ALC280, 3168 ALC269_TYPE_ALC282, 3169 ALC269_TYPE_ALC283, 3170 ALC269_TYPE_ALC284, 3171 ALC269_TYPE_ALC293, 3172 ALC269_TYPE_ALC286, 3173 ALC269_TYPE_ALC298, 3174 ALC269_TYPE_ALC255, 3175 ALC269_TYPE_ALC256, 3176 ALC269_TYPE_ALC257, 3177 ALC269_TYPE_ALC215, 3178 ALC269_TYPE_ALC225, 3179 ALC269_TYPE_ALC245, 3180 ALC269_TYPE_ALC287, 3181 ALC269_TYPE_ALC294, 3182 ALC269_TYPE_ALC300, 3183 ALC269_TYPE_ALC623, 3184 ALC269_TYPE_ALC700, 3185 }; 3186 3187 /* 3188 * BIOS auto configuration 3189 */ 3190 static int alc269_parse_auto_config(struct hda_codec *codec) 3191 { 3192 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 }; 3193 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 }; 3194 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 3195 struct alc_spec *spec = codec->spec; 3196 const hda_nid_t *ssids; 3197 3198 switch (spec->codec_variant) { 3199 case ALC269_TYPE_ALC269VA: 3200 case ALC269_TYPE_ALC269VC: 3201 case ALC269_TYPE_ALC280: 3202 case ALC269_TYPE_ALC284: 3203 case ALC269_TYPE_ALC293: 3204 ssids = alc269va_ssids; 3205 break; 3206 case ALC269_TYPE_ALC269VB: 3207 case ALC269_TYPE_ALC269VD: 3208 case ALC269_TYPE_ALC282: 3209 case ALC269_TYPE_ALC283: 3210 case ALC269_TYPE_ALC286: 3211 case ALC269_TYPE_ALC298: 3212 case ALC269_TYPE_ALC255: 3213 case ALC269_TYPE_ALC256: 3214 case ALC269_TYPE_ALC257: 3215 case ALC269_TYPE_ALC215: 3216 case ALC269_TYPE_ALC225: 3217 case ALC269_TYPE_ALC245: 3218 case ALC269_TYPE_ALC287: 3219 case ALC269_TYPE_ALC294: 3220 case ALC269_TYPE_ALC300: 3221 case ALC269_TYPE_ALC623: 3222 case ALC269_TYPE_ALC700: 3223 ssids = alc269_ssids; 3224 break; 3225 default: 3226 ssids = alc269_ssids; 3227 break; 3228 } 3229 3230 return alc_parse_auto_config(codec, alc269_ignore, ssids); 3231 } 3232 3233 static const struct hda_jack_keymap alc_headset_btn_keymap[] = { 3234 { SND_JACK_BTN_0, KEY_PLAYPAUSE }, 3235 { SND_JACK_BTN_1, KEY_VOICECOMMAND }, 3236 { SND_JACK_BTN_2, KEY_VOLUMEUP }, 3237 { SND_JACK_BTN_3, KEY_VOLUMEDOWN }, 3238 {} 3239 }; 3240 3241 static void alc_headset_btn_callback(struct hda_codec *codec, 3242 struct hda_jack_callback *jack) 3243 { 3244 int report = 0; 3245 3246 if (jack->unsol_res & (7 << 13)) 3247 report |= SND_JACK_BTN_0; 3248 3249 if (jack->unsol_res & (1 << 16 | 3 << 8)) 3250 report |= SND_JACK_BTN_1; 3251 3252 /* Volume up key */ 3253 if (jack->unsol_res & (7 << 23)) 3254 report |= SND_JACK_BTN_2; 3255 3256 /* Volume down key */ 3257 if (jack->unsol_res & (7 << 10)) 3258 report |= SND_JACK_BTN_3; 3259 3260 snd_hda_jack_set_button_state(codec, jack->nid, report); 3261 } 3262 3263 static void alc_disable_headset_jack_key(struct hda_codec *codec) 3264 { 3265 struct alc_spec *spec = codec->spec; 3266 3267 if (!spec->has_hs_key) 3268 return; 3269 3270 switch (codec->core.vendor_id) { 3271 case 0x10ec0215: 3272 case 0x10ec0225: 3273 case 0x10ec0285: 3274 case 0x10ec0287: 3275 case 0x10ec0295: 3276 case 0x10ec0289: 3277 case 0x10ec0299: 3278 alc_write_coef_idx(codec, 0x48, 0x0); 3279 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0); 3280 alc_update_coef_idx(codec, 0x44, 0x0045 << 8, 0x0); 3281 break; 3282 case 0x10ec0230: 3283 case 0x10ec0236: 3284 case 0x10ec0256: 3285 case 0x10ec0257: 3286 case 0x19e58326: 3287 alc_write_coef_idx(codec, 0x48, 0x0); 3288 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0); 3289 break; 3290 } 3291 } 3292 3293 static void alc_enable_headset_jack_key(struct hda_codec *codec) 3294 { 3295 struct alc_spec *spec = codec->spec; 3296 3297 if (!spec->has_hs_key) 3298 return; 3299 3300 switch (codec->core.vendor_id) { 3301 case 0x10ec0215: 3302 case 0x10ec0225: 3303 case 0x10ec0285: 3304 case 0x10ec0287: 3305 case 0x10ec0295: 3306 case 0x10ec0289: 3307 case 0x10ec0299: 3308 alc_write_coef_idx(codec, 0x48, 0xd011); 3309 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045); 3310 alc_update_coef_idx(codec, 0x44, 0x007f << 8, 0x0045 << 8); 3311 break; 3312 case 0x10ec0230: 3313 case 0x10ec0236: 3314 case 0x10ec0256: 3315 case 0x10ec0257: 3316 case 0x19e58326: 3317 alc_write_coef_idx(codec, 0x48, 0xd011); 3318 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045); 3319 break; 3320 } 3321 } 3322 3323 static void alc_fixup_headset_jack(struct hda_codec *codec, 3324 const struct hda_fixup *fix, int action) 3325 { 3326 struct alc_spec *spec = codec->spec; 3327 hda_nid_t hp_pin; 3328 3329 switch (action) { 3330 case HDA_FIXUP_ACT_PRE_PROBE: 3331 spec->has_hs_key = 1; 3332 snd_hda_jack_detect_enable_callback(codec, 0x55, 3333 alc_headset_btn_callback); 3334 break; 3335 case HDA_FIXUP_ACT_BUILD: 3336 hp_pin = alc_get_hp_pin(spec); 3337 if (!hp_pin || snd_hda_jack_bind_keymap(codec, 0x55, 3338 alc_headset_btn_keymap, 3339 hp_pin)) 3340 snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack", 3341 false, SND_JACK_HEADSET, 3342 alc_headset_btn_keymap); 3343 3344 alc_enable_headset_jack_key(codec); 3345 break; 3346 } 3347 } 3348 3349 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up) 3350 { 3351 alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0); 3352 } 3353 3354 static void alc269_shutup(struct hda_codec *codec) 3355 { 3356 struct alc_spec *spec = codec->spec; 3357 3358 if (spec->codec_variant == ALC269_TYPE_ALC269VB) 3359 alc269vb_toggle_power_output(codec, 0); 3360 if (spec->codec_variant == ALC269_TYPE_ALC269VB && 3361 (alc_get_coef0(codec) & 0x00ff) == 0x018) { 3362 msleep(150); 3363 } 3364 alc_shutup_pins(codec); 3365 } 3366 3367 static const struct coef_fw alc282_coefs[] = { 3368 WRITE_COEF(0x03, 0x0002), /* Power Down Control */ 3369 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */ 3370 WRITE_COEF(0x07, 0x0200), /* DMIC control */ 3371 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */ 3372 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */ 3373 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */ 3374 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */ 3375 WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */ 3376 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */ 3377 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */ 3378 WRITE_COEF(0x6f, 0x0), /* Class D test 4 */ 3379 UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */ 3380 WRITE_COEF(0x34, 0xa0c0), /* ANC */ 3381 UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */ 3382 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */ 3383 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */ 3384 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */ 3385 WRITE_COEF(0x63, 0x2902), /* PLL */ 3386 WRITE_COEF(0x68, 0xa080), /* capless control 2 */ 3387 WRITE_COEF(0x69, 0x3400), /* capless control 3 */ 3388 WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */ 3389 WRITE_COEF(0x6b, 0x0), /* capless control 5 */ 3390 UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */ 3391 WRITE_COEF(0x6e, 0x110a), /* class D test 3 */ 3392 UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */ 3393 WRITE_COEF(0x71, 0x0014), /* class D test 6 */ 3394 WRITE_COEF(0x72, 0xc2ba), /* classD OCP */ 3395 UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */ 3396 WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */ 3397 {} 3398 }; 3399 3400 static void alc282_restore_default_value(struct hda_codec *codec) 3401 { 3402 alc_process_coef_fw(codec, alc282_coefs); 3403 } 3404 3405 static void alc282_init(struct hda_codec *codec) 3406 { 3407 struct alc_spec *spec = codec->spec; 3408 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3409 bool hp_pin_sense; 3410 int coef78; 3411 3412 alc282_restore_default_value(codec); 3413 3414 if (!hp_pin) 3415 return; 3416 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3417 coef78 = alc_read_coef_idx(codec, 0x78); 3418 3419 /* Index 0x78 Direct Drive HP AMP LPM Control 1 */ 3420 /* Headphone capless set to high power mode */ 3421 alc_write_coef_idx(codec, 0x78, 0x9004); 3422 3423 if (hp_pin_sense) 3424 msleep(2); 3425 3426 snd_hda_codec_write(codec, hp_pin, 0, 3427 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3428 3429 if (hp_pin_sense) 3430 msleep(85); 3431 3432 snd_hda_codec_write(codec, hp_pin, 0, 3433 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3434 3435 if (hp_pin_sense) 3436 msleep(100); 3437 3438 /* Headphone capless set to normal mode */ 3439 alc_write_coef_idx(codec, 0x78, coef78); 3440 } 3441 3442 static void alc282_shutup(struct hda_codec *codec) 3443 { 3444 struct alc_spec *spec = codec->spec; 3445 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3446 bool hp_pin_sense; 3447 int coef78; 3448 3449 if (!hp_pin) { 3450 alc269_shutup(codec); 3451 return; 3452 } 3453 3454 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3455 coef78 = alc_read_coef_idx(codec, 0x78); 3456 alc_write_coef_idx(codec, 0x78, 0x9004); 3457 3458 if (hp_pin_sense) 3459 msleep(2); 3460 3461 snd_hda_codec_write(codec, hp_pin, 0, 3462 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3463 3464 if (hp_pin_sense) 3465 msleep(85); 3466 3467 if (!spec->no_shutup_pins) 3468 snd_hda_codec_write(codec, hp_pin, 0, 3469 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3470 3471 if (hp_pin_sense) 3472 msleep(100); 3473 3474 alc_auto_setup_eapd(codec, false); 3475 alc_shutup_pins(codec); 3476 alc_write_coef_idx(codec, 0x78, coef78); 3477 } 3478 3479 static const struct coef_fw alc283_coefs[] = { 3480 WRITE_COEF(0x03, 0x0002), /* Power Down Control */ 3481 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */ 3482 WRITE_COEF(0x07, 0x0200), /* DMIC control */ 3483 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */ 3484 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */ 3485 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */ 3486 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */ 3487 WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */ 3488 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */ 3489 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */ 3490 WRITE_COEF(0x3a, 0x0), /* Class D test 4 */ 3491 UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */ 3492 WRITE_COEF(0x22, 0xa0c0), /* ANC */ 3493 UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */ 3494 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */ 3495 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */ 3496 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */ 3497 WRITE_COEF(0x2e, 0x2902), /* PLL */ 3498 WRITE_COEF(0x33, 0xa080), /* capless control 2 */ 3499 WRITE_COEF(0x34, 0x3400), /* capless control 3 */ 3500 WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */ 3501 WRITE_COEF(0x36, 0x0), /* capless control 5 */ 3502 UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */ 3503 WRITE_COEF(0x39, 0x110a), /* class D test 3 */ 3504 UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */ 3505 WRITE_COEF(0x3c, 0x0014), /* class D test 6 */ 3506 WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */ 3507 UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */ 3508 WRITE_COEF(0x49, 0x0), /* test mode */ 3509 UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */ 3510 UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */ 3511 WRITE_COEF(0x37, 0xfc06), /* Class D amp control */ 3512 UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */ 3513 {} 3514 }; 3515 3516 static void alc283_restore_default_value(struct hda_codec *codec) 3517 { 3518 alc_process_coef_fw(codec, alc283_coefs); 3519 } 3520 3521 static void alc283_init(struct hda_codec *codec) 3522 { 3523 struct alc_spec *spec = codec->spec; 3524 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3525 bool hp_pin_sense; 3526 3527 alc283_restore_default_value(codec); 3528 3529 if (!hp_pin) 3530 return; 3531 3532 msleep(30); 3533 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3534 3535 /* Index 0x43 Direct Drive HP AMP LPM Control 1 */ 3536 /* Headphone capless set to high power mode */ 3537 alc_write_coef_idx(codec, 0x43, 0x9004); 3538 3539 snd_hda_codec_write(codec, hp_pin, 0, 3540 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3541 3542 if (hp_pin_sense) 3543 msleep(85); 3544 3545 snd_hda_codec_write(codec, hp_pin, 0, 3546 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3547 3548 if (hp_pin_sense) 3549 msleep(85); 3550 /* Index 0x46 Combo jack auto switch control 2 */ 3551 /* 3k pull low control for Headset jack. */ 3552 alc_update_coef_idx(codec, 0x46, 3 << 12, 0); 3553 /* Headphone capless set to normal mode */ 3554 alc_write_coef_idx(codec, 0x43, 0x9614); 3555 } 3556 3557 static void alc283_shutup(struct hda_codec *codec) 3558 { 3559 struct alc_spec *spec = codec->spec; 3560 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3561 bool hp_pin_sense; 3562 3563 if (!hp_pin) { 3564 alc269_shutup(codec); 3565 return; 3566 } 3567 3568 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3569 3570 alc_write_coef_idx(codec, 0x43, 0x9004); 3571 3572 /*depop hp during suspend*/ 3573 alc_write_coef_idx(codec, 0x06, 0x2100); 3574 3575 snd_hda_codec_write(codec, hp_pin, 0, 3576 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3577 3578 if (hp_pin_sense) 3579 msleep(100); 3580 3581 if (!spec->no_shutup_pins) 3582 snd_hda_codec_write(codec, hp_pin, 0, 3583 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3584 3585 alc_update_coef_idx(codec, 0x46, 0, 3 << 12); 3586 3587 if (hp_pin_sense) 3588 msleep(100); 3589 alc_auto_setup_eapd(codec, false); 3590 alc_shutup_pins(codec); 3591 alc_write_coef_idx(codec, 0x43, 0x9614); 3592 } 3593 3594 static void alc256_init(struct hda_codec *codec) 3595 { 3596 struct alc_spec *spec = codec->spec; 3597 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3598 bool hp_pin_sense; 3599 3600 if (spec->ultra_low_power) { 3601 alc_update_coef_idx(codec, 0x03, 1<<1, 1<<1); 3602 alc_update_coef_idx(codec, 0x08, 3<<2, 3<<2); 3603 alc_update_coef_idx(codec, 0x08, 7<<4, 0); 3604 alc_update_coef_idx(codec, 0x3b, 1<<15, 0); 3605 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6); 3606 msleep(30); 3607 } 3608 3609 if (!hp_pin) 3610 hp_pin = 0x21; 3611 3612 msleep(30); 3613 3614 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3615 3616 if (hp_pin_sense) { 3617 msleep(2); 3618 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */ 3619 3620 snd_hda_codec_write(codec, hp_pin, 0, 3621 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3622 3623 msleep(75); 3624 3625 snd_hda_codec_write(codec, hp_pin, 0, 3626 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 3627 3628 msleep(75); 3629 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */ 3630 } 3631 alc_update_coef_idx(codec, 0x46, 3 << 12, 0); 3632 alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15); /* Clear bit */ 3633 alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15); 3634 /* 3635 * Expose headphone mic (or possibly Line In on some machines) instead 3636 * of PC Beep on 1Ah, and disable 1Ah loopback for all outputs. See 3637 * Documentation/sound/hd-audio/realtek-pc-beep.rst for details of 3638 * this register. 3639 */ 3640 alc_write_coef_idx(codec, 0x36, 0x5757); 3641 } 3642 3643 static void alc256_shutup(struct hda_codec *codec) 3644 { 3645 struct alc_spec *spec = codec->spec; 3646 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3647 bool hp_pin_sense; 3648 3649 if (!hp_pin) 3650 hp_pin = 0x21; 3651 3652 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */ 3653 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3654 3655 if (hp_pin_sense) { 3656 msleep(2); 3657 3658 snd_hda_codec_write(codec, hp_pin, 0, 3659 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3660 3661 msleep(75); 3662 3663 /* 3k pull low control for Headset jack. */ 3664 /* NOTE: call this before clearing the pin, otherwise codec stalls */ 3665 /* If disable 3k pulldown control for alc257, the Mic detection will not work correctly 3666 * when booting with headset plugged. So skip setting it for the codec alc257 3667 */ 3668 if (spec->en_3kpull_low) 3669 alc_update_coef_idx(codec, 0x46, 0, 3 << 12); 3670 3671 if (!spec->no_shutup_pins) 3672 snd_hda_codec_write(codec, hp_pin, 0, 3673 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3674 3675 msleep(75); 3676 } 3677 3678 alc_auto_setup_eapd(codec, false); 3679 alc_shutup_pins(codec); 3680 if (spec->ultra_low_power) { 3681 msleep(50); 3682 alc_update_coef_idx(codec, 0x03, 1<<1, 0); 3683 alc_update_coef_idx(codec, 0x08, 7<<4, 7<<4); 3684 alc_update_coef_idx(codec, 0x08, 3<<2, 0); 3685 alc_update_coef_idx(codec, 0x3b, 1<<15, 1<<15); 3686 alc_update_coef_idx(codec, 0x0e, 7<<6, 0); 3687 msleep(30); 3688 } 3689 } 3690 3691 static void alc285_hp_init(struct hda_codec *codec) 3692 { 3693 struct alc_spec *spec = codec->spec; 3694 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3695 int i, val; 3696 int coef38, coef0d, coef36; 3697 3698 alc_write_coefex_idx(codec, 0x58, 0x00, 0x1888); /* write default value */ 3699 alc_update_coef_idx(codec, 0x4a, 1<<15, 1<<15); /* Reset HP JD */ 3700 coef38 = alc_read_coef_idx(codec, 0x38); /* Amp control */ 3701 coef0d = alc_read_coef_idx(codec, 0x0d); /* Digital Misc control */ 3702 coef36 = alc_read_coef_idx(codec, 0x36); /* Passthrough Control */ 3703 alc_update_coef_idx(codec, 0x38, 1<<4, 0x0); 3704 alc_update_coef_idx(codec, 0x0d, 0x110, 0x0); 3705 3706 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000); 3707 3708 if (hp_pin) 3709 snd_hda_codec_write(codec, hp_pin, 0, 3710 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3711 3712 msleep(130); 3713 alc_update_coef_idx(codec, 0x36, 1<<14, 1<<14); 3714 alc_update_coef_idx(codec, 0x36, 1<<13, 0x0); 3715 3716 if (hp_pin) 3717 snd_hda_codec_write(codec, hp_pin, 0, 3718 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3719 msleep(10); 3720 alc_write_coef_idx(codec, 0x67, 0x0); /* Set HP depop to manual mode */ 3721 alc_write_coefex_idx(codec, 0x58, 0x00, 0x7880); 3722 alc_write_coefex_idx(codec, 0x58, 0x0f, 0xf049); 3723 alc_update_coefex_idx(codec, 0x58, 0x03, 0x00f0, 0x00c0); 3724 3725 alc_write_coefex_idx(codec, 0x58, 0x00, 0xf888); /* HP depop procedure start */ 3726 val = alc_read_coefex_idx(codec, 0x58, 0x00); 3727 for (i = 0; i < 20 && val & 0x8000; i++) { 3728 msleep(50); 3729 val = alc_read_coefex_idx(codec, 0x58, 0x00); 3730 } /* Wait for depop procedure finish */ 3731 3732 alc_write_coefex_idx(codec, 0x58, 0x00, val); /* write back the result */ 3733 alc_update_coef_idx(codec, 0x38, 1<<4, coef38); 3734 alc_update_coef_idx(codec, 0x0d, 0x110, coef0d); 3735 alc_update_coef_idx(codec, 0x36, 3<<13, coef36); 3736 3737 msleep(50); 3738 alc_update_coef_idx(codec, 0x4a, 1<<15, 0); 3739 } 3740 3741 static void alc225_init(struct hda_codec *codec) 3742 { 3743 struct alc_spec *spec = codec->spec; 3744 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3745 bool hp1_pin_sense, hp2_pin_sense; 3746 3747 if (spec->ultra_low_power) { 3748 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 3<<2); 3749 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6); 3750 alc_update_coef_idx(codec, 0x33, 1<<11, 0); 3751 msleep(30); 3752 } 3753 3754 if (spec->codec_variant != ALC269_TYPE_ALC287 && 3755 spec->codec_variant != ALC269_TYPE_ALC245) 3756 /* required only at boot or S3 and S4 resume time */ 3757 if (!spec->done_hp_init || 3758 is_s3_resume(codec) || 3759 is_s4_resume(codec)) { 3760 alc285_hp_init(codec); 3761 spec->done_hp_init = true; 3762 } 3763 3764 if (!hp_pin) 3765 hp_pin = 0x21; 3766 msleep(30); 3767 3768 hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3769 hp2_pin_sense = snd_hda_jack_detect(codec, 0x16); 3770 3771 if (hp1_pin_sense || hp2_pin_sense) { 3772 msleep(2); 3773 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */ 3774 3775 if (hp1_pin_sense) 3776 snd_hda_codec_write(codec, hp_pin, 0, 3777 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3778 if (hp2_pin_sense) 3779 snd_hda_codec_write(codec, 0x16, 0, 3780 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3781 msleep(75); 3782 3783 if (hp1_pin_sense) 3784 snd_hda_codec_write(codec, hp_pin, 0, 3785 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 3786 if (hp2_pin_sense) 3787 snd_hda_codec_write(codec, 0x16, 0, 3788 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 3789 3790 msleep(75); 3791 alc_update_coef_idx(codec, 0x4a, 3 << 10, 0); 3792 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */ 3793 } 3794 } 3795 3796 static void alc225_shutup(struct hda_codec *codec) 3797 { 3798 struct alc_spec *spec = codec->spec; 3799 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3800 bool hp1_pin_sense, hp2_pin_sense; 3801 3802 if (!hp_pin) 3803 hp_pin = 0x21; 3804 3805 hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3806 hp2_pin_sense = snd_hda_jack_detect(codec, 0x16); 3807 3808 if (hp1_pin_sense || hp2_pin_sense) { 3809 alc_disable_headset_jack_key(codec); 3810 /* 3k pull low control for Headset jack. */ 3811 alc_update_coef_idx(codec, 0x4a, 0, 3 << 10); 3812 msleep(2); 3813 3814 if (hp1_pin_sense) 3815 snd_hda_codec_write(codec, hp_pin, 0, 3816 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3817 if (hp2_pin_sense) 3818 snd_hda_codec_write(codec, 0x16, 0, 3819 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3820 3821 msleep(75); 3822 3823 if (hp1_pin_sense) 3824 snd_hda_codec_write(codec, hp_pin, 0, 3825 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3826 if (hp2_pin_sense) 3827 snd_hda_codec_write(codec, 0x16, 0, 3828 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3829 3830 msleep(75); 3831 alc_update_coef_idx(codec, 0x4a, 3 << 10, 0); 3832 alc_enable_headset_jack_key(codec); 3833 } 3834 alc_auto_setup_eapd(codec, false); 3835 alc_shutup_pins(codec); 3836 if (spec->ultra_low_power) { 3837 msleep(50); 3838 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 0x0c << 2); 3839 alc_update_coef_idx(codec, 0x0e, 7<<6, 0); 3840 alc_update_coef_idx(codec, 0x33, 1<<11, 1<<11); 3841 alc_update_coef_idx(codec, 0x4a, 3<<4, 2<<4); 3842 msleep(30); 3843 } 3844 } 3845 3846 static void alc_default_init(struct hda_codec *codec) 3847 { 3848 struct alc_spec *spec = codec->spec; 3849 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3850 bool hp_pin_sense; 3851 3852 if (!hp_pin) 3853 return; 3854 3855 msleep(30); 3856 3857 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3858 3859 if (hp_pin_sense) { 3860 msleep(2); 3861 3862 snd_hda_codec_write(codec, hp_pin, 0, 3863 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3864 3865 msleep(75); 3866 3867 snd_hda_codec_write(codec, hp_pin, 0, 3868 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 3869 msleep(75); 3870 } 3871 } 3872 3873 static void alc_default_shutup(struct hda_codec *codec) 3874 { 3875 struct alc_spec *spec = codec->spec; 3876 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3877 bool hp_pin_sense; 3878 3879 if (!hp_pin) { 3880 alc269_shutup(codec); 3881 return; 3882 } 3883 3884 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3885 3886 if (hp_pin_sense) { 3887 msleep(2); 3888 3889 snd_hda_codec_write(codec, hp_pin, 0, 3890 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3891 3892 msleep(75); 3893 3894 if (!spec->no_shutup_pins) 3895 snd_hda_codec_write(codec, hp_pin, 0, 3896 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3897 3898 msleep(75); 3899 } 3900 alc_auto_setup_eapd(codec, false); 3901 alc_shutup_pins(codec); 3902 } 3903 3904 static void alc294_hp_init(struct hda_codec *codec) 3905 { 3906 struct alc_spec *spec = codec->spec; 3907 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3908 int i, val; 3909 3910 if (!hp_pin) 3911 return; 3912 3913 snd_hda_codec_write(codec, hp_pin, 0, 3914 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3915 3916 msleep(100); 3917 3918 if (!spec->no_shutup_pins) 3919 snd_hda_codec_write(codec, hp_pin, 0, 3920 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3921 3922 alc_update_coef_idx(codec, 0x6f, 0x000f, 0);/* Set HP depop to manual mode */ 3923 alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000); /* HP depop procedure start */ 3924 3925 /* Wait for depop procedure finish */ 3926 val = alc_read_coefex_idx(codec, 0x58, 0x01); 3927 for (i = 0; i < 20 && val & 0x0080; i++) { 3928 msleep(50); 3929 val = alc_read_coefex_idx(codec, 0x58, 0x01); 3930 } 3931 /* Set HP depop to auto mode */ 3932 alc_update_coef_idx(codec, 0x6f, 0x000f, 0x000b); 3933 msleep(50); 3934 } 3935 3936 static void alc294_init(struct hda_codec *codec) 3937 { 3938 struct alc_spec *spec = codec->spec; 3939 3940 /* required only at boot or S4 resume time */ 3941 if (!spec->done_hp_init || 3942 codec->core.dev.power.power_state.event == PM_EVENT_RESTORE) { 3943 alc294_hp_init(codec); 3944 spec->done_hp_init = true; 3945 } 3946 alc_default_init(codec); 3947 } 3948 3949 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg, 3950 unsigned int val) 3951 { 3952 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1); 3953 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */ 3954 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */ 3955 } 3956 3957 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg) 3958 { 3959 unsigned int val; 3960 3961 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1); 3962 val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0) 3963 & 0xffff; 3964 val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0) 3965 << 16; 3966 return val; 3967 } 3968 3969 static void alc5505_dsp_halt(struct hda_codec *codec) 3970 { 3971 unsigned int val; 3972 3973 alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */ 3974 alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */ 3975 alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */ 3976 alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */ 3977 alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */ 3978 alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */ 3979 alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */ 3980 val = alc5505_coef_get(codec, 0x6220); 3981 alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */ 3982 } 3983 3984 static void alc5505_dsp_back_from_halt(struct hda_codec *codec) 3985 { 3986 alc5505_coef_set(codec, 0x61b8, 0x04133302); 3987 alc5505_coef_set(codec, 0x61b0, 0x00005b16); 3988 alc5505_coef_set(codec, 0x61b4, 0x040a2b02); 3989 alc5505_coef_set(codec, 0x6230, 0xf80d4011); 3990 alc5505_coef_set(codec, 0x6220, 0x2002010f); 3991 alc5505_coef_set(codec, 0x880c, 0x00000004); 3992 } 3993 3994 static void alc5505_dsp_init(struct hda_codec *codec) 3995 { 3996 unsigned int val; 3997 3998 alc5505_dsp_halt(codec); 3999 alc5505_dsp_back_from_halt(codec); 4000 alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */ 4001 alc5505_coef_set(codec, 0x61b0, 0x5b16); 4002 alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */ 4003 alc5505_coef_set(codec, 0x61b4, 0x04132b02); 4004 alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/ 4005 alc5505_coef_set(codec, 0x61b8, 0x041f3302); 4006 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */ 4007 alc5505_coef_set(codec, 0x61b8, 0x041b3302); 4008 alc5505_coef_set(codec, 0x61b8, 0x04173302); 4009 alc5505_coef_set(codec, 0x61b8, 0x04163302); 4010 alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */ 4011 alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */ 4012 alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */ 4013 4014 val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */ 4015 if (val <= 3) 4016 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */ 4017 else 4018 alc5505_coef_set(codec, 0x6220, 0x6002018f); 4019 4020 alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/ 4021 alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */ 4022 alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */ 4023 alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */ 4024 alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */ 4025 alc5505_coef_set(codec, 0x880c, 0x00000003); 4026 alc5505_coef_set(codec, 0x880c, 0x00000010); 4027 4028 #ifdef HALT_REALTEK_ALC5505 4029 alc5505_dsp_halt(codec); 4030 #endif 4031 } 4032 4033 #ifdef HALT_REALTEK_ALC5505 4034 #define alc5505_dsp_suspend(codec) do { } while (0) /* NOP */ 4035 #define alc5505_dsp_resume(codec) do { } while (0) /* NOP */ 4036 #else 4037 #define alc5505_dsp_suspend(codec) alc5505_dsp_halt(codec) 4038 #define alc5505_dsp_resume(codec) alc5505_dsp_back_from_halt(codec) 4039 #endif 4040 4041 static int alc269_suspend(struct hda_codec *codec) 4042 { 4043 struct alc_spec *spec = codec->spec; 4044 4045 if (spec->has_alc5505_dsp) 4046 alc5505_dsp_suspend(codec); 4047 4048 return alc_suspend(codec); 4049 } 4050 4051 static int alc269_resume(struct hda_codec *codec) 4052 { 4053 struct alc_spec *spec = codec->spec; 4054 4055 if (spec->codec_variant == ALC269_TYPE_ALC269VB) 4056 alc269vb_toggle_power_output(codec, 0); 4057 if (spec->codec_variant == ALC269_TYPE_ALC269VB && 4058 (alc_get_coef0(codec) & 0x00ff) == 0x018) { 4059 msleep(150); 4060 } 4061 4062 codec->patch_ops.init(codec); 4063 4064 if (spec->codec_variant == ALC269_TYPE_ALC269VB) 4065 alc269vb_toggle_power_output(codec, 1); 4066 if (spec->codec_variant == ALC269_TYPE_ALC269VB && 4067 (alc_get_coef0(codec) & 0x00ff) == 0x017) { 4068 msleep(200); 4069 } 4070 4071 snd_hda_regmap_sync(codec); 4072 hda_call_check_power_status(codec, 0x01); 4073 4074 /* on some machine, the BIOS will clear the codec gpio data when enter 4075 * suspend, and won't restore the data after resume, so we restore it 4076 * in the driver. 4077 */ 4078 if (spec->gpio_data) 4079 alc_write_gpio_data(codec); 4080 4081 if (spec->has_alc5505_dsp) 4082 alc5505_dsp_resume(codec); 4083 4084 return 0; 4085 } 4086 4087 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec, 4088 const struct hda_fixup *fix, int action) 4089 { 4090 struct alc_spec *spec = codec->spec; 4091 4092 if (action == HDA_FIXUP_ACT_PRE_PROBE) 4093 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 4094 } 4095 4096 static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec, 4097 const struct hda_fixup *fix, 4098 int action) 4099 { 4100 unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21); 4101 unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19); 4102 4103 if (cfg_headphone && cfg_headset_mic == 0x411111f0) 4104 snd_hda_codec_set_pincfg(codec, 0x19, 4105 (cfg_headphone & ~AC_DEFCFG_DEVICE) | 4106 (AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT)); 4107 } 4108 4109 static void alc269_fixup_hweq(struct hda_codec *codec, 4110 const struct hda_fixup *fix, int action) 4111 { 4112 if (action == HDA_FIXUP_ACT_INIT) 4113 alc_update_coef_idx(codec, 0x1e, 0, 0x80); 4114 } 4115 4116 static void alc269_fixup_headset_mic(struct hda_codec *codec, 4117 const struct hda_fixup *fix, int action) 4118 { 4119 struct alc_spec *spec = codec->spec; 4120 4121 if (action == HDA_FIXUP_ACT_PRE_PROBE) 4122 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 4123 } 4124 4125 static void alc271_fixup_dmic(struct hda_codec *codec, 4126 const struct hda_fixup *fix, int action) 4127 { 4128 static const struct hda_verb verbs[] = { 4129 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d}, 4130 {0x20, AC_VERB_SET_PROC_COEF, 0x4000}, 4131 {} 4132 }; 4133 unsigned int cfg; 4134 4135 if (strcmp(codec->core.chip_name, "ALC271X") && 4136 strcmp(codec->core.chip_name, "ALC269VB")) 4137 return; 4138 cfg = snd_hda_codec_get_pincfg(codec, 0x12); 4139 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED) 4140 snd_hda_sequence_write(codec, verbs); 4141 } 4142 4143 /* Fix the speaker amp after resume, etc */ 4144 static void alc269vb_fixup_aspire_e1_coef(struct hda_codec *codec, 4145 const struct hda_fixup *fix, 4146 int action) 4147 { 4148 if (action == HDA_FIXUP_ACT_INIT) 4149 alc_update_coef_idx(codec, 0x0d, 0x6000, 0x6000); 4150 } 4151 4152 static void alc269_fixup_pcm_44k(struct hda_codec *codec, 4153 const struct hda_fixup *fix, int action) 4154 { 4155 struct alc_spec *spec = codec->spec; 4156 4157 if (action != HDA_FIXUP_ACT_PROBE) 4158 return; 4159 4160 /* Due to a hardware problem on Lenovo Ideadpad, we need to 4161 * fix the sample rate of analog I/O to 44.1kHz 4162 */ 4163 spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback; 4164 spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture; 4165 } 4166 4167 static void alc269_fixup_stereo_dmic(struct hda_codec *codec, 4168 const struct hda_fixup *fix, int action) 4169 { 4170 /* The digital-mic unit sends PDM (differential signal) instead of 4171 * the standard PCM, thus you can't record a valid mono stream as is. 4172 * Below is a workaround specific to ALC269 to control the dmic 4173 * signal source as mono. 4174 */ 4175 if (action == HDA_FIXUP_ACT_INIT) 4176 alc_update_coef_idx(codec, 0x07, 0, 0x80); 4177 } 4178 4179 static void alc269_quanta_automute(struct hda_codec *codec) 4180 { 4181 snd_hda_gen_update_outputs(codec); 4182 4183 alc_write_coef_idx(codec, 0x0c, 0x680); 4184 alc_write_coef_idx(codec, 0x0c, 0x480); 4185 } 4186 4187 static void alc269_fixup_quanta_mute(struct hda_codec *codec, 4188 const struct hda_fixup *fix, int action) 4189 { 4190 struct alc_spec *spec = codec->spec; 4191 if (action != HDA_FIXUP_ACT_PROBE) 4192 return; 4193 spec->gen.automute_hook = alc269_quanta_automute; 4194 } 4195 4196 static void alc269_x101_hp_automute_hook(struct hda_codec *codec, 4197 struct hda_jack_callback *jack) 4198 { 4199 struct alc_spec *spec = codec->spec; 4200 int vref; 4201 msleep(200); 4202 snd_hda_gen_hp_automute(codec, jack); 4203 4204 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0; 4205 msleep(100); 4206 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4207 vref); 4208 msleep(500); 4209 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4210 vref); 4211 } 4212 4213 /* 4214 * Magic sequence to make Huawei Matebook X right speaker working (bko#197801) 4215 */ 4216 struct hda_alc298_mbxinit { 4217 unsigned char value_0x23; 4218 unsigned char value_0x25; 4219 }; 4220 4221 static void alc298_huawei_mbx_stereo_seq(struct hda_codec *codec, 4222 const struct hda_alc298_mbxinit *initval, 4223 bool first) 4224 { 4225 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x0); 4226 alc_write_coef_idx(codec, 0x26, 0xb000); 4227 4228 if (first) 4229 snd_hda_codec_write(codec, 0x21, 0, AC_VERB_GET_PIN_SENSE, 0x0); 4230 4231 snd_hda_codec_write(codec, 0x6, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80); 4232 alc_write_coef_idx(codec, 0x26, 0xf000); 4233 alc_write_coef_idx(codec, 0x23, initval->value_0x23); 4234 4235 if (initval->value_0x23 != 0x1e) 4236 alc_write_coef_idx(codec, 0x25, initval->value_0x25); 4237 4238 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26); 4239 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010); 4240 } 4241 4242 static void alc298_fixup_huawei_mbx_stereo(struct hda_codec *codec, 4243 const struct hda_fixup *fix, 4244 int action) 4245 { 4246 /* Initialization magic */ 4247 static const struct hda_alc298_mbxinit dac_init[] = { 4248 {0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00}, 4249 {0x10, 0x00}, {0x1a, 0x40}, {0x1b, 0x82}, {0x1c, 0x00}, 4250 {0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00}, 4251 {0x20, 0xc2}, {0x21, 0xc8}, {0x22, 0x26}, {0x23, 0x24}, 4252 {0x27, 0xff}, {0x28, 0xff}, {0x29, 0xff}, {0x2a, 0x8f}, 4253 {0x2b, 0x02}, {0x2c, 0x48}, {0x2d, 0x34}, {0x2e, 0x00}, 4254 {0x2f, 0x00}, 4255 {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00}, 4256 {0x34, 0x00}, {0x35, 0x01}, {0x36, 0x93}, {0x37, 0x0c}, 4257 {0x38, 0x00}, {0x39, 0x00}, {0x3a, 0xf8}, {0x38, 0x80}, 4258 {} 4259 }; 4260 const struct hda_alc298_mbxinit *seq; 4261 4262 if (action != HDA_FIXUP_ACT_INIT) 4263 return; 4264 4265 /* Start */ 4266 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x00); 4267 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80); 4268 alc_write_coef_idx(codec, 0x26, 0xf000); 4269 alc_write_coef_idx(codec, 0x22, 0x31); 4270 alc_write_coef_idx(codec, 0x23, 0x0b); 4271 alc_write_coef_idx(codec, 0x25, 0x00); 4272 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26); 4273 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010); 4274 4275 for (seq = dac_init; seq->value_0x23; seq++) 4276 alc298_huawei_mbx_stereo_seq(codec, seq, seq == dac_init); 4277 } 4278 4279 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec, 4280 const struct hda_fixup *fix, int action) 4281 { 4282 struct alc_spec *spec = codec->spec; 4283 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4284 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 4285 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook; 4286 } 4287 } 4288 4289 static void alc_update_vref_led(struct hda_codec *codec, hda_nid_t pin, 4290 bool polarity, bool on) 4291 { 4292 unsigned int pinval; 4293 4294 if (!pin) 4295 return; 4296 if (polarity) 4297 on = !on; 4298 pinval = snd_hda_codec_get_pin_target(codec, pin); 4299 pinval &= ~AC_PINCTL_VREFEN; 4300 pinval |= on ? AC_PINCTL_VREF_80 : AC_PINCTL_VREF_HIZ; 4301 /* temporarily power up/down for setting VREF */ 4302 snd_hda_power_up_pm(codec); 4303 snd_hda_set_pin_ctl_cache(codec, pin, pinval); 4304 snd_hda_power_down_pm(codec); 4305 } 4306 4307 /* update mute-LED according to the speaker mute state via mic VREF pin */ 4308 static int vref_mute_led_set(struct led_classdev *led_cdev, 4309 enum led_brightness brightness) 4310 { 4311 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4312 struct alc_spec *spec = codec->spec; 4313 4314 alc_update_vref_led(codec, spec->mute_led_nid, 4315 spec->mute_led_polarity, brightness); 4316 return 0; 4317 } 4318 4319 /* Make sure the led works even in runtime suspend */ 4320 static unsigned int led_power_filter(struct hda_codec *codec, 4321 hda_nid_t nid, 4322 unsigned int power_state) 4323 { 4324 struct alc_spec *spec = codec->spec; 4325 4326 if (power_state != AC_PWRST_D3 || nid == 0 || 4327 (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid)) 4328 return power_state; 4329 4330 /* Set pin ctl again, it might have just been set to 0 */ 4331 snd_hda_set_pin_ctl(codec, nid, 4332 snd_hda_codec_get_pin_target(codec, nid)); 4333 4334 return snd_hda_gen_path_power_filter(codec, nid, power_state); 4335 } 4336 4337 static void alc269_fixup_hp_mute_led(struct hda_codec *codec, 4338 const struct hda_fixup *fix, int action) 4339 { 4340 struct alc_spec *spec = codec->spec; 4341 const struct dmi_device *dev = NULL; 4342 4343 if (action != HDA_FIXUP_ACT_PRE_PROBE) 4344 return; 4345 4346 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) { 4347 int pol, pin; 4348 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2) 4349 continue; 4350 if (pin < 0x0a || pin >= 0x10) 4351 break; 4352 spec->mute_led_polarity = pol; 4353 spec->mute_led_nid = pin - 0x0a + 0x18; 4354 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set); 4355 codec->power_filter = led_power_filter; 4356 codec_dbg(codec, 4357 "Detected mute LED for %x:%d\n", spec->mute_led_nid, 4358 spec->mute_led_polarity); 4359 break; 4360 } 4361 } 4362 4363 static void alc269_fixup_hp_mute_led_micx(struct hda_codec *codec, 4364 const struct hda_fixup *fix, 4365 int action, hda_nid_t pin) 4366 { 4367 struct alc_spec *spec = codec->spec; 4368 4369 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4370 spec->mute_led_polarity = 0; 4371 spec->mute_led_nid = pin; 4372 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set); 4373 codec->power_filter = led_power_filter; 4374 } 4375 } 4376 4377 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec, 4378 const struct hda_fixup *fix, int action) 4379 { 4380 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x18); 4381 } 4382 4383 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec, 4384 const struct hda_fixup *fix, int action) 4385 { 4386 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x19); 4387 } 4388 4389 static void alc269_fixup_hp_mute_led_mic3(struct hda_codec *codec, 4390 const struct hda_fixup *fix, int action) 4391 { 4392 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1b); 4393 } 4394 4395 /* update LED status via GPIO */ 4396 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask, 4397 int polarity, bool enabled) 4398 { 4399 if (polarity) 4400 enabled = !enabled; 4401 alc_update_gpio_data(codec, mask, !enabled); /* muted -> LED on */ 4402 } 4403 4404 /* turn on/off mute LED via GPIO per vmaster hook */ 4405 static int gpio_mute_led_set(struct led_classdev *led_cdev, 4406 enum led_brightness brightness) 4407 { 4408 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4409 struct alc_spec *spec = codec->spec; 4410 4411 alc_update_gpio_led(codec, spec->gpio_mute_led_mask, 4412 spec->mute_led_polarity, !brightness); 4413 return 0; 4414 } 4415 4416 /* turn on/off mic-mute LED via GPIO per capture hook */ 4417 static int micmute_led_set(struct led_classdev *led_cdev, 4418 enum led_brightness brightness) 4419 { 4420 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4421 struct alc_spec *spec = codec->spec; 4422 4423 alc_update_gpio_led(codec, spec->gpio_mic_led_mask, 4424 spec->micmute_led_polarity, !brightness); 4425 return 0; 4426 } 4427 4428 /* setup mute and mic-mute GPIO bits, add hooks appropriately */ 4429 static void alc_fixup_hp_gpio_led(struct hda_codec *codec, 4430 int action, 4431 unsigned int mute_mask, 4432 unsigned int micmute_mask) 4433 { 4434 struct alc_spec *spec = codec->spec; 4435 4436 alc_fixup_gpio(codec, action, mute_mask | micmute_mask); 4437 4438 if (action != HDA_FIXUP_ACT_PRE_PROBE) 4439 return; 4440 if (mute_mask) { 4441 spec->gpio_mute_led_mask = mute_mask; 4442 snd_hda_gen_add_mute_led_cdev(codec, gpio_mute_led_set); 4443 } 4444 if (micmute_mask) { 4445 spec->gpio_mic_led_mask = micmute_mask; 4446 snd_hda_gen_add_micmute_led_cdev(codec, micmute_led_set); 4447 } 4448 } 4449 4450 static void alc236_fixup_hp_gpio_led(struct hda_codec *codec, 4451 const struct hda_fixup *fix, int action) 4452 { 4453 alc_fixup_hp_gpio_led(codec, action, 0x02, 0x01); 4454 } 4455 4456 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec, 4457 const struct hda_fixup *fix, int action) 4458 { 4459 alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10); 4460 } 4461 4462 static void alc285_fixup_hp_gpio_led(struct hda_codec *codec, 4463 const struct hda_fixup *fix, int action) 4464 { 4465 alc_fixup_hp_gpio_led(codec, action, 0x04, 0x01); 4466 } 4467 4468 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec, 4469 const struct hda_fixup *fix, int action) 4470 { 4471 alc_fixup_hp_gpio_led(codec, action, 0x02, 0x20); 4472 } 4473 4474 static void alc287_fixup_hp_gpio_led(struct hda_codec *codec, 4475 const struct hda_fixup *fix, int action) 4476 { 4477 alc_fixup_hp_gpio_led(codec, action, 0x10, 0); 4478 } 4479 4480 static void alc245_fixup_hp_gpio_led(struct hda_codec *codec, 4481 const struct hda_fixup *fix, int action) 4482 { 4483 struct alc_spec *spec = codec->spec; 4484 4485 if (action == HDA_FIXUP_ACT_PRE_PROBE) 4486 spec->micmute_led_polarity = 1; 4487 alc_fixup_hp_gpio_led(codec, action, 0, 0x04); 4488 } 4489 4490 /* turn on/off mic-mute LED per capture hook via VREF change */ 4491 static int vref_micmute_led_set(struct led_classdev *led_cdev, 4492 enum led_brightness brightness) 4493 { 4494 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4495 struct alc_spec *spec = codec->spec; 4496 4497 alc_update_vref_led(codec, spec->cap_mute_led_nid, 4498 spec->micmute_led_polarity, brightness); 4499 return 0; 4500 } 4501 4502 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec, 4503 const struct hda_fixup *fix, int action) 4504 { 4505 struct alc_spec *spec = codec->spec; 4506 4507 alc_fixup_hp_gpio_led(codec, action, 0x08, 0); 4508 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4509 /* Like hp_gpio_mic1_led, but also needs GPIO4 low to 4510 * enable headphone amp 4511 */ 4512 spec->gpio_mask |= 0x10; 4513 spec->gpio_dir |= 0x10; 4514 spec->cap_mute_led_nid = 0x18; 4515 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set); 4516 codec->power_filter = led_power_filter; 4517 } 4518 } 4519 4520 static void alc280_fixup_hp_gpio4(struct hda_codec *codec, 4521 const struct hda_fixup *fix, int action) 4522 { 4523 struct alc_spec *spec = codec->spec; 4524 4525 alc_fixup_hp_gpio_led(codec, action, 0x08, 0); 4526 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4527 spec->cap_mute_led_nid = 0x18; 4528 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set); 4529 codec->power_filter = led_power_filter; 4530 } 4531 } 4532 4533 /* HP Spectre x360 14 model needs a unique workaround for enabling the amp; 4534 * it needs to toggle the GPIO0 once on and off at each time (bko#210633) 4535 */ 4536 static void alc245_fixup_hp_x360_amp(struct hda_codec *codec, 4537 const struct hda_fixup *fix, int action) 4538 { 4539 struct alc_spec *spec = codec->spec; 4540 4541 switch (action) { 4542 case HDA_FIXUP_ACT_PRE_PROBE: 4543 spec->gpio_mask |= 0x01; 4544 spec->gpio_dir |= 0x01; 4545 break; 4546 case HDA_FIXUP_ACT_INIT: 4547 /* need to toggle GPIO to enable the amp */ 4548 alc_update_gpio_data(codec, 0x01, true); 4549 msleep(100); 4550 alc_update_gpio_data(codec, 0x01, false); 4551 break; 4552 } 4553 } 4554 4555 /* toggle GPIO2 at each time stream is started; we use PREPARE state instead */ 4556 static void alc274_hp_envy_pcm_hook(struct hda_pcm_stream *hinfo, 4557 struct hda_codec *codec, 4558 struct snd_pcm_substream *substream, 4559 int action) 4560 { 4561 switch (action) { 4562 case HDA_GEN_PCM_ACT_PREPARE: 4563 alc_update_gpio_data(codec, 0x04, true); 4564 break; 4565 case HDA_GEN_PCM_ACT_CLEANUP: 4566 alc_update_gpio_data(codec, 0x04, false); 4567 break; 4568 } 4569 } 4570 4571 static void alc274_fixup_hp_envy_gpio(struct hda_codec *codec, 4572 const struct hda_fixup *fix, 4573 int action) 4574 { 4575 struct alc_spec *spec = codec->spec; 4576 4577 if (action == HDA_FIXUP_ACT_PROBE) { 4578 spec->gpio_mask |= 0x04; 4579 spec->gpio_dir |= 0x04; 4580 spec->gen.pcm_playback_hook = alc274_hp_envy_pcm_hook; 4581 } 4582 } 4583 4584 static void alc_update_coef_led(struct hda_codec *codec, 4585 struct alc_coef_led *led, 4586 bool polarity, bool on) 4587 { 4588 if (polarity) 4589 on = !on; 4590 /* temporarily power up/down for setting COEF bit */ 4591 alc_update_coef_idx(codec, led->idx, led->mask, 4592 on ? led->on : led->off); 4593 } 4594 4595 /* update mute-LED according to the speaker mute state via COEF bit */ 4596 static int coef_mute_led_set(struct led_classdev *led_cdev, 4597 enum led_brightness brightness) 4598 { 4599 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4600 struct alc_spec *spec = codec->spec; 4601 4602 alc_update_coef_led(codec, &spec->mute_led_coef, 4603 spec->mute_led_polarity, brightness); 4604 return 0; 4605 } 4606 4607 static void alc285_fixup_hp_mute_led_coefbit(struct hda_codec *codec, 4608 const struct hda_fixup *fix, 4609 int action) 4610 { 4611 struct alc_spec *spec = codec->spec; 4612 4613 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4614 spec->mute_led_polarity = 0; 4615 spec->mute_led_coef.idx = 0x0b; 4616 spec->mute_led_coef.mask = 1 << 3; 4617 spec->mute_led_coef.on = 1 << 3; 4618 spec->mute_led_coef.off = 0; 4619 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set); 4620 } 4621 } 4622 4623 static void alc236_fixup_hp_mute_led_coefbit(struct hda_codec *codec, 4624 const struct hda_fixup *fix, 4625 int action) 4626 { 4627 struct alc_spec *spec = codec->spec; 4628 4629 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4630 spec->mute_led_polarity = 0; 4631 spec->mute_led_coef.idx = 0x34; 4632 spec->mute_led_coef.mask = 1 << 5; 4633 spec->mute_led_coef.on = 0; 4634 spec->mute_led_coef.off = 1 << 5; 4635 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set); 4636 } 4637 } 4638 4639 static void alc236_fixup_hp_mute_led_coefbit2(struct hda_codec *codec, 4640 const struct hda_fixup *fix, int action) 4641 { 4642 struct alc_spec *spec = codec->spec; 4643 4644 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4645 spec->mute_led_polarity = 0; 4646 spec->mute_led_coef.idx = 0x07; 4647 spec->mute_led_coef.mask = 1; 4648 spec->mute_led_coef.on = 1; 4649 spec->mute_led_coef.off = 0; 4650 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set); 4651 } 4652 } 4653 4654 static void alc245_fixup_hp_mute_led_coefbit(struct hda_codec *codec, 4655 const struct hda_fixup *fix, 4656 int action) 4657 { 4658 struct alc_spec *spec = codec->spec; 4659 4660 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4661 spec->mute_led_polarity = 0; 4662 spec->mute_led_coef.idx = 0x0b; 4663 spec->mute_led_coef.mask = 3 << 2; 4664 spec->mute_led_coef.on = 2 << 2; 4665 spec->mute_led_coef.off = 1 << 2; 4666 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set); 4667 } 4668 } 4669 4670 /* turn on/off mic-mute LED per capture hook by coef bit */ 4671 static int coef_micmute_led_set(struct led_classdev *led_cdev, 4672 enum led_brightness brightness) 4673 { 4674 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4675 struct alc_spec *spec = codec->spec; 4676 4677 alc_update_coef_led(codec, &spec->mic_led_coef, 4678 spec->micmute_led_polarity, brightness); 4679 return 0; 4680 } 4681 4682 static void alc285_fixup_hp_coef_micmute_led(struct hda_codec *codec, 4683 const struct hda_fixup *fix, int action) 4684 { 4685 struct alc_spec *spec = codec->spec; 4686 4687 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4688 spec->mic_led_coef.idx = 0x19; 4689 spec->mic_led_coef.mask = 1 << 13; 4690 spec->mic_led_coef.on = 1 << 13; 4691 spec->mic_led_coef.off = 0; 4692 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set); 4693 } 4694 } 4695 4696 static void alc285_fixup_hp_gpio_micmute_led(struct hda_codec *codec, 4697 const struct hda_fixup *fix, int action) 4698 { 4699 struct alc_spec *spec = codec->spec; 4700 4701 if (action == HDA_FIXUP_ACT_PRE_PROBE) 4702 spec->micmute_led_polarity = 1; 4703 alc_fixup_hp_gpio_led(codec, action, 0, 0x04); 4704 } 4705 4706 static void alc236_fixup_hp_coef_micmute_led(struct hda_codec *codec, 4707 const struct hda_fixup *fix, int action) 4708 { 4709 struct alc_spec *spec = codec->spec; 4710 4711 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4712 spec->mic_led_coef.idx = 0x35; 4713 spec->mic_led_coef.mask = 3 << 2; 4714 spec->mic_led_coef.on = 2 << 2; 4715 spec->mic_led_coef.off = 1 << 2; 4716 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set); 4717 } 4718 } 4719 4720 static void alc285_fixup_hp_mute_led(struct hda_codec *codec, 4721 const struct hda_fixup *fix, int action) 4722 { 4723 alc285_fixup_hp_mute_led_coefbit(codec, fix, action); 4724 alc285_fixup_hp_coef_micmute_led(codec, fix, action); 4725 } 4726 4727 static void alc285_fixup_hp_spectre_x360_mute_led(struct hda_codec *codec, 4728 const struct hda_fixup *fix, int action) 4729 { 4730 alc285_fixup_hp_mute_led_coefbit(codec, fix, action); 4731 alc285_fixup_hp_gpio_micmute_led(codec, fix, action); 4732 } 4733 4734 static void alc236_fixup_hp_mute_led(struct hda_codec *codec, 4735 const struct hda_fixup *fix, int action) 4736 { 4737 alc236_fixup_hp_mute_led_coefbit(codec, fix, action); 4738 alc236_fixup_hp_coef_micmute_led(codec, fix, action); 4739 } 4740 4741 static void alc236_fixup_hp_micmute_led_vref(struct hda_codec *codec, 4742 const struct hda_fixup *fix, int action) 4743 { 4744 struct alc_spec *spec = codec->spec; 4745 4746 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4747 spec->cap_mute_led_nid = 0x1a; 4748 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set); 4749 codec->power_filter = led_power_filter; 4750 } 4751 } 4752 4753 static void alc236_fixup_hp_mute_led_micmute_vref(struct hda_codec *codec, 4754 const struct hda_fixup *fix, int action) 4755 { 4756 alc236_fixup_hp_mute_led_coefbit(codec, fix, action); 4757 alc236_fixup_hp_micmute_led_vref(codec, fix, action); 4758 } 4759 4760 static inline void alc298_samsung_write_coef_pack(struct hda_codec *codec, 4761 const unsigned short coefs[2]) 4762 { 4763 alc_write_coef_idx(codec, 0x23, coefs[0]); 4764 alc_write_coef_idx(codec, 0x25, coefs[1]); 4765 alc_write_coef_idx(codec, 0x26, 0xb011); 4766 } 4767 4768 struct alc298_samsung_amp_desc { 4769 unsigned char nid; 4770 unsigned short init_seq[2][2]; 4771 }; 4772 4773 static void alc298_fixup_samsung_amp(struct hda_codec *codec, 4774 const struct hda_fixup *fix, int action) 4775 { 4776 int i, j; 4777 static const unsigned short init_seq[][2] = { 4778 { 0x19, 0x00 }, { 0x20, 0xc0 }, { 0x22, 0x44 }, { 0x23, 0x08 }, 4779 { 0x24, 0x85 }, { 0x25, 0x41 }, { 0x35, 0x40 }, { 0x36, 0x01 }, 4780 { 0x38, 0x81 }, { 0x3a, 0x03 }, { 0x3b, 0x81 }, { 0x40, 0x3e }, 4781 { 0x41, 0x07 }, { 0x400, 0x1 } 4782 }; 4783 static const struct alc298_samsung_amp_desc amps[] = { 4784 { 0x3a, { { 0x18, 0x1 }, { 0x26, 0x0 } } }, 4785 { 0x39, { { 0x18, 0x2 }, { 0x26, 0x1 } } } 4786 }; 4787 4788 if (action != HDA_FIXUP_ACT_INIT) 4789 return; 4790 4791 for (i = 0; i < ARRAY_SIZE(amps); i++) { 4792 alc_write_coef_idx(codec, 0x22, amps[i].nid); 4793 4794 for (j = 0; j < ARRAY_SIZE(amps[i].init_seq); j++) 4795 alc298_samsung_write_coef_pack(codec, amps[i].init_seq[j]); 4796 4797 for (j = 0; j < ARRAY_SIZE(init_seq); j++) 4798 alc298_samsung_write_coef_pack(codec, init_seq[j]); 4799 } 4800 } 4801 4802 struct alc298_samsung_v2_amp_desc { 4803 unsigned short nid; 4804 int init_seq_size; 4805 unsigned short init_seq[18][2]; 4806 }; 4807 4808 static const struct alc298_samsung_v2_amp_desc 4809 alc298_samsung_v2_amp_desc_tbl[] = { 4810 { 0x38, 18, { 4811 { 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 }, 4812 { 0x201b, 0x0001 }, { 0x201d, 0x0001 }, { 0x201f, 0x00fe }, 4813 { 0x2021, 0x0000 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 }, 4814 { 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e }, 4815 { 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x2399, 0x0003 }, 4816 { 0x23a4, 0x00b5 }, { 0x23a5, 0x0001 }, { 0x23ba, 0x0094 } 4817 }}, 4818 { 0x39, 18, { 4819 { 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 }, 4820 { 0x201b, 0x0002 }, { 0x201d, 0x0002 }, { 0x201f, 0x00fd }, 4821 { 0x2021, 0x0001 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 }, 4822 { 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e }, 4823 { 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x2399, 0x0003 }, 4824 { 0x23a4, 0x00b5 }, { 0x23a5, 0x0001 }, { 0x23ba, 0x0094 } 4825 }}, 4826 { 0x3c, 15, { 4827 { 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 }, 4828 { 0x201b, 0x0001 }, { 0x201d, 0x0001 }, { 0x201f, 0x00fe }, 4829 { 0x2021, 0x0000 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 }, 4830 { 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e }, 4831 { 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x23ba, 0x008d } 4832 }}, 4833 { 0x3d, 15, { 4834 { 0x23e1, 0x0000 }, { 0x2012, 0x006f }, { 0x2014, 0x0000 }, 4835 { 0x201b, 0x0002 }, { 0x201d, 0x0002 }, { 0x201f, 0x00fd }, 4836 { 0x2021, 0x0001 }, { 0x2022, 0x0010 }, { 0x203d, 0x0005 }, 4837 { 0x203f, 0x0003 }, { 0x2050, 0x002c }, { 0x2076, 0x000e }, 4838 { 0x207c, 0x004a }, { 0x2081, 0x0003 }, { 0x23ba, 0x008d } 4839 }} 4840 }; 4841 4842 static void alc298_samsung_v2_enable_amps(struct hda_codec *codec) 4843 { 4844 struct alc_spec *spec = codec->spec; 4845 static const unsigned short enable_seq[][2] = { 4846 { 0x203a, 0x0081 }, { 0x23ff, 0x0001 }, 4847 }; 4848 int i, j; 4849 4850 for (i = 0; i < spec->num_speaker_amps; i++) { 4851 alc_write_coef_idx(codec, 0x22, alc298_samsung_v2_amp_desc_tbl[i].nid); 4852 for (j = 0; j < ARRAY_SIZE(enable_seq); j++) 4853 alc298_samsung_write_coef_pack(codec, enable_seq[j]); 4854 codec_dbg(codec, "alc298_samsung_v2: Enabled speaker amp 0x%02x\n", 4855 alc298_samsung_v2_amp_desc_tbl[i].nid); 4856 } 4857 } 4858 4859 static void alc298_samsung_v2_disable_amps(struct hda_codec *codec) 4860 { 4861 struct alc_spec *spec = codec->spec; 4862 static const unsigned short disable_seq[][2] = { 4863 { 0x23ff, 0x0000 }, { 0x203a, 0x0080 }, 4864 }; 4865 int i, j; 4866 4867 for (i = 0; i < spec->num_speaker_amps; i++) { 4868 alc_write_coef_idx(codec, 0x22, alc298_samsung_v2_amp_desc_tbl[i].nid); 4869 for (j = 0; j < ARRAY_SIZE(disable_seq); j++) 4870 alc298_samsung_write_coef_pack(codec, disable_seq[j]); 4871 codec_dbg(codec, "alc298_samsung_v2: Disabled speaker amp 0x%02x\n", 4872 alc298_samsung_v2_amp_desc_tbl[i].nid); 4873 } 4874 } 4875 4876 static void alc298_samsung_v2_playback_hook(struct hda_pcm_stream *hinfo, 4877 struct hda_codec *codec, 4878 struct snd_pcm_substream *substream, 4879 int action) 4880 { 4881 /* Dynamically enable/disable speaker amps before and after playback */ 4882 if (action == HDA_GEN_PCM_ACT_OPEN) 4883 alc298_samsung_v2_enable_amps(codec); 4884 if (action == HDA_GEN_PCM_ACT_CLOSE) 4885 alc298_samsung_v2_disable_amps(codec); 4886 } 4887 4888 static void alc298_samsung_v2_init_amps(struct hda_codec *codec, 4889 int num_speaker_amps) 4890 { 4891 struct alc_spec *spec = codec->spec; 4892 int i, j; 4893 4894 /* Set spec's num_speaker_amps before doing anything else */ 4895 spec->num_speaker_amps = num_speaker_amps; 4896 4897 /* Disable speaker amps before init to prevent any physical damage */ 4898 alc298_samsung_v2_disable_amps(codec); 4899 4900 /* Initialize the speaker amps */ 4901 for (i = 0; i < spec->num_speaker_amps; i++) { 4902 alc_write_coef_idx(codec, 0x22, alc298_samsung_v2_amp_desc_tbl[i].nid); 4903 for (j = 0; j < alc298_samsung_v2_amp_desc_tbl[i].init_seq_size; j++) { 4904 alc298_samsung_write_coef_pack(codec, 4905 alc298_samsung_v2_amp_desc_tbl[i].init_seq[j]); 4906 } 4907 alc_write_coef_idx(codec, 0x89, 0x0); 4908 codec_dbg(codec, "alc298_samsung_v2: Initialized speaker amp 0x%02x\n", 4909 alc298_samsung_v2_amp_desc_tbl[i].nid); 4910 } 4911 4912 /* register hook to enable speaker amps only when they are needed */ 4913 spec->gen.pcm_playback_hook = alc298_samsung_v2_playback_hook; 4914 } 4915 4916 static void alc298_fixup_samsung_amp_v2_2_amps(struct hda_codec *codec, 4917 const struct hda_fixup *fix, int action) 4918 { 4919 if (action == HDA_FIXUP_ACT_PROBE) 4920 alc298_samsung_v2_init_amps(codec, 2); 4921 } 4922 4923 static void alc298_fixup_samsung_amp_v2_4_amps(struct hda_codec *codec, 4924 const struct hda_fixup *fix, int action) 4925 { 4926 if (action == HDA_FIXUP_ACT_PROBE) 4927 alc298_samsung_v2_init_amps(codec, 4); 4928 } 4929 4930 #if IS_REACHABLE(CONFIG_INPUT) 4931 static void gpio2_mic_hotkey_event(struct hda_codec *codec, 4932 struct hda_jack_callback *event) 4933 { 4934 struct alc_spec *spec = codec->spec; 4935 4936 /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore 4937 send both key on and key off event for every interrupt. */ 4938 input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1); 4939 input_sync(spec->kb_dev); 4940 input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0); 4941 input_sync(spec->kb_dev); 4942 } 4943 4944 static int alc_register_micmute_input_device(struct hda_codec *codec) 4945 { 4946 struct alc_spec *spec = codec->spec; 4947 int i; 4948 4949 spec->kb_dev = input_allocate_device(); 4950 if (!spec->kb_dev) { 4951 codec_err(codec, "Out of memory (input_allocate_device)\n"); 4952 return -ENOMEM; 4953 } 4954 4955 spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE; 4956 4957 spec->kb_dev->name = "Microphone Mute Button"; 4958 spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY); 4959 spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]); 4960 spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map); 4961 spec->kb_dev->keycode = spec->alc_mute_keycode_map; 4962 for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++) 4963 set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit); 4964 4965 if (input_register_device(spec->kb_dev)) { 4966 codec_err(codec, "input_register_device failed\n"); 4967 input_free_device(spec->kb_dev); 4968 spec->kb_dev = NULL; 4969 return -ENOMEM; 4970 } 4971 4972 return 0; 4973 } 4974 4975 /* GPIO1 = set according to SKU external amp 4976 * GPIO2 = mic mute hotkey 4977 * GPIO3 = mute LED 4978 * GPIO4 = mic mute LED 4979 */ 4980 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec, 4981 const struct hda_fixup *fix, int action) 4982 { 4983 struct alc_spec *spec = codec->spec; 4984 4985 alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10); 4986 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4987 spec->init_amp = ALC_INIT_DEFAULT; 4988 if (alc_register_micmute_input_device(codec) != 0) 4989 return; 4990 4991 spec->gpio_mask |= 0x06; 4992 spec->gpio_dir |= 0x02; 4993 spec->gpio_data |= 0x02; 4994 snd_hda_codec_write_cache(codec, codec->core.afg, 0, 4995 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04); 4996 snd_hda_jack_detect_enable_callback(codec, codec->core.afg, 4997 gpio2_mic_hotkey_event); 4998 return; 4999 } 5000 5001 if (!spec->kb_dev) 5002 return; 5003 5004 switch (action) { 5005 case HDA_FIXUP_ACT_FREE: 5006 input_unregister_device(spec->kb_dev); 5007 spec->kb_dev = NULL; 5008 } 5009 } 5010 5011 /* Line2 = mic mute hotkey 5012 * GPIO2 = mic mute LED 5013 */ 5014 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec, 5015 const struct hda_fixup *fix, int action) 5016 { 5017 struct alc_spec *spec = codec->spec; 5018 5019 alc_fixup_hp_gpio_led(codec, action, 0, 0x04); 5020 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5021 spec->init_amp = ALC_INIT_DEFAULT; 5022 if (alc_register_micmute_input_device(codec) != 0) 5023 return; 5024 5025 snd_hda_jack_detect_enable_callback(codec, 0x1b, 5026 gpio2_mic_hotkey_event); 5027 return; 5028 } 5029 5030 if (!spec->kb_dev) 5031 return; 5032 5033 switch (action) { 5034 case HDA_FIXUP_ACT_FREE: 5035 input_unregister_device(spec->kb_dev); 5036 spec->kb_dev = NULL; 5037 } 5038 } 5039 #else /* INPUT */ 5040 #define alc280_fixup_hp_gpio2_mic_hotkey NULL 5041 #define alc233_fixup_lenovo_line2_mic_hotkey NULL 5042 #endif /* INPUT */ 5043 5044 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec, 5045 const struct hda_fixup *fix, int action) 5046 { 5047 struct alc_spec *spec = codec->spec; 5048 5049 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1a); 5050 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5051 spec->cap_mute_led_nid = 0x18; 5052 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set); 5053 } 5054 } 5055 5056 static void alc_hp_mute_disable(struct hda_codec *codec, unsigned int delay) 5057 { 5058 if (delay <= 0) 5059 delay = 75; 5060 snd_hda_codec_write(codec, 0x21, 0, 5061 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 5062 msleep(delay); 5063 snd_hda_codec_write(codec, 0x21, 0, 5064 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 5065 msleep(delay); 5066 } 5067 5068 static void alc_hp_enable_unmute(struct hda_codec *codec, unsigned int delay) 5069 { 5070 if (delay <= 0) 5071 delay = 75; 5072 snd_hda_codec_write(codec, 0x21, 0, 5073 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 5074 msleep(delay); 5075 snd_hda_codec_write(codec, 0x21, 0, 5076 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 5077 msleep(delay); 5078 } 5079 5080 static const struct coef_fw alc225_pre_hsmode[] = { 5081 UPDATE_COEF(0x4a, 1<<8, 0), 5082 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), 5083 UPDATE_COEF(0x63, 3<<14, 3<<14), 5084 UPDATE_COEF(0x4a, 3<<4, 2<<4), 5085 UPDATE_COEF(0x4a, 3<<10, 3<<10), 5086 UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10), 5087 UPDATE_COEF(0x4a, 3<<10, 0), 5088 {} 5089 }; 5090 5091 static void alc_headset_mode_unplugged(struct hda_codec *codec) 5092 { 5093 struct alc_spec *spec = codec->spec; 5094 static const struct coef_fw coef0255[] = { 5095 WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */ 5096 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */ 5097 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/ 5098 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */ 5099 WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */ 5100 {} 5101 }; 5102 static const struct coef_fw coef0256[] = { 5103 WRITE_COEF(0x1b, 0x0c4b), /* LDO and MISC control */ 5104 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */ 5105 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */ 5106 WRITE_COEFEX(0x57, 0x03, 0x09a3), /* Direct Drive HP Amp control */ 5107 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/ 5108 {} 5109 }; 5110 static const struct coef_fw coef0233[] = { 5111 WRITE_COEF(0x1b, 0x0c0b), 5112 WRITE_COEF(0x45, 0xc429), 5113 UPDATE_COEF(0x35, 0x4000, 0), 5114 WRITE_COEF(0x06, 0x2104), 5115 WRITE_COEF(0x1a, 0x0001), 5116 WRITE_COEF(0x26, 0x0004), 5117 WRITE_COEF(0x32, 0x42a3), 5118 {} 5119 }; 5120 static const struct coef_fw coef0288[] = { 5121 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), 5122 UPDATE_COEF(0x50, 0x2000, 0x2000), 5123 UPDATE_COEF(0x56, 0x0006, 0x0006), 5124 UPDATE_COEF(0x66, 0x0008, 0), 5125 UPDATE_COEF(0x67, 0x2000, 0), 5126 {} 5127 }; 5128 static const struct coef_fw coef0298[] = { 5129 UPDATE_COEF(0x19, 0x1300, 0x0300), 5130 {} 5131 }; 5132 static const struct coef_fw coef0292[] = { 5133 WRITE_COEF(0x76, 0x000e), 5134 WRITE_COEF(0x6c, 0x2400), 5135 WRITE_COEF(0x18, 0x7308), 5136 WRITE_COEF(0x6b, 0xc429), 5137 {} 5138 }; 5139 static const struct coef_fw coef0293[] = { 5140 UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */ 5141 UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */ 5142 UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */ 5143 UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */ 5144 WRITE_COEF(0x45, 0xc429), /* Set to TRS type */ 5145 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */ 5146 {} 5147 }; 5148 static const struct coef_fw coef0668[] = { 5149 WRITE_COEF(0x15, 0x0d40), 5150 WRITE_COEF(0xb7, 0x802b), 5151 {} 5152 }; 5153 static const struct coef_fw coef0225[] = { 5154 UPDATE_COEF(0x63, 3<<14, 0), 5155 {} 5156 }; 5157 static const struct coef_fw coef0274[] = { 5158 UPDATE_COEF(0x4a, 0x0100, 0), 5159 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0), 5160 UPDATE_COEF(0x6b, 0xf000, 0x5000), 5161 UPDATE_COEF(0x4a, 0x0010, 0), 5162 UPDATE_COEF(0x4a, 0x0c00, 0x0c00), 5163 WRITE_COEF(0x45, 0x5289), 5164 UPDATE_COEF(0x4a, 0x0c00, 0), 5165 {} 5166 }; 5167 5168 if (spec->no_internal_mic_pin) { 5169 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12); 5170 return; 5171 } 5172 5173 switch (codec->core.vendor_id) { 5174 case 0x10ec0255: 5175 alc_process_coef_fw(codec, coef0255); 5176 break; 5177 case 0x10ec0230: 5178 case 0x10ec0236: 5179 case 0x10ec0256: 5180 case 0x19e58326: 5181 alc_hp_mute_disable(codec, 75); 5182 alc_process_coef_fw(codec, coef0256); 5183 break; 5184 case 0x10ec0234: 5185 case 0x10ec0274: 5186 case 0x10ec0294: 5187 alc_process_coef_fw(codec, coef0274); 5188 break; 5189 case 0x10ec0233: 5190 case 0x10ec0283: 5191 alc_process_coef_fw(codec, coef0233); 5192 break; 5193 case 0x10ec0286: 5194 case 0x10ec0288: 5195 alc_process_coef_fw(codec, coef0288); 5196 break; 5197 case 0x10ec0298: 5198 alc_process_coef_fw(codec, coef0298); 5199 alc_process_coef_fw(codec, coef0288); 5200 break; 5201 case 0x10ec0292: 5202 alc_process_coef_fw(codec, coef0292); 5203 break; 5204 case 0x10ec0293: 5205 alc_process_coef_fw(codec, coef0293); 5206 break; 5207 case 0x10ec0668: 5208 alc_process_coef_fw(codec, coef0668); 5209 break; 5210 case 0x10ec0215: 5211 case 0x10ec0225: 5212 case 0x10ec0285: 5213 case 0x10ec0295: 5214 case 0x10ec0289: 5215 case 0x10ec0299: 5216 alc_hp_mute_disable(codec, 75); 5217 alc_process_coef_fw(codec, alc225_pre_hsmode); 5218 alc_process_coef_fw(codec, coef0225); 5219 break; 5220 case 0x10ec0867: 5221 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0); 5222 break; 5223 } 5224 codec_dbg(codec, "Headset jack set to unplugged mode.\n"); 5225 } 5226 5227 5228 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin, 5229 hda_nid_t mic_pin) 5230 { 5231 static const struct coef_fw coef0255[] = { 5232 WRITE_COEFEX(0x57, 0x03, 0x8aa6), 5233 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */ 5234 {} 5235 }; 5236 static const struct coef_fw coef0256[] = { 5237 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), /* Direct Drive HP Amp control(Set to verb control)*/ 5238 WRITE_COEFEX(0x57, 0x03, 0x09a3), 5239 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */ 5240 {} 5241 }; 5242 static const struct coef_fw coef0233[] = { 5243 UPDATE_COEF(0x35, 0, 1<<14), 5244 WRITE_COEF(0x06, 0x2100), 5245 WRITE_COEF(0x1a, 0x0021), 5246 WRITE_COEF(0x26, 0x008c), 5247 {} 5248 }; 5249 static const struct coef_fw coef0288[] = { 5250 UPDATE_COEF(0x4f, 0x00c0, 0), 5251 UPDATE_COEF(0x50, 0x2000, 0), 5252 UPDATE_COEF(0x56, 0x0006, 0), 5253 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), 5254 UPDATE_COEF(0x66, 0x0008, 0x0008), 5255 UPDATE_COEF(0x67, 0x2000, 0x2000), 5256 {} 5257 }; 5258 static const struct coef_fw coef0292[] = { 5259 WRITE_COEF(0x19, 0xa208), 5260 WRITE_COEF(0x2e, 0xacf0), 5261 {} 5262 }; 5263 static const struct coef_fw coef0293[] = { 5264 UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */ 5265 UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */ 5266 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */ 5267 {} 5268 }; 5269 static const struct coef_fw coef0688[] = { 5270 WRITE_COEF(0xb7, 0x802b), 5271 WRITE_COEF(0xb5, 0x1040), 5272 UPDATE_COEF(0xc3, 0, 1<<12), 5273 {} 5274 }; 5275 static const struct coef_fw coef0225[] = { 5276 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), 5277 UPDATE_COEF(0x4a, 3<<4, 2<<4), 5278 UPDATE_COEF(0x63, 3<<14, 0), 5279 {} 5280 }; 5281 static const struct coef_fw coef0274[] = { 5282 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0x4000), 5283 UPDATE_COEF(0x4a, 0x0010, 0), 5284 UPDATE_COEF(0x6b, 0xf000, 0), 5285 {} 5286 }; 5287 5288 switch (codec->core.vendor_id) { 5289 case 0x10ec0255: 5290 alc_write_coef_idx(codec, 0x45, 0xc489); 5291 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5292 alc_process_coef_fw(codec, coef0255); 5293 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 5294 break; 5295 case 0x10ec0230: 5296 case 0x10ec0236: 5297 case 0x10ec0256: 5298 case 0x19e58326: 5299 alc_write_coef_idx(codec, 0x45, 0xc489); 5300 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5301 alc_process_coef_fw(codec, coef0256); 5302 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 5303 break; 5304 case 0x10ec0234: 5305 case 0x10ec0274: 5306 case 0x10ec0294: 5307 alc_write_coef_idx(codec, 0x45, 0x4689); 5308 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5309 alc_process_coef_fw(codec, coef0274); 5310 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 5311 break; 5312 case 0x10ec0233: 5313 case 0x10ec0283: 5314 alc_write_coef_idx(codec, 0x45, 0xc429); 5315 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5316 alc_process_coef_fw(codec, coef0233); 5317 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 5318 break; 5319 case 0x10ec0286: 5320 case 0x10ec0288: 5321 case 0x10ec0298: 5322 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5323 alc_process_coef_fw(codec, coef0288); 5324 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 5325 break; 5326 case 0x10ec0292: 5327 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5328 alc_process_coef_fw(codec, coef0292); 5329 break; 5330 case 0x10ec0293: 5331 /* Set to TRS mode */ 5332 alc_write_coef_idx(codec, 0x45, 0xc429); 5333 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5334 alc_process_coef_fw(codec, coef0293); 5335 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 5336 break; 5337 case 0x10ec0867: 5338 alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14); 5339 fallthrough; 5340 case 0x10ec0221: 5341 case 0x10ec0662: 5342 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5343 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 5344 break; 5345 case 0x10ec0668: 5346 alc_write_coef_idx(codec, 0x11, 0x0001); 5347 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5348 alc_process_coef_fw(codec, coef0688); 5349 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 5350 break; 5351 case 0x10ec0215: 5352 case 0x10ec0225: 5353 case 0x10ec0285: 5354 case 0x10ec0295: 5355 case 0x10ec0289: 5356 case 0x10ec0299: 5357 alc_process_coef_fw(codec, alc225_pre_hsmode); 5358 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10); 5359 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5360 alc_process_coef_fw(codec, coef0225); 5361 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 5362 break; 5363 } 5364 codec_dbg(codec, "Headset jack set to mic-in mode.\n"); 5365 } 5366 5367 static void alc_headset_mode_default(struct hda_codec *codec) 5368 { 5369 static const struct coef_fw coef0225[] = { 5370 UPDATE_COEF(0x45, 0x3f<<10, 0x30<<10), 5371 UPDATE_COEF(0x45, 0x3f<<10, 0x31<<10), 5372 UPDATE_COEF(0x49, 3<<8, 0<<8), 5373 UPDATE_COEF(0x4a, 3<<4, 3<<4), 5374 UPDATE_COEF(0x63, 3<<14, 0), 5375 UPDATE_COEF(0x67, 0xf000, 0x3000), 5376 {} 5377 }; 5378 static const struct coef_fw coef0255[] = { 5379 WRITE_COEF(0x45, 0xc089), 5380 WRITE_COEF(0x45, 0xc489), 5381 WRITE_COEFEX(0x57, 0x03, 0x8ea6), 5382 WRITE_COEF(0x49, 0x0049), 5383 {} 5384 }; 5385 static const struct coef_fw coef0256[] = { 5386 WRITE_COEF(0x45, 0xc489), 5387 WRITE_COEFEX(0x57, 0x03, 0x0da3), 5388 WRITE_COEF(0x49, 0x0049), 5389 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/ 5390 WRITE_COEF(0x06, 0x6100), 5391 {} 5392 }; 5393 static const struct coef_fw coef0233[] = { 5394 WRITE_COEF(0x06, 0x2100), 5395 WRITE_COEF(0x32, 0x4ea3), 5396 {} 5397 }; 5398 static const struct coef_fw coef0288[] = { 5399 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */ 5400 UPDATE_COEF(0x50, 0x2000, 0x2000), 5401 UPDATE_COEF(0x56, 0x0006, 0x0006), 5402 UPDATE_COEF(0x66, 0x0008, 0), 5403 UPDATE_COEF(0x67, 0x2000, 0), 5404 {} 5405 }; 5406 static const struct coef_fw coef0292[] = { 5407 WRITE_COEF(0x76, 0x000e), 5408 WRITE_COEF(0x6c, 0x2400), 5409 WRITE_COEF(0x6b, 0xc429), 5410 WRITE_COEF(0x18, 0x7308), 5411 {} 5412 }; 5413 static const struct coef_fw coef0293[] = { 5414 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */ 5415 WRITE_COEF(0x45, 0xC429), /* Set to TRS type */ 5416 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */ 5417 {} 5418 }; 5419 static const struct coef_fw coef0688[] = { 5420 WRITE_COEF(0x11, 0x0041), 5421 WRITE_COEF(0x15, 0x0d40), 5422 WRITE_COEF(0xb7, 0x802b), 5423 {} 5424 }; 5425 static const struct coef_fw coef0274[] = { 5426 WRITE_COEF(0x45, 0x4289), 5427 UPDATE_COEF(0x4a, 0x0010, 0x0010), 5428 UPDATE_COEF(0x6b, 0x0f00, 0), 5429 UPDATE_COEF(0x49, 0x0300, 0x0300), 5430 {} 5431 }; 5432 5433 switch (codec->core.vendor_id) { 5434 case 0x10ec0215: 5435 case 0x10ec0225: 5436 case 0x10ec0285: 5437 case 0x10ec0295: 5438 case 0x10ec0289: 5439 case 0x10ec0299: 5440 alc_process_coef_fw(codec, alc225_pre_hsmode); 5441 alc_process_coef_fw(codec, coef0225); 5442 alc_hp_enable_unmute(codec, 75); 5443 break; 5444 case 0x10ec0255: 5445 alc_process_coef_fw(codec, coef0255); 5446 break; 5447 case 0x10ec0230: 5448 case 0x10ec0236: 5449 case 0x10ec0256: 5450 case 0x19e58326: 5451 alc_write_coef_idx(codec, 0x1b, 0x0e4b); 5452 alc_write_coef_idx(codec, 0x45, 0xc089); 5453 msleep(50); 5454 alc_process_coef_fw(codec, coef0256); 5455 alc_hp_enable_unmute(codec, 75); 5456 break; 5457 case 0x10ec0234: 5458 case 0x10ec0274: 5459 case 0x10ec0294: 5460 alc_process_coef_fw(codec, coef0274); 5461 break; 5462 case 0x10ec0233: 5463 case 0x10ec0283: 5464 alc_process_coef_fw(codec, coef0233); 5465 break; 5466 case 0x10ec0286: 5467 case 0x10ec0288: 5468 case 0x10ec0298: 5469 alc_process_coef_fw(codec, coef0288); 5470 break; 5471 case 0x10ec0292: 5472 alc_process_coef_fw(codec, coef0292); 5473 break; 5474 case 0x10ec0293: 5475 alc_process_coef_fw(codec, coef0293); 5476 break; 5477 case 0x10ec0668: 5478 alc_process_coef_fw(codec, coef0688); 5479 break; 5480 case 0x10ec0867: 5481 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0); 5482 break; 5483 } 5484 codec_dbg(codec, "Headset jack set to headphone (default) mode.\n"); 5485 } 5486 5487 /* Iphone type */ 5488 static void alc_headset_mode_ctia(struct hda_codec *codec) 5489 { 5490 int val; 5491 5492 static const struct coef_fw coef0255[] = { 5493 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */ 5494 WRITE_COEF(0x1b, 0x0c2b), 5495 WRITE_COEFEX(0x57, 0x03, 0x8ea6), 5496 {} 5497 }; 5498 static const struct coef_fw coef0256[] = { 5499 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */ 5500 WRITE_COEF(0x1b, 0x0e6b), 5501 {} 5502 }; 5503 static const struct coef_fw coef0233[] = { 5504 WRITE_COEF(0x45, 0xd429), 5505 WRITE_COEF(0x1b, 0x0c2b), 5506 WRITE_COEF(0x32, 0x4ea3), 5507 {} 5508 }; 5509 static const struct coef_fw coef0288[] = { 5510 UPDATE_COEF(0x50, 0x2000, 0x2000), 5511 UPDATE_COEF(0x56, 0x0006, 0x0006), 5512 UPDATE_COEF(0x66, 0x0008, 0), 5513 UPDATE_COEF(0x67, 0x2000, 0), 5514 {} 5515 }; 5516 static const struct coef_fw coef0292[] = { 5517 WRITE_COEF(0x6b, 0xd429), 5518 WRITE_COEF(0x76, 0x0008), 5519 WRITE_COEF(0x18, 0x7388), 5520 {} 5521 }; 5522 static const struct coef_fw coef0293[] = { 5523 WRITE_COEF(0x45, 0xd429), /* Set to ctia type */ 5524 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */ 5525 {} 5526 }; 5527 static const struct coef_fw coef0688[] = { 5528 WRITE_COEF(0x11, 0x0001), 5529 WRITE_COEF(0x15, 0x0d60), 5530 WRITE_COEF(0xc3, 0x0000), 5531 {} 5532 }; 5533 static const struct coef_fw coef0225_1[] = { 5534 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10), 5535 UPDATE_COEF(0x63, 3<<14, 2<<14), 5536 {} 5537 }; 5538 static const struct coef_fw coef0225_2[] = { 5539 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10), 5540 UPDATE_COEF(0x63, 3<<14, 1<<14), 5541 {} 5542 }; 5543 5544 switch (codec->core.vendor_id) { 5545 case 0x10ec0255: 5546 alc_process_coef_fw(codec, coef0255); 5547 break; 5548 case 0x10ec0230: 5549 case 0x10ec0236: 5550 case 0x10ec0256: 5551 case 0x19e58326: 5552 alc_process_coef_fw(codec, coef0256); 5553 alc_hp_enable_unmute(codec, 75); 5554 break; 5555 case 0x10ec0234: 5556 case 0x10ec0274: 5557 case 0x10ec0294: 5558 alc_write_coef_idx(codec, 0x45, 0xd689); 5559 break; 5560 case 0x10ec0233: 5561 case 0x10ec0283: 5562 alc_process_coef_fw(codec, coef0233); 5563 break; 5564 case 0x10ec0298: 5565 val = alc_read_coef_idx(codec, 0x50); 5566 if (val & (1 << 12)) { 5567 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020); 5568 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400); 5569 msleep(300); 5570 } else { 5571 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010); 5572 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400); 5573 msleep(300); 5574 } 5575 break; 5576 case 0x10ec0286: 5577 case 0x10ec0288: 5578 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400); 5579 msleep(300); 5580 alc_process_coef_fw(codec, coef0288); 5581 break; 5582 case 0x10ec0292: 5583 alc_process_coef_fw(codec, coef0292); 5584 break; 5585 case 0x10ec0293: 5586 alc_process_coef_fw(codec, coef0293); 5587 break; 5588 case 0x10ec0668: 5589 alc_process_coef_fw(codec, coef0688); 5590 break; 5591 case 0x10ec0215: 5592 case 0x10ec0225: 5593 case 0x10ec0285: 5594 case 0x10ec0295: 5595 case 0x10ec0289: 5596 case 0x10ec0299: 5597 val = alc_read_coef_idx(codec, 0x45); 5598 if (val & (1 << 9)) 5599 alc_process_coef_fw(codec, coef0225_2); 5600 else 5601 alc_process_coef_fw(codec, coef0225_1); 5602 alc_hp_enable_unmute(codec, 75); 5603 break; 5604 case 0x10ec0867: 5605 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0); 5606 break; 5607 } 5608 codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n"); 5609 } 5610 5611 /* Nokia type */ 5612 static void alc_headset_mode_omtp(struct hda_codec *codec) 5613 { 5614 static const struct coef_fw coef0255[] = { 5615 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */ 5616 WRITE_COEF(0x1b, 0x0c2b), 5617 WRITE_COEFEX(0x57, 0x03, 0x8ea6), 5618 {} 5619 }; 5620 static const struct coef_fw coef0256[] = { 5621 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */ 5622 WRITE_COEF(0x1b, 0x0e6b), 5623 {} 5624 }; 5625 static const struct coef_fw coef0233[] = { 5626 WRITE_COEF(0x45, 0xe429), 5627 WRITE_COEF(0x1b, 0x0c2b), 5628 WRITE_COEF(0x32, 0x4ea3), 5629 {} 5630 }; 5631 static const struct coef_fw coef0288[] = { 5632 UPDATE_COEF(0x50, 0x2000, 0x2000), 5633 UPDATE_COEF(0x56, 0x0006, 0x0006), 5634 UPDATE_COEF(0x66, 0x0008, 0), 5635 UPDATE_COEF(0x67, 0x2000, 0), 5636 {} 5637 }; 5638 static const struct coef_fw coef0292[] = { 5639 WRITE_COEF(0x6b, 0xe429), 5640 WRITE_COEF(0x76, 0x0008), 5641 WRITE_COEF(0x18, 0x7388), 5642 {} 5643 }; 5644 static const struct coef_fw coef0293[] = { 5645 WRITE_COEF(0x45, 0xe429), /* Set to omtp type */ 5646 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */ 5647 {} 5648 }; 5649 static const struct coef_fw coef0688[] = { 5650 WRITE_COEF(0x11, 0x0001), 5651 WRITE_COEF(0x15, 0x0d50), 5652 WRITE_COEF(0xc3, 0x0000), 5653 {} 5654 }; 5655 static const struct coef_fw coef0225[] = { 5656 UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10), 5657 UPDATE_COEF(0x63, 3<<14, 2<<14), 5658 {} 5659 }; 5660 5661 switch (codec->core.vendor_id) { 5662 case 0x10ec0255: 5663 alc_process_coef_fw(codec, coef0255); 5664 break; 5665 case 0x10ec0230: 5666 case 0x10ec0236: 5667 case 0x10ec0256: 5668 case 0x19e58326: 5669 alc_process_coef_fw(codec, coef0256); 5670 alc_hp_enable_unmute(codec, 75); 5671 break; 5672 case 0x10ec0234: 5673 case 0x10ec0274: 5674 case 0x10ec0294: 5675 alc_write_coef_idx(codec, 0x45, 0xe689); 5676 break; 5677 case 0x10ec0233: 5678 case 0x10ec0283: 5679 alc_process_coef_fw(codec, coef0233); 5680 break; 5681 case 0x10ec0298: 5682 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */ 5683 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400); 5684 msleep(300); 5685 break; 5686 case 0x10ec0286: 5687 case 0x10ec0288: 5688 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400); 5689 msleep(300); 5690 alc_process_coef_fw(codec, coef0288); 5691 break; 5692 case 0x10ec0292: 5693 alc_process_coef_fw(codec, coef0292); 5694 break; 5695 case 0x10ec0293: 5696 alc_process_coef_fw(codec, coef0293); 5697 break; 5698 case 0x10ec0668: 5699 alc_process_coef_fw(codec, coef0688); 5700 break; 5701 case 0x10ec0215: 5702 case 0x10ec0225: 5703 case 0x10ec0285: 5704 case 0x10ec0295: 5705 case 0x10ec0289: 5706 case 0x10ec0299: 5707 alc_process_coef_fw(codec, coef0225); 5708 alc_hp_enable_unmute(codec, 75); 5709 break; 5710 } 5711 codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n"); 5712 } 5713 5714 static void alc_determine_headset_type(struct hda_codec *codec) 5715 { 5716 int val; 5717 bool is_ctia = false; 5718 struct alc_spec *spec = codec->spec; 5719 static const struct coef_fw coef0255[] = { 5720 WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/ 5721 WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref 5722 conteol) */ 5723 {} 5724 }; 5725 static const struct coef_fw coef0288[] = { 5726 UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */ 5727 {} 5728 }; 5729 static const struct coef_fw coef0298[] = { 5730 UPDATE_COEF(0x50, 0x2000, 0x2000), 5731 UPDATE_COEF(0x56, 0x0006, 0x0006), 5732 UPDATE_COEF(0x66, 0x0008, 0), 5733 UPDATE_COEF(0x67, 0x2000, 0), 5734 UPDATE_COEF(0x19, 0x1300, 0x1300), 5735 {} 5736 }; 5737 static const struct coef_fw coef0293[] = { 5738 UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */ 5739 WRITE_COEF(0x45, 0xD429), /* Set to ctia type */ 5740 {} 5741 }; 5742 static const struct coef_fw coef0688[] = { 5743 WRITE_COEF(0x11, 0x0001), 5744 WRITE_COEF(0xb7, 0x802b), 5745 WRITE_COEF(0x15, 0x0d60), 5746 WRITE_COEF(0xc3, 0x0c00), 5747 {} 5748 }; 5749 static const struct coef_fw coef0274[] = { 5750 UPDATE_COEF(0x4a, 0x0010, 0), 5751 UPDATE_COEF(0x4a, 0x8000, 0), 5752 WRITE_COEF(0x45, 0xd289), 5753 UPDATE_COEF(0x49, 0x0300, 0x0300), 5754 {} 5755 }; 5756 5757 if (spec->no_internal_mic_pin) { 5758 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12); 5759 return; 5760 } 5761 5762 switch (codec->core.vendor_id) { 5763 case 0x10ec0255: 5764 alc_process_coef_fw(codec, coef0255); 5765 msleep(300); 5766 val = alc_read_coef_idx(codec, 0x46); 5767 is_ctia = (val & 0x0070) == 0x0070; 5768 break; 5769 case 0x10ec0230: 5770 case 0x10ec0236: 5771 case 0x10ec0256: 5772 case 0x19e58326: 5773 alc_write_coef_idx(codec, 0x1b, 0x0e4b); 5774 alc_write_coef_idx(codec, 0x06, 0x6104); 5775 alc_write_coefex_idx(codec, 0x57, 0x3, 0x09a3); 5776 5777 alc_process_coef_fw(codec, coef0255); 5778 msleep(300); 5779 val = alc_read_coef_idx(codec, 0x46); 5780 is_ctia = (val & 0x0070) == 0x0070; 5781 if (!is_ctia) { 5782 alc_write_coef_idx(codec, 0x45, 0xe089); 5783 msleep(100); 5784 val = alc_read_coef_idx(codec, 0x46); 5785 if ((val & 0x0070) == 0x0070) 5786 is_ctia = false; 5787 else 5788 is_ctia = true; 5789 } 5790 alc_write_coefex_idx(codec, 0x57, 0x3, 0x0da3); 5791 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0); 5792 break; 5793 case 0x10ec0234: 5794 case 0x10ec0274: 5795 case 0x10ec0294: 5796 alc_process_coef_fw(codec, coef0274); 5797 msleep(850); 5798 val = alc_read_coef_idx(codec, 0x46); 5799 is_ctia = (val & 0x00f0) == 0x00f0; 5800 break; 5801 case 0x10ec0233: 5802 case 0x10ec0283: 5803 alc_write_coef_idx(codec, 0x45, 0xd029); 5804 msleep(300); 5805 val = alc_read_coef_idx(codec, 0x46); 5806 is_ctia = (val & 0x0070) == 0x0070; 5807 break; 5808 case 0x10ec0298: 5809 snd_hda_codec_write(codec, 0x21, 0, 5810 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 5811 msleep(100); 5812 snd_hda_codec_write(codec, 0x21, 0, 5813 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 5814 msleep(200); 5815 5816 val = alc_read_coef_idx(codec, 0x50); 5817 if (val & (1 << 12)) { 5818 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020); 5819 alc_process_coef_fw(codec, coef0288); 5820 msleep(350); 5821 val = alc_read_coef_idx(codec, 0x50); 5822 is_ctia = (val & 0x0070) == 0x0070; 5823 } else { 5824 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010); 5825 alc_process_coef_fw(codec, coef0288); 5826 msleep(350); 5827 val = alc_read_coef_idx(codec, 0x50); 5828 is_ctia = (val & 0x0070) == 0x0070; 5829 } 5830 alc_process_coef_fw(codec, coef0298); 5831 snd_hda_codec_write(codec, 0x21, 0, 5832 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP); 5833 msleep(75); 5834 snd_hda_codec_write(codec, 0x21, 0, 5835 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 5836 break; 5837 case 0x10ec0286: 5838 case 0x10ec0288: 5839 alc_process_coef_fw(codec, coef0288); 5840 msleep(350); 5841 val = alc_read_coef_idx(codec, 0x50); 5842 is_ctia = (val & 0x0070) == 0x0070; 5843 break; 5844 case 0x10ec0292: 5845 alc_write_coef_idx(codec, 0x6b, 0xd429); 5846 msleep(300); 5847 val = alc_read_coef_idx(codec, 0x6c); 5848 is_ctia = (val & 0x001c) == 0x001c; 5849 break; 5850 case 0x10ec0293: 5851 alc_process_coef_fw(codec, coef0293); 5852 msleep(300); 5853 val = alc_read_coef_idx(codec, 0x46); 5854 is_ctia = (val & 0x0070) == 0x0070; 5855 break; 5856 case 0x10ec0668: 5857 alc_process_coef_fw(codec, coef0688); 5858 msleep(300); 5859 val = alc_read_coef_idx(codec, 0xbe); 5860 is_ctia = (val & 0x1c02) == 0x1c02; 5861 break; 5862 case 0x10ec0215: 5863 case 0x10ec0225: 5864 case 0x10ec0285: 5865 case 0x10ec0295: 5866 case 0x10ec0289: 5867 case 0x10ec0299: 5868 alc_process_coef_fw(codec, alc225_pre_hsmode); 5869 alc_update_coef_idx(codec, 0x67, 0xf000, 0x1000); 5870 val = alc_read_coef_idx(codec, 0x45); 5871 if (val & (1 << 9)) { 5872 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10); 5873 alc_update_coef_idx(codec, 0x49, 3<<8, 2<<8); 5874 msleep(800); 5875 val = alc_read_coef_idx(codec, 0x46); 5876 is_ctia = (val & 0x00f0) == 0x00f0; 5877 } else { 5878 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10); 5879 alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8); 5880 msleep(800); 5881 val = alc_read_coef_idx(codec, 0x46); 5882 is_ctia = (val & 0x00f0) == 0x00f0; 5883 } 5884 if (!is_ctia) { 5885 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x38<<10); 5886 alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8); 5887 msleep(100); 5888 val = alc_read_coef_idx(codec, 0x46); 5889 if ((val & 0x00f0) == 0x00f0) 5890 is_ctia = false; 5891 else 5892 is_ctia = true; 5893 } 5894 alc_update_coef_idx(codec, 0x4a, 7<<6, 7<<6); 5895 alc_update_coef_idx(codec, 0x4a, 3<<4, 3<<4); 5896 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000); 5897 break; 5898 case 0x10ec0867: 5899 is_ctia = true; 5900 break; 5901 } 5902 5903 codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n", 5904 str_yes_no(is_ctia)); 5905 spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP; 5906 } 5907 5908 static void alc_update_headset_mode(struct hda_codec *codec) 5909 { 5910 struct alc_spec *spec = codec->spec; 5911 5912 hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]]; 5913 hda_nid_t hp_pin = alc_get_hp_pin(spec); 5914 5915 int new_headset_mode; 5916 5917 if (!snd_hda_jack_detect(codec, hp_pin)) 5918 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED; 5919 else if (mux_pin == spec->headset_mic_pin) 5920 new_headset_mode = ALC_HEADSET_MODE_HEADSET; 5921 else if (mux_pin == spec->headphone_mic_pin) 5922 new_headset_mode = ALC_HEADSET_MODE_MIC; 5923 else 5924 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE; 5925 5926 if (new_headset_mode == spec->current_headset_mode) { 5927 snd_hda_gen_update_outputs(codec); 5928 return; 5929 } 5930 5931 switch (new_headset_mode) { 5932 case ALC_HEADSET_MODE_UNPLUGGED: 5933 alc_headset_mode_unplugged(codec); 5934 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN; 5935 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN; 5936 spec->gen.hp_jack_present = false; 5937 break; 5938 case ALC_HEADSET_MODE_HEADSET: 5939 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN) 5940 alc_determine_headset_type(codec); 5941 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA) 5942 alc_headset_mode_ctia(codec); 5943 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP) 5944 alc_headset_mode_omtp(codec); 5945 spec->gen.hp_jack_present = true; 5946 break; 5947 case ALC_HEADSET_MODE_MIC: 5948 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin); 5949 spec->gen.hp_jack_present = false; 5950 break; 5951 case ALC_HEADSET_MODE_HEADPHONE: 5952 alc_headset_mode_default(codec); 5953 spec->gen.hp_jack_present = true; 5954 break; 5955 } 5956 if (new_headset_mode != ALC_HEADSET_MODE_MIC) { 5957 snd_hda_set_pin_ctl_cache(codec, hp_pin, 5958 AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN); 5959 if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin) 5960 snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin, 5961 PIN_VREFHIZ); 5962 } 5963 spec->current_headset_mode = new_headset_mode; 5964 5965 snd_hda_gen_update_outputs(codec); 5966 } 5967 5968 static void alc_update_headset_mode_hook(struct hda_codec *codec, 5969 struct snd_kcontrol *kcontrol, 5970 struct snd_ctl_elem_value *ucontrol) 5971 { 5972 alc_update_headset_mode(codec); 5973 } 5974 5975 static void alc_update_headset_jack_cb(struct hda_codec *codec, 5976 struct hda_jack_callback *jack) 5977 { 5978 snd_hda_gen_hp_automute(codec, jack); 5979 alc_update_headset_mode(codec); 5980 } 5981 5982 static void alc_probe_headset_mode(struct hda_codec *codec) 5983 { 5984 int i; 5985 struct alc_spec *spec = codec->spec; 5986 struct auto_pin_cfg *cfg = &spec->gen.autocfg; 5987 5988 /* Find mic pins */ 5989 for (i = 0; i < cfg->num_inputs; i++) { 5990 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin) 5991 spec->headset_mic_pin = cfg->inputs[i].pin; 5992 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin) 5993 spec->headphone_mic_pin = cfg->inputs[i].pin; 5994 } 5995 5996 WARN_ON(spec->gen.cap_sync_hook); 5997 spec->gen.cap_sync_hook = alc_update_headset_mode_hook; 5998 spec->gen.automute_hook = alc_update_headset_mode; 5999 spec->gen.hp_automute_hook = alc_update_headset_jack_cb; 6000 } 6001 6002 static void alc_fixup_headset_mode(struct hda_codec *codec, 6003 const struct hda_fixup *fix, int action) 6004 { 6005 struct alc_spec *spec = codec->spec; 6006 6007 switch (action) { 6008 case HDA_FIXUP_ACT_PRE_PROBE: 6009 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC; 6010 break; 6011 case HDA_FIXUP_ACT_PROBE: 6012 alc_probe_headset_mode(codec); 6013 break; 6014 case HDA_FIXUP_ACT_INIT: 6015 if (is_s3_resume(codec) || is_s4_resume(codec)) { 6016 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN; 6017 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN; 6018 } 6019 alc_update_headset_mode(codec); 6020 break; 6021 } 6022 } 6023 6024 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec, 6025 const struct hda_fixup *fix, int action) 6026 { 6027 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6028 struct alc_spec *spec = codec->spec; 6029 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 6030 } 6031 else 6032 alc_fixup_headset_mode(codec, fix, action); 6033 } 6034 6035 static void alc255_set_default_jack_type(struct hda_codec *codec) 6036 { 6037 /* Set to iphone type */ 6038 static const struct coef_fw alc255fw[] = { 6039 WRITE_COEF(0x1b, 0x880b), 6040 WRITE_COEF(0x45, 0xd089), 6041 WRITE_COEF(0x1b, 0x080b), 6042 WRITE_COEF(0x46, 0x0004), 6043 WRITE_COEF(0x1b, 0x0c0b), 6044 {} 6045 }; 6046 static const struct coef_fw alc256fw[] = { 6047 WRITE_COEF(0x1b, 0x884b), 6048 WRITE_COEF(0x45, 0xd089), 6049 WRITE_COEF(0x1b, 0x084b), 6050 WRITE_COEF(0x46, 0x0004), 6051 WRITE_COEF(0x1b, 0x0c4b), 6052 {} 6053 }; 6054 switch (codec->core.vendor_id) { 6055 case 0x10ec0255: 6056 alc_process_coef_fw(codec, alc255fw); 6057 break; 6058 case 0x10ec0230: 6059 case 0x10ec0236: 6060 case 0x10ec0256: 6061 case 0x19e58326: 6062 alc_process_coef_fw(codec, alc256fw); 6063 break; 6064 } 6065 msleep(30); 6066 } 6067 6068 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec, 6069 const struct hda_fixup *fix, int action) 6070 { 6071 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6072 alc255_set_default_jack_type(codec); 6073 } 6074 alc_fixup_headset_mode(codec, fix, action); 6075 } 6076 6077 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec, 6078 const struct hda_fixup *fix, int action) 6079 { 6080 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6081 struct alc_spec *spec = codec->spec; 6082 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 6083 alc255_set_default_jack_type(codec); 6084 } 6085 else 6086 alc_fixup_headset_mode(codec, fix, action); 6087 } 6088 6089 static void alc288_update_headset_jack_cb(struct hda_codec *codec, 6090 struct hda_jack_callback *jack) 6091 { 6092 struct alc_spec *spec = codec->spec; 6093 6094 alc_update_headset_jack_cb(codec, jack); 6095 /* Headset Mic enable or disable, only for Dell Dino */ 6096 alc_update_gpio_data(codec, 0x40, spec->gen.hp_jack_present); 6097 } 6098 6099 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec, 6100 const struct hda_fixup *fix, int action) 6101 { 6102 alc_fixup_headset_mode(codec, fix, action); 6103 if (action == HDA_FIXUP_ACT_PROBE) { 6104 struct alc_spec *spec = codec->spec; 6105 /* toggled via hp_automute_hook */ 6106 spec->gpio_mask |= 0x40; 6107 spec->gpio_dir |= 0x40; 6108 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb; 6109 } 6110 } 6111 6112 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec, 6113 const struct hda_fixup *fix, int action) 6114 { 6115 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6116 struct alc_spec *spec = codec->spec; 6117 spec->gen.auto_mute_via_amp = 1; 6118 } 6119 } 6120 6121 static void alc_fixup_no_shutup(struct hda_codec *codec, 6122 const struct hda_fixup *fix, int action) 6123 { 6124 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6125 struct alc_spec *spec = codec->spec; 6126 spec->no_shutup_pins = 1; 6127 } 6128 } 6129 6130 static void alc_fixup_disable_aamix(struct hda_codec *codec, 6131 const struct hda_fixup *fix, int action) 6132 { 6133 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6134 struct alc_spec *spec = codec->spec; 6135 /* Disable AA-loopback as it causes white noise */ 6136 spec->gen.mixer_nid = 0; 6137 } 6138 } 6139 6140 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */ 6141 static void alc_fixup_tpt440_dock(struct hda_codec *codec, 6142 const struct hda_fixup *fix, int action) 6143 { 6144 static const struct hda_pintbl pincfgs[] = { 6145 { 0x16, 0x21211010 }, /* dock headphone */ 6146 { 0x19, 0x21a11010 }, /* dock mic */ 6147 { } 6148 }; 6149 struct alc_spec *spec = codec->spec; 6150 6151 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6152 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 6153 codec->power_save_node = 0; /* avoid click noises */ 6154 snd_hda_apply_pincfgs(codec, pincfgs); 6155 } 6156 } 6157 6158 static void alc_fixup_tpt470_dock(struct hda_codec *codec, 6159 const struct hda_fixup *fix, int action) 6160 { 6161 static const struct hda_pintbl pincfgs[] = { 6162 { 0x17, 0x21211010 }, /* dock headphone */ 6163 { 0x19, 0x21a11010 }, /* dock mic */ 6164 { } 6165 }; 6166 struct alc_spec *spec = codec->spec; 6167 6168 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6169 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 6170 snd_hda_apply_pincfgs(codec, pincfgs); 6171 } else if (action == HDA_FIXUP_ACT_INIT) { 6172 /* Enable DOCK device */ 6173 snd_hda_codec_write(codec, 0x17, 0, 6174 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0); 6175 /* Enable DOCK device */ 6176 snd_hda_codec_write(codec, 0x19, 0, 6177 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0); 6178 } 6179 } 6180 6181 static void alc_fixup_tpt470_dacs(struct hda_codec *codec, 6182 const struct hda_fixup *fix, int action) 6183 { 6184 /* Assure the speaker pin to be coupled with DAC NID 0x03; otherwise 6185 * the speaker output becomes too low by some reason on Thinkpads with 6186 * ALC298 codec 6187 */ 6188 static const hda_nid_t preferred_pairs[] = { 6189 0x14, 0x03, 0x17, 0x02, 0x21, 0x02, 6190 0 6191 }; 6192 struct alc_spec *spec = codec->spec; 6193 6194 if (action == HDA_FIXUP_ACT_PRE_PROBE) 6195 spec->gen.preferred_dacs = preferred_pairs; 6196 } 6197 6198 static void alc295_fixup_asus_dacs(struct hda_codec *codec, 6199 const struct hda_fixup *fix, int action) 6200 { 6201 static const hda_nid_t preferred_pairs[] = { 6202 0x17, 0x02, 0x21, 0x03, 0 6203 }; 6204 struct alc_spec *spec = codec->spec; 6205 6206 if (action == HDA_FIXUP_ACT_PRE_PROBE) 6207 spec->gen.preferred_dacs = preferred_pairs; 6208 } 6209 6210 static void alc_shutup_dell_xps13(struct hda_codec *codec) 6211 { 6212 struct alc_spec *spec = codec->spec; 6213 int hp_pin = alc_get_hp_pin(spec); 6214 6215 /* Prevent pop noises when headphones are plugged in */ 6216 snd_hda_codec_write(codec, hp_pin, 0, 6217 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 6218 msleep(20); 6219 } 6220 6221 static void alc_fixup_dell_xps13(struct hda_codec *codec, 6222 const struct hda_fixup *fix, int action) 6223 { 6224 struct alc_spec *spec = codec->spec; 6225 struct hda_input_mux *imux = &spec->gen.input_mux; 6226 int i; 6227 6228 switch (action) { 6229 case HDA_FIXUP_ACT_PRE_PROBE: 6230 /* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise 6231 * it causes a click noise at start up 6232 */ 6233 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ); 6234 spec->shutup = alc_shutup_dell_xps13; 6235 break; 6236 case HDA_FIXUP_ACT_PROBE: 6237 /* Make the internal mic the default input source. */ 6238 for (i = 0; i < imux->num_items; i++) { 6239 if (spec->gen.imux_pins[i] == 0x12) { 6240 spec->gen.cur_mux[0] = i; 6241 break; 6242 } 6243 } 6244 break; 6245 } 6246 } 6247 6248 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec, 6249 const struct hda_fixup *fix, int action) 6250 { 6251 struct alc_spec *spec = codec->spec; 6252 6253 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6254 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 6255 spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */ 6256 6257 /* Disable boost for mic-in permanently. (This code is only called 6258 from quirks that guarantee that the headphone is at NID 0x1b.) */ 6259 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000); 6260 snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP); 6261 } else 6262 alc_fixup_headset_mode(codec, fix, action); 6263 } 6264 6265 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec, 6266 const struct hda_fixup *fix, int action) 6267 { 6268 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6269 alc_write_coef_idx(codec, 0xc4, 0x8000); 6270 alc_update_coef_idx(codec, 0xc2, ~0xfe, 0); 6271 snd_hda_set_pin_ctl_cache(codec, 0x18, 0); 6272 } 6273 alc_fixup_headset_mode(codec, fix, action); 6274 } 6275 6276 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */ 6277 static int find_ext_mic_pin(struct hda_codec *codec) 6278 { 6279 struct alc_spec *spec = codec->spec; 6280 struct auto_pin_cfg *cfg = &spec->gen.autocfg; 6281 hda_nid_t nid; 6282 unsigned int defcfg; 6283 int i; 6284 6285 for (i = 0; i < cfg->num_inputs; i++) { 6286 if (cfg->inputs[i].type != AUTO_PIN_MIC) 6287 continue; 6288 nid = cfg->inputs[i].pin; 6289 defcfg = snd_hda_codec_get_pincfg(codec, nid); 6290 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT) 6291 continue; 6292 return nid; 6293 } 6294 6295 return 0; 6296 } 6297 6298 static void alc271_hp_gate_mic_jack(struct hda_codec *codec, 6299 const struct hda_fixup *fix, 6300 int action) 6301 { 6302 struct alc_spec *spec = codec->spec; 6303 6304 if (action == HDA_FIXUP_ACT_PROBE) { 6305 int mic_pin = find_ext_mic_pin(codec); 6306 int hp_pin = alc_get_hp_pin(spec); 6307 6308 if (snd_BUG_ON(!mic_pin || !hp_pin)) 6309 return; 6310 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin); 6311 } 6312 } 6313 6314 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec, 6315 const struct hda_fixup *fix, 6316 int action) 6317 { 6318 struct alc_spec *spec = codec->spec; 6319 struct auto_pin_cfg *cfg = &spec->gen.autocfg; 6320 int i; 6321 6322 /* The mic boosts on level 2 and 3 are too noisy 6323 on the internal mic input. 6324 Therefore limit the boost to 0 or 1. */ 6325 6326 if (action != HDA_FIXUP_ACT_PROBE) 6327 return; 6328 6329 for (i = 0; i < cfg->num_inputs; i++) { 6330 hda_nid_t nid = cfg->inputs[i].pin; 6331 unsigned int defcfg; 6332 if (cfg->inputs[i].type != AUTO_PIN_MIC) 6333 continue; 6334 defcfg = snd_hda_codec_get_pincfg(codec, nid); 6335 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT) 6336 continue; 6337 6338 snd_hda_override_amp_caps(codec, nid, HDA_INPUT, 6339 (0x00 << AC_AMPCAP_OFFSET_SHIFT) | 6340 (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) | 6341 (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) | 6342 (0 << AC_AMPCAP_MUTE_SHIFT)); 6343 } 6344 } 6345 6346 static void alc283_hp_automute_hook(struct hda_codec *codec, 6347 struct hda_jack_callback *jack) 6348 { 6349 struct alc_spec *spec = codec->spec; 6350 int vref; 6351 6352 msleep(200); 6353 snd_hda_gen_hp_automute(codec, jack); 6354 6355 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0; 6356 6357 msleep(600); 6358 snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 6359 vref); 6360 } 6361 6362 static void alc283_fixup_chromebook(struct hda_codec *codec, 6363 const struct hda_fixup *fix, int action) 6364 { 6365 struct alc_spec *spec = codec->spec; 6366 6367 switch (action) { 6368 case HDA_FIXUP_ACT_PRE_PROBE: 6369 snd_hda_override_wcaps(codec, 0x03, 0); 6370 /* Disable AA-loopback as it causes white noise */ 6371 spec->gen.mixer_nid = 0; 6372 break; 6373 case HDA_FIXUP_ACT_INIT: 6374 /* MIC2-VREF control */ 6375 /* Set to manual mode */ 6376 alc_update_coef_idx(codec, 0x06, 0x000c, 0); 6377 /* Enable Line1 input control by verb */ 6378 alc_update_coef_idx(codec, 0x1a, 0, 1 << 4); 6379 break; 6380 } 6381 } 6382 6383 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec, 6384 const struct hda_fixup *fix, int action) 6385 { 6386 struct alc_spec *spec = codec->spec; 6387 6388 switch (action) { 6389 case HDA_FIXUP_ACT_PRE_PROBE: 6390 spec->gen.hp_automute_hook = alc283_hp_automute_hook; 6391 break; 6392 case HDA_FIXUP_ACT_INIT: 6393 /* MIC2-VREF control */ 6394 /* Set to manual mode */ 6395 alc_update_coef_idx(codec, 0x06, 0x000c, 0); 6396 break; 6397 } 6398 } 6399 6400 /* mute tablet speaker pin (0x14) via dock plugging in addition */ 6401 static void asus_tx300_automute(struct hda_codec *codec) 6402 { 6403 struct alc_spec *spec = codec->spec; 6404 snd_hda_gen_update_outputs(codec); 6405 if (snd_hda_jack_detect(codec, 0x1b)) 6406 spec->gen.mute_bits |= (1ULL << 0x14); 6407 } 6408 6409 static void alc282_fixup_asus_tx300(struct hda_codec *codec, 6410 const struct hda_fixup *fix, int action) 6411 { 6412 struct alc_spec *spec = codec->spec; 6413 static const struct hda_pintbl dock_pins[] = { 6414 { 0x1b, 0x21114000 }, /* dock speaker pin */ 6415 {} 6416 }; 6417 6418 switch (action) { 6419 case HDA_FIXUP_ACT_PRE_PROBE: 6420 spec->init_amp = ALC_INIT_DEFAULT; 6421 /* TX300 needs to set up GPIO2 for the speaker amp */ 6422 alc_setup_gpio(codec, 0x04); 6423 snd_hda_apply_pincfgs(codec, dock_pins); 6424 spec->gen.auto_mute_via_amp = 1; 6425 spec->gen.automute_hook = asus_tx300_automute; 6426 snd_hda_jack_detect_enable_callback(codec, 0x1b, 6427 snd_hda_gen_hp_automute); 6428 break; 6429 case HDA_FIXUP_ACT_PROBE: 6430 spec->init_amp = ALC_INIT_DEFAULT; 6431 break; 6432 case HDA_FIXUP_ACT_BUILD: 6433 /* this is a bit tricky; give more sane names for the main 6434 * (tablet) speaker and the dock speaker, respectively 6435 */ 6436 rename_ctl(codec, "Speaker Playback Switch", 6437 "Dock Speaker Playback Switch"); 6438 rename_ctl(codec, "Bass Speaker Playback Switch", 6439 "Speaker Playback Switch"); 6440 break; 6441 } 6442 } 6443 6444 static void alc290_fixup_mono_speakers(struct hda_codec *codec, 6445 const struct hda_fixup *fix, int action) 6446 { 6447 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6448 /* DAC node 0x03 is giving mono output. We therefore want to 6449 make sure 0x14 (front speaker) and 0x15 (headphones) use the 6450 stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */ 6451 static const hda_nid_t conn1[] = { 0x0c }; 6452 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1); 6453 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1); 6454 } 6455 } 6456 6457 static void alc298_fixup_speaker_volume(struct hda_codec *codec, 6458 const struct hda_fixup *fix, int action) 6459 { 6460 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6461 /* The speaker is routed to the Node 0x06 by a mistake, as a result 6462 we can't adjust the speaker's volume since this node does not has 6463 Amp-out capability. we change the speaker's route to: 6464 Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 ( 6465 Pin Complex), since Node 0x02 has Amp-out caps, we can adjust 6466 speaker's volume now. */ 6467 6468 static const hda_nid_t conn1[] = { 0x0c }; 6469 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn1), conn1); 6470 } 6471 } 6472 6473 /* disable DAC3 (0x06) selection on NID 0x17 as it has no volume amp control */ 6474 static void alc295_fixup_disable_dac3(struct hda_codec *codec, 6475 const struct hda_fixup *fix, int action) 6476 { 6477 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6478 static const hda_nid_t conn[] = { 0x02, 0x03 }; 6479 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 6480 } 6481 } 6482 6483 /* force NID 0x17 (Bass Speaker) to DAC1 to share it with the main speaker */ 6484 static void alc285_fixup_speaker2_to_dac1(struct hda_codec *codec, 6485 const struct hda_fixup *fix, int action) 6486 { 6487 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6488 static const hda_nid_t conn[] = { 0x02 }; 6489 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 6490 } 6491 } 6492 6493 /* disable DAC3 (0x06) selection on NID 0x15 - share Speaker/Bass Speaker DAC 0x03 */ 6494 static void alc294_fixup_bass_speaker_15(struct hda_codec *codec, 6495 const struct hda_fixup *fix, int action) 6496 { 6497 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6498 static const hda_nid_t conn[] = { 0x02, 0x03 }; 6499 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn), conn); 6500 } 6501 } 6502 6503 /* Hook to update amp GPIO4 for automute */ 6504 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec, 6505 struct hda_jack_callback *jack) 6506 { 6507 struct alc_spec *spec = codec->spec; 6508 6509 snd_hda_gen_hp_automute(codec, jack); 6510 /* mute_led_polarity is set to 0, so we pass inverted value here */ 6511 alc_update_gpio_led(codec, 0x10, spec->mute_led_polarity, 6512 !spec->gen.hp_jack_present); 6513 } 6514 6515 /* Manage GPIOs for HP EliteBook Folio 9480m. 6516 * 6517 * GPIO4 is the headphone amplifier power control 6518 * GPIO3 is the audio output mute indicator LED 6519 */ 6520 6521 static void alc280_fixup_hp_9480m(struct hda_codec *codec, 6522 const struct hda_fixup *fix, 6523 int action) 6524 { 6525 struct alc_spec *spec = codec->spec; 6526 6527 alc_fixup_hp_gpio_led(codec, action, 0x08, 0); 6528 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6529 /* amp at GPIO4; toggled via alc280_hp_gpio4_automute_hook() */ 6530 spec->gpio_mask |= 0x10; 6531 spec->gpio_dir |= 0x10; 6532 spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook; 6533 } 6534 } 6535 6536 static void alc275_fixup_gpio4_off(struct hda_codec *codec, 6537 const struct hda_fixup *fix, 6538 int action) 6539 { 6540 struct alc_spec *spec = codec->spec; 6541 6542 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6543 spec->gpio_mask |= 0x04; 6544 spec->gpio_dir |= 0x04; 6545 /* set data bit low */ 6546 } 6547 } 6548 6549 /* Quirk for Thinkpad X1 7th and 8th Gen 6550 * The following fixed routing needed 6551 * DAC1 (NID 0x02) -> Speaker (NID 0x14); some eq applied secretly 6552 * DAC2 (NID 0x03) -> Bass (NID 0x17) & Headphone (NID 0x21); sharing a DAC 6553 * DAC3 (NID 0x06) -> Unused, due to the lack of volume amp 6554 */ 6555 static void alc285_fixup_thinkpad_x1_gen7(struct hda_codec *codec, 6556 const struct hda_fixup *fix, int action) 6557 { 6558 static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */ 6559 static const hda_nid_t preferred_pairs[] = { 6560 0x14, 0x02, 0x17, 0x03, 0x21, 0x03, 0 6561 }; 6562 struct alc_spec *spec = codec->spec; 6563 6564 switch (action) { 6565 case HDA_FIXUP_ACT_PRE_PROBE: 6566 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 6567 spec->gen.preferred_dacs = preferred_pairs; 6568 break; 6569 case HDA_FIXUP_ACT_BUILD: 6570 /* The generic parser creates somewhat unintuitive volume ctls 6571 * with the fixed routing above, and the shared DAC2 may be 6572 * confusing for PA. 6573 * Rename those to unique names so that PA doesn't touch them 6574 * and use only Master volume. 6575 */ 6576 rename_ctl(codec, "Front Playback Volume", "DAC1 Playback Volume"); 6577 rename_ctl(codec, "Bass Speaker Playback Volume", "DAC2 Playback Volume"); 6578 break; 6579 } 6580 } 6581 6582 static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec, 6583 const struct hda_fixup *fix, 6584 int action) 6585 { 6586 alc_fixup_dual_codecs(codec, fix, action); 6587 switch (action) { 6588 case HDA_FIXUP_ACT_PRE_PROBE: 6589 /* override card longname to provide a unique UCM profile */ 6590 strcpy(codec->card->longname, "HDAudio-Lenovo-DualCodecs"); 6591 break; 6592 case HDA_FIXUP_ACT_BUILD: 6593 /* rename Capture controls depending on the codec */ 6594 rename_ctl(codec, "Capture Volume", 6595 codec->addr == 0 ? 6596 "Rear-Panel Capture Volume" : 6597 "Front-Panel Capture Volume"); 6598 rename_ctl(codec, "Capture Switch", 6599 codec->addr == 0 ? 6600 "Rear-Panel Capture Switch" : 6601 "Front-Panel Capture Switch"); 6602 break; 6603 } 6604 } 6605 6606 static void alc225_fixup_s3_pop_noise(struct hda_codec *codec, 6607 const struct hda_fixup *fix, int action) 6608 { 6609 if (action != HDA_FIXUP_ACT_PRE_PROBE) 6610 return; 6611 6612 codec->power_save_node = 1; 6613 } 6614 6615 /* Forcibly assign NID 0x03 to HP/LO while NID 0x02 to SPK for EQ */ 6616 static void alc274_fixup_bind_dacs(struct hda_codec *codec, 6617 const struct hda_fixup *fix, int action) 6618 { 6619 struct alc_spec *spec = codec->spec; 6620 static const hda_nid_t preferred_pairs[] = { 6621 0x21, 0x03, 0x1b, 0x03, 0x16, 0x02, 6622 0 6623 }; 6624 6625 if (action != HDA_FIXUP_ACT_PRE_PROBE) 6626 return; 6627 6628 spec->gen.preferred_dacs = preferred_pairs; 6629 spec->gen.auto_mute_via_amp = 1; 6630 codec->power_save_node = 0; 6631 } 6632 6633 /* avoid DAC 0x06 for bass speaker 0x17; it has no volume control */ 6634 static void alc289_fixup_asus_ga401(struct hda_codec *codec, 6635 const struct hda_fixup *fix, int action) 6636 { 6637 static const hda_nid_t preferred_pairs[] = { 6638 0x14, 0x02, 0x17, 0x02, 0x21, 0x03, 0 6639 }; 6640 struct alc_spec *spec = codec->spec; 6641 6642 if (action == HDA_FIXUP_ACT_PRE_PROBE) 6643 spec->gen.preferred_dacs = preferred_pairs; 6644 } 6645 6646 /* The DAC of NID 0x3 will introduce click/pop noise on headphones, so invalidate it */ 6647 static void alc285_fixup_invalidate_dacs(struct hda_codec *codec, 6648 const struct hda_fixup *fix, int action) 6649 { 6650 if (action != HDA_FIXUP_ACT_PRE_PROBE) 6651 return; 6652 6653 snd_hda_override_wcaps(codec, 0x03, 0); 6654 } 6655 6656 static void alc_combo_jack_hp_jd_restart(struct hda_codec *codec) 6657 { 6658 switch (codec->core.vendor_id) { 6659 case 0x10ec0274: 6660 case 0x10ec0294: 6661 case 0x10ec0225: 6662 case 0x10ec0295: 6663 case 0x10ec0299: 6664 alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */ 6665 alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15); 6666 break; 6667 case 0x10ec0230: 6668 case 0x10ec0235: 6669 case 0x10ec0236: 6670 case 0x10ec0255: 6671 case 0x10ec0256: 6672 case 0x10ec0257: 6673 case 0x19e58326: 6674 alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */ 6675 alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15); 6676 break; 6677 } 6678 } 6679 6680 static void alc295_fixup_chromebook(struct hda_codec *codec, 6681 const struct hda_fixup *fix, int action) 6682 { 6683 struct alc_spec *spec = codec->spec; 6684 6685 switch (action) { 6686 case HDA_FIXUP_ACT_PRE_PROBE: 6687 spec->ultra_low_power = true; 6688 break; 6689 case HDA_FIXUP_ACT_INIT: 6690 alc_combo_jack_hp_jd_restart(codec); 6691 break; 6692 } 6693 } 6694 6695 static void alc256_fixup_chromebook(struct hda_codec *codec, 6696 const struct hda_fixup *fix, int action) 6697 { 6698 struct alc_spec *spec = codec->spec; 6699 6700 switch (action) { 6701 case HDA_FIXUP_ACT_PRE_PROBE: 6702 spec->gen.suppress_auto_mute = 1; 6703 spec->gen.suppress_auto_mic = 1; 6704 spec->en_3kpull_low = false; 6705 break; 6706 } 6707 } 6708 6709 static void alc_fixup_disable_mic_vref(struct hda_codec *codec, 6710 const struct hda_fixup *fix, int action) 6711 { 6712 if (action == HDA_FIXUP_ACT_PRE_PROBE) 6713 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ); 6714 } 6715 6716 6717 static void alc294_gx502_toggle_output(struct hda_codec *codec, 6718 struct hda_jack_callback *cb) 6719 { 6720 /* The Windows driver sets the codec up in a very different way where 6721 * it appears to leave 0x10 = 0x8a20 set. For Linux we need to toggle it 6722 */ 6723 if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT) 6724 alc_write_coef_idx(codec, 0x10, 0x8a20); 6725 else 6726 alc_write_coef_idx(codec, 0x10, 0x0a20); 6727 } 6728 6729 static void alc294_fixup_gx502_hp(struct hda_codec *codec, 6730 const struct hda_fixup *fix, int action) 6731 { 6732 /* Pin 0x21: headphones/headset mic */ 6733 if (!is_jack_detectable(codec, 0x21)) 6734 return; 6735 6736 switch (action) { 6737 case HDA_FIXUP_ACT_PRE_PROBE: 6738 snd_hda_jack_detect_enable_callback(codec, 0x21, 6739 alc294_gx502_toggle_output); 6740 break; 6741 case HDA_FIXUP_ACT_INIT: 6742 /* Make sure to start in a correct state, i.e. if 6743 * headphones have been plugged in before powering up the system 6744 */ 6745 alc294_gx502_toggle_output(codec, NULL); 6746 break; 6747 } 6748 } 6749 6750 static void alc294_gu502_toggle_output(struct hda_codec *codec, 6751 struct hda_jack_callback *cb) 6752 { 6753 /* Windows sets 0x10 to 0x8420 for Node 0x20 which is 6754 * responsible from changes between speakers and headphones 6755 */ 6756 if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT) 6757 alc_write_coef_idx(codec, 0x10, 0x8420); 6758 else 6759 alc_write_coef_idx(codec, 0x10, 0x0a20); 6760 } 6761 6762 static void alc294_fixup_gu502_hp(struct hda_codec *codec, 6763 const struct hda_fixup *fix, int action) 6764 { 6765 if (!is_jack_detectable(codec, 0x21)) 6766 return; 6767 6768 switch (action) { 6769 case HDA_FIXUP_ACT_PRE_PROBE: 6770 snd_hda_jack_detect_enable_callback(codec, 0x21, 6771 alc294_gu502_toggle_output); 6772 break; 6773 case HDA_FIXUP_ACT_INIT: 6774 alc294_gu502_toggle_output(codec, NULL); 6775 break; 6776 } 6777 } 6778 6779 static void alc285_fixup_hp_gpio_amp_init(struct hda_codec *codec, 6780 const struct hda_fixup *fix, int action) 6781 { 6782 if (action != HDA_FIXUP_ACT_INIT) 6783 return; 6784 6785 msleep(100); 6786 alc_write_coef_idx(codec, 0x65, 0x0); 6787 } 6788 6789 static void alc274_fixup_hp_headset_mic(struct hda_codec *codec, 6790 const struct hda_fixup *fix, int action) 6791 { 6792 switch (action) { 6793 case HDA_FIXUP_ACT_INIT: 6794 alc_combo_jack_hp_jd_restart(codec); 6795 break; 6796 } 6797 } 6798 6799 static void alc_fixup_no_int_mic(struct hda_codec *codec, 6800 const struct hda_fixup *fix, int action) 6801 { 6802 struct alc_spec *spec = codec->spec; 6803 6804 switch (action) { 6805 case HDA_FIXUP_ACT_PRE_PROBE: 6806 /* Mic RING SLEEVE swap for combo jack */ 6807 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12); 6808 spec->no_internal_mic_pin = true; 6809 break; 6810 case HDA_FIXUP_ACT_INIT: 6811 alc_combo_jack_hp_jd_restart(codec); 6812 break; 6813 } 6814 } 6815 6816 /* GPIO1 = amplifier on/off 6817 * GPIO3 = mic mute LED 6818 */ 6819 static void alc285_fixup_hp_spectre_x360_eb1(struct hda_codec *codec, 6820 const struct hda_fixup *fix, int action) 6821 { 6822 static const hda_nid_t conn[] = { 0x02 }; 6823 6824 struct alc_spec *spec = codec->spec; 6825 static const struct hda_pintbl pincfgs[] = { 6826 { 0x14, 0x90170110 }, /* front/high speakers */ 6827 { 0x17, 0x90170130 }, /* back/bass speakers */ 6828 { } 6829 }; 6830 6831 //enable micmute led 6832 alc_fixup_hp_gpio_led(codec, action, 0x00, 0x04); 6833 6834 switch (action) { 6835 case HDA_FIXUP_ACT_PRE_PROBE: 6836 spec->micmute_led_polarity = 1; 6837 /* needed for amp of back speakers */ 6838 spec->gpio_mask |= 0x01; 6839 spec->gpio_dir |= 0x01; 6840 snd_hda_apply_pincfgs(codec, pincfgs); 6841 /* share DAC to have unified volume control */ 6842 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn); 6843 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 6844 break; 6845 case HDA_FIXUP_ACT_INIT: 6846 /* need to toggle GPIO to enable the amp of back speakers */ 6847 alc_update_gpio_data(codec, 0x01, true); 6848 msleep(100); 6849 alc_update_gpio_data(codec, 0x01, false); 6850 break; 6851 } 6852 } 6853 6854 static void alc285_fixup_hp_spectre_x360(struct hda_codec *codec, 6855 const struct hda_fixup *fix, int action) 6856 { 6857 static const hda_nid_t conn[] = { 0x02 }; 6858 static const struct hda_pintbl pincfgs[] = { 6859 { 0x14, 0x90170110 }, /* rear speaker */ 6860 { } 6861 }; 6862 6863 switch (action) { 6864 case HDA_FIXUP_ACT_PRE_PROBE: 6865 snd_hda_apply_pincfgs(codec, pincfgs); 6866 /* force front speaker to DAC1 */ 6867 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 6868 break; 6869 } 6870 } 6871 6872 static void alc285_fixup_hp_envy_x360(struct hda_codec *codec, 6873 const struct hda_fixup *fix, 6874 int action) 6875 { 6876 static const struct coef_fw coefs[] = { 6877 WRITE_COEF(0x08, 0x6a0c), WRITE_COEF(0x0d, 0xa023), 6878 WRITE_COEF(0x10, 0x0320), WRITE_COEF(0x1a, 0x8c03), 6879 WRITE_COEF(0x25, 0x1800), WRITE_COEF(0x26, 0x003a), 6880 WRITE_COEF(0x28, 0x1dfe), WRITE_COEF(0x29, 0xb014), 6881 WRITE_COEF(0x2b, 0x1dfe), WRITE_COEF(0x37, 0xfe15), 6882 WRITE_COEF(0x38, 0x7909), WRITE_COEF(0x45, 0xd489), 6883 WRITE_COEF(0x46, 0x00f4), WRITE_COEF(0x4a, 0x21e0), 6884 WRITE_COEF(0x66, 0x03f0), WRITE_COEF(0x67, 0x1000), 6885 WRITE_COEF(0x6e, 0x1005), { } 6886 }; 6887 6888 static const struct hda_pintbl pincfgs[] = { 6889 { 0x12, 0xb7a60130 }, /* Internal microphone*/ 6890 { 0x14, 0x90170150 }, /* B&O soundbar speakers */ 6891 { 0x17, 0x90170153 }, /* Side speakers */ 6892 { 0x19, 0x03a11040 }, /* Headset microphone */ 6893 { } 6894 }; 6895 6896 switch (action) { 6897 case HDA_FIXUP_ACT_PRE_PROBE: 6898 snd_hda_apply_pincfgs(codec, pincfgs); 6899 6900 /* Fixes volume control problem for side speakers */ 6901 alc295_fixup_disable_dac3(codec, fix, action); 6902 6903 /* Fixes no sound from headset speaker */ 6904 snd_hda_codec_amp_stereo(codec, 0x21, HDA_OUTPUT, 0, -1, 0); 6905 6906 /* Auto-enable headset mic when plugged */ 6907 snd_hda_jack_set_gating_jack(codec, 0x19, 0x21); 6908 6909 /* Headset mic volume enhancement */ 6910 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREF50); 6911 break; 6912 case HDA_FIXUP_ACT_INIT: 6913 alc_process_coef_fw(codec, coefs); 6914 break; 6915 case HDA_FIXUP_ACT_BUILD: 6916 rename_ctl(codec, "Bass Speaker Playback Volume", 6917 "B&O-Tuned Playback Volume"); 6918 rename_ctl(codec, "Front Playback Switch", 6919 "B&O Soundbar Playback Switch"); 6920 rename_ctl(codec, "Bass Speaker Playback Switch", 6921 "Side Speaker Playback Switch"); 6922 break; 6923 } 6924 } 6925 6926 /* for hda_fixup_thinkpad_acpi() */ 6927 #include "thinkpad_helper.c" 6928 6929 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec, 6930 const struct hda_fixup *fix, int action) 6931 { 6932 alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */ 6933 hda_fixup_thinkpad_acpi(codec, fix, action); 6934 } 6935 6936 /* for hda_fixup_ideapad_acpi() */ 6937 #include "ideapad_hotkey_led_helper.c" 6938 6939 static void alc_fixup_ideapad_acpi(struct hda_codec *codec, 6940 const struct hda_fixup *fix, int action) 6941 { 6942 hda_fixup_ideapad_acpi(codec, fix, action); 6943 } 6944 6945 /* Fixup for Lenovo Legion 15IMHg05 speaker output on headset removal. */ 6946 static void alc287_fixup_legion_15imhg05_speakers(struct hda_codec *codec, 6947 const struct hda_fixup *fix, 6948 int action) 6949 { 6950 struct alc_spec *spec = codec->spec; 6951 6952 switch (action) { 6953 case HDA_FIXUP_ACT_PRE_PROBE: 6954 spec->gen.suppress_auto_mute = 1; 6955 break; 6956 } 6957 } 6958 6959 static void comp_acpi_device_notify(acpi_handle handle, u32 event, void *data) 6960 { 6961 struct hda_codec *cdc = data; 6962 struct alc_spec *spec = cdc->spec; 6963 6964 codec_info(cdc, "ACPI Notification %d\n", event); 6965 6966 hda_component_acpi_device_notify(&spec->comps, handle, event, data); 6967 } 6968 6969 static int comp_bind(struct device *dev) 6970 { 6971 struct hda_codec *cdc = dev_to_hda_codec(dev); 6972 struct alc_spec *spec = cdc->spec; 6973 int ret; 6974 6975 ret = hda_component_manager_bind(cdc, &spec->comps); 6976 if (ret) 6977 return ret; 6978 6979 return hda_component_manager_bind_acpi_notifications(cdc, 6980 &spec->comps, 6981 comp_acpi_device_notify, cdc); 6982 } 6983 6984 static void comp_unbind(struct device *dev) 6985 { 6986 struct hda_codec *cdc = dev_to_hda_codec(dev); 6987 struct alc_spec *spec = cdc->spec; 6988 6989 hda_component_manager_unbind_acpi_notifications(cdc, &spec->comps, comp_acpi_device_notify); 6990 hda_component_manager_unbind(cdc, &spec->comps); 6991 } 6992 6993 static const struct component_master_ops comp_master_ops = { 6994 .bind = comp_bind, 6995 .unbind = comp_unbind, 6996 }; 6997 6998 static void comp_generic_playback_hook(struct hda_pcm_stream *hinfo, struct hda_codec *cdc, 6999 struct snd_pcm_substream *sub, int action) 7000 { 7001 struct alc_spec *spec = cdc->spec; 7002 7003 hda_component_manager_playback_hook(&spec->comps, action); 7004 } 7005 7006 static void comp_generic_fixup(struct hda_codec *cdc, int action, const char *bus, 7007 const char *hid, const char *match_str, int count) 7008 { 7009 struct alc_spec *spec = cdc->spec; 7010 int ret; 7011 7012 switch (action) { 7013 case HDA_FIXUP_ACT_PRE_PROBE: 7014 ret = hda_component_manager_init(cdc, &spec->comps, count, bus, hid, 7015 match_str, &comp_master_ops); 7016 if (ret) 7017 return; 7018 7019 spec->gen.pcm_playback_hook = comp_generic_playback_hook; 7020 break; 7021 case HDA_FIXUP_ACT_FREE: 7022 hda_component_manager_free(&spec->comps, &comp_master_ops); 7023 break; 7024 } 7025 } 7026 7027 static void find_cirrus_companion_amps(struct hda_codec *cdc) 7028 { 7029 struct device *dev = hda_codec_dev(cdc); 7030 struct acpi_device *adev; 7031 struct fwnode_handle *fwnode __free(fwnode_handle) = NULL; 7032 const char *bus = NULL; 7033 static const struct { 7034 const char *hid; 7035 const char *name; 7036 } acpi_ids[] = {{ "CSC3554", "cs35l54-hda" }, 7037 { "CSC3556", "cs35l56-hda" }, 7038 { "CSC3557", "cs35l57-hda" }}; 7039 char *match; 7040 int i, count = 0, count_devindex = 0; 7041 7042 for (i = 0; i < ARRAY_SIZE(acpi_ids); ++i) { 7043 adev = acpi_dev_get_first_match_dev(acpi_ids[i].hid, NULL, -1); 7044 if (adev) 7045 break; 7046 } 7047 if (!adev) { 7048 codec_dbg(cdc, "Did not find ACPI entry for a Cirrus Amp\n"); 7049 return; 7050 } 7051 7052 count = i2c_acpi_client_count(adev); 7053 if (count > 0) { 7054 bus = "i2c"; 7055 } else { 7056 count = acpi_spi_count_resources(adev); 7057 if (count > 0) 7058 bus = "spi"; 7059 } 7060 7061 fwnode = fwnode_handle_get(acpi_fwnode_handle(adev)); 7062 acpi_dev_put(adev); 7063 7064 if (!bus) { 7065 codec_err(cdc, "Did not find any buses for %s\n", acpi_ids[i].hid); 7066 return; 7067 } 7068 7069 if (!fwnode) { 7070 codec_err(cdc, "Could not get fwnode for %s\n", acpi_ids[i].hid); 7071 return; 7072 } 7073 7074 /* 7075 * When available the cirrus,dev-index property is an accurate 7076 * count of the amps in a system and is used in preference to 7077 * the count of bus devices that can contain additional address 7078 * alias entries. 7079 */ 7080 count_devindex = fwnode_property_count_u32(fwnode, "cirrus,dev-index"); 7081 if (count_devindex > 0) 7082 count = count_devindex; 7083 7084 match = devm_kasprintf(dev, GFP_KERNEL, "-%%s:00-%s.%%d", acpi_ids[i].name); 7085 if (!match) 7086 return; 7087 codec_info(cdc, "Found %d %s on %s (%s)\n", count, acpi_ids[i].hid, bus, match); 7088 comp_generic_fixup(cdc, HDA_FIXUP_ACT_PRE_PROBE, bus, acpi_ids[i].hid, match, count); 7089 } 7090 7091 static void cs35l41_fixup_i2c_two(struct hda_codec *cdc, const struct hda_fixup *fix, int action) 7092 { 7093 comp_generic_fixup(cdc, action, "i2c", "CSC3551", "-%s:00-cs35l41-hda.%d", 2); 7094 } 7095 7096 static void cs35l41_fixup_i2c_four(struct hda_codec *cdc, const struct hda_fixup *fix, int action) 7097 { 7098 comp_generic_fixup(cdc, action, "i2c", "CSC3551", "-%s:00-cs35l41-hda.%d", 4); 7099 } 7100 7101 static void cs35l41_fixup_spi_two(struct hda_codec *codec, const struct hda_fixup *fix, int action) 7102 { 7103 comp_generic_fixup(codec, action, "spi", "CSC3551", "-%s:00-cs35l41-hda.%d", 2); 7104 } 7105 7106 static void cs35l41_fixup_spi_four(struct hda_codec *codec, const struct hda_fixup *fix, int action) 7107 { 7108 comp_generic_fixup(codec, action, "spi", "CSC3551", "-%s:00-cs35l41-hda.%d", 4); 7109 } 7110 7111 static void alc287_fixup_legion_16achg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix, 7112 int action) 7113 { 7114 comp_generic_fixup(cdc, action, "i2c", "CLSA0100", "-%s:00-cs35l41-hda.%d", 2); 7115 } 7116 7117 static void alc287_fixup_legion_16ithg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix, 7118 int action) 7119 { 7120 comp_generic_fixup(cdc, action, "i2c", "CLSA0101", "-%s:00-cs35l41-hda.%d", 2); 7121 } 7122 7123 static void alc285_fixup_asus_ga403u(struct hda_codec *cdc, const struct hda_fixup *fix, int action) 7124 { 7125 /* 7126 * The same SSID has been re-used in different hardware, they have 7127 * different codecs and the newer GA403U has a ALC285. 7128 */ 7129 if (cdc->core.vendor_id != 0x10ec0285) 7130 alc_fixup_inv_dmic(cdc, fix, action); 7131 } 7132 7133 static void tas2781_fixup_i2c(struct hda_codec *cdc, 7134 const struct hda_fixup *fix, int action) 7135 { 7136 comp_generic_fixup(cdc, action, "i2c", "TIAS2781", "-%s:00", 1); 7137 } 7138 7139 static void tas2781_fixup_spi(struct hda_codec *cdc, const struct hda_fixup *fix, int action) 7140 { 7141 comp_generic_fixup(cdc, action, "spi", "TXNW2781", "-%s:00-tas2781-hda.%d", 2); 7142 } 7143 7144 static void yoga7_14arb7_fixup_i2c(struct hda_codec *cdc, 7145 const struct hda_fixup *fix, int action) 7146 { 7147 comp_generic_fixup(cdc, action, "i2c", "INT8866", "-%s:00", 1); 7148 } 7149 7150 static void alc256_fixup_acer_sfg16_micmute_led(struct hda_codec *codec, 7151 const struct hda_fixup *fix, int action) 7152 { 7153 alc_fixup_hp_gpio_led(codec, action, 0, 0x04); 7154 } 7155 7156 7157 /* for alc295_fixup_hp_top_speakers */ 7158 #include "hp_x360_helper.c" 7159 7160 /* for alc285_fixup_ideapad_s740_coef() */ 7161 #include "ideapad_s740_helper.c" 7162 7163 static const struct coef_fw alc256_fixup_set_coef_defaults_coefs[] = { 7164 WRITE_COEF(0x10, 0x0020), WRITE_COEF(0x24, 0x0000), 7165 WRITE_COEF(0x26, 0x0000), WRITE_COEF(0x29, 0x3000), 7166 WRITE_COEF(0x37, 0xfe05), WRITE_COEF(0x45, 0x5089), 7167 {} 7168 }; 7169 7170 static void alc256_fixup_set_coef_defaults(struct hda_codec *codec, 7171 const struct hda_fixup *fix, 7172 int action) 7173 { 7174 /* 7175 * A certain other OS sets these coeffs to different values. On at least 7176 * one TongFang barebone these settings might survive even a cold 7177 * reboot. So to restore a clean slate the values are explicitly reset 7178 * to default here. Without this, the external microphone is always in a 7179 * plugged-in state, while the internal microphone is always in an 7180 * unplugged state, breaking the ability to use the internal microphone. 7181 */ 7182 alc_process_coef_fw(codec, alc256_fixup_set_coef_defaults_coefs); 7183 } 7184 7185 static const struct coef_fw alc233_fixup_no_audio_jack_coefs[] = { 7186 WRITE_COEF(0x1a, 0x9003), WRITE_COEF(0x1b, 0x0e2b), WRITE_COEF(0x37, 0xfe06), 7187 WRITE_COEF(0x38, 0x4981), WRITE_COEF(0x45, 0xd489), WRITE_COEF(0x46, 0x0074), 7188 WRITE_COEF(0x49, 0x0149), 7189 {} 7190 }; 7191 7192 static void alc233_fixup_no_audio_jack(struct hda_codec *codec, 7193 const struct hda_fixup *fix, 7194 int action) 7195 { 7196 /* 7197 * The audio jack input and output is not detected on the ASRock NUC Box 7198 * 1100 series when cold booting without this fix. Warm rebooting from a 7199 * certain other OS makes the audio functional, as COEF settings are 7200 * preserved in this case. This fix sets these altered COEF values as 7201 * the default. 7202 */ 7203 alc_process_coef_fw(codec, alc233_fixup_no_audio_jack_coefs); 7204 } 7205 7206 static void alc256_fixup_mic_no_presence_and_resume(struct hda_codec *codec, 7207 const struct hda_fixup *fix, 7208 int action) 7209 { 7210 /* 7211 * The Clevo NJ51CU comes either with the ALC293 or the ALC256 codec, 7212 * but uses the 0x8686 subproduct id in both cases. The ALC256 codec 7213 * needs an additional quirk for sound working after suspend and resume. 7214 */ 7215 if (codec->core.vendor_id == 0x10ec0256) { 7216 alc_update_coef_idx(codec, 0x10, 1<<9, 0); 7217 snd_hda_codec_set_pincfg(codec, 0x19, 0x04a11120); 7218 } else { 7219 snd_hda_codec_set_pincfg(codec, 0x1a, 0x04a1113c); 7220 } 7221 } 7222 7223 static void alc256_decrease_headphone_amp_val(struct hda_codec *codec, 7224 const struct hda_fixup *fix, int action) 7225 { 7226 u32 caps; 7227 u8 nsteps, offs; 7228 7229 if (action != HDA_FIXUP_ACT_PRE_PROBE) 7230 return; 7231 7232 caps = query_amp_caps(codec, 0x3, HDA_OUTPUT); 7233 nsteps = ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) - 10; 7234 offs = ((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT) - 10; 7235 caps &= ~AC_AMPCAP_NUM_STEPS & ~AC_AMPCAP_OFFSET; 7236 caps |= (nsteps << AC_AMPCAP_NUM_STEPS_SHIFT) | (offs << AC_AMPCAP_OFFSET_SHIFT); 7237 7238 if (snd_hda_override_amp_caps(codec, 0x3, HDA_OUTPUT, caps)) 7239 codec_warn(codec, "failed to override amp caps for NID 0x3\n"); 7240 } 7241 7242 static void alc_fixup_dell4_mic_no_presence_quiet(struct hda_codec *codec, 7243 const struct hda_fixup *fix, 7244 int action) 7245 { 7246 struct alc_spec *spec = codec->spec; 7247 struct hda_input_mux *imux = &spec->gen.input_mux; 7248 int i; 7249 7250 alc269_fixup_limit_int_mic_boost(codec, fix, action); 7251 7252 switch (action) { 7253 case HDA_FIXUP_ACT_PRE_PROBE: 7254 /** 7255 * Set the vref of pin 0x19 (Headset Mic) and pin 0x1b (Headphone Mic) 7256 * to Hi-Z to avoid pop noises at startup and when plugging and 7257 * unplugging headphones. 7258 */ 7259 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ); 7260 snd_hda_codec_set_pin_target(codec, 0x1b, PIN_VREFHIZ); 7261 break; 7262 case HDA_FIXUP_ACT_PROBE: 7263 /** 7264 * Make the internal mic (0x12) the default input source to 7265 * prevent pop noises on cold boot. 7266 */ 7267 for (i = 0; i < imux->num_items; i++) { 7268 if (spec->gen.imux_pins[i] == 0x12) { 7269 spec->gen.cur_mux[0] = i; 7270 break; 7271 } 7272 } 7273 break; 7274 } 7275 } 7276 7277 static void alc287_fixup_yoga9_14iap7_bass_spk_pin(struct hda_codec *codec, 7278 const struct hda_fixup *fix, int action) 7279 { 7280 /* 7281 * The Pin Complex 0x17 for the bass speakers is wrongly reported as 7282 * unconnected. 7283 */ 7284 static const struct hda_pintbl pincfgs[] = { 7285 { 0x17, 0x90170121 }, 7286 { } 7287 }; 7288 /* 7289 * Avoid DAC 0x06 and 0x08, as they have no volume controls. 7290 * DAC 0x02 and 0x03 would be fine. 7291 */ 7292 static const hda_nid_t conn[] = { 0x02, 0x03 }; 7293 /* 7294 * Prefer both speakerbar (0x14) and bass speakers (0x17) connected to DAC 0x02. 7295 * Headphones (0x21) are connected to DAC 0x03. 7296 */ 7297 static const hda_nid_t preferred_pairs[] = { 7298 0x14, 0x02, 7299 0x17, 0x02, 7300 0x21, 0x03, 7301 0 7302 }; 7303 struct alc_spec *spec = codec->spec; 7304 7305 switch (action) { 7306 case HDA_FIXUP_ACT_PRE_PROBE: 7307 snd_hda_apply_pincfgs(codec, pincfgs); 7308 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 7309 spec->gen.preferred_dacs = preferred_pairs; 7310 break; 7311 } 7312 } 7313 7314 static void alc295_fixup_dell_inspiron_top_speakers(struct hda_codec *codec, 7315 const struct hda_fixup *fix, int action) 7316 { 7317 static const struct hda_pintbl pincfgs[] = { 7318 { 0x14, 0x90170151 }, 7319 { 0x17, 0x90170150 }, 7320 { } 7321 }; 7322 static const hda_nid_t conn[] = { 0x02, 0x03 }; 7323 static const hda_nid_t preferred_pairs[] = { 7324 0x14, 0x02, 7325 0x17, 0x03, 7326 0x21, 0x02, 7327 0 7328 }; 7329 struct alc_spec *spec = codec->spec; 7330 7331 alc_fixup_no_shutup(codec, fix, action); 7332 7333 switch (action) { 7334 case HDA_FIXUP_ACT_PRE_PROBE: 7335 snd_hda_apply_pincfgs(codec, pincfgs); 7336 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 7337 spec->gen.preferred_dacs = preferred_pairs; 7338 break; 7339 } 7340 } 7341 7342 /* Forcibly assign NID 0x03 to HP while NID 0x02 to SPK */ 7343 static void alc287_fixup_bind_dacs(struct hda_codec *codec, 7344 const struct hda_fixup *fix, int action) 7345 { 7346 struct alc_spec *spec = codec->spec; 7347 static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */ 7348 static const hda_nid_t preferred_pairs[] = { 7349 0x17, 0x02, 0x21, 0x03, 0 7350 }; 7351 7352 if (action != HDA_FIXUP_ACT_PRE_PROBE) 7353 return; 7354 7355 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 7356 spec->gen.preferred_dacs = preferred_pairs; 7357 spec->gen.auto_mute_via_amp = 1; 7358 if (spec->gen.autocfg.speaker_pins[0] != 0x14) { 7359 snd_hda_codec_write_cache(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 7360 0x0); /* Make sure 0x14 was disable */ 7361 } 7362 } 7363 /* Fix none verb table of Headset Mic pin */ 7364 static void alc_fixup_headset_mic(struct hda_codec *codec, 7365 const struct hda_fixup *fix, int action) 7366 { 7367 struct alc_spec *spec = codec->spec; 7368 static const struct hda_pintbl pincfgs[] = { 7369 { 0x19, 0x03a1103c }, 7370 { } 7371 }; 7372 7373 switch (action) { 7374 case HDA_FIXUP_ACT_PRE_PROBE: 7375 snd_hda_apply_pincfgs(codec, pincfgs); 7376 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12); 7377 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 7378 break; 7379 } 7380 } 7381 7382 static void alc245_fixup_hp_spectre_x360_eu0xxx(struct hda_codec *codec, 7383 const struct hda_fixup *fix, int action) 7384 { 7385 /* 7386 * The Pin Complex 0x14 for the treble speakers is wrongly reported as 7387 * unconnected. 7388 * The Pin Complex 0x17 for the bass speakers has the lowest association 7389 * and sequence values so shift it up a bit to squeeze 0x14 in. 7390 */ 7391 static const struct hda_pintbl pincfgs[] = { 7392 { 0x14, 0x90170110 }, // top/treble 7393 { 0x17, 0x90170111 }, // bottom/bass 7394 { } 7395 }; 7396 7397 /* 7398 * Force DAC 0x02 for the bass speakers 0x17. 7399 */ 7400 static const hda_nid_t conn[] = { 0x02 }; 7401 7402 switch (action) { 7403 case HDA_FIXUP_ACT_PRE_PROBE: 7404 snd_hda_apply_pincfgs(codec, pincfgs); 7405 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 7406 break; 7407 } 7408 7409 cs35l41_fixup_i2c_two(codec, fix, action); 7410 alc245_fixup_hp_mute_led_coefbit(codec, fix, action); 7411 alc245_fixup_hp_gpio_led(codec, fix, action); 7412 } 7413 7414 /* some changes for Spectre x360 16, 2024 model */ 7415 static void alc245_fixup_hp_spectre_x360_16_aa0xxx(struct hda_codec *codec, 7416 const struct hda_fixup *fix, int action) 7417 { 7418 /* 7419 * The Pin Complex 0x14 for the treble speakers is wrongly reported as 7420 * unconnected. 7421 * The Pin Complex 0x17 for the bass speakers has the lowest association 7422 * and sequence values so shift it up a bit to squeeze 0x14 in. 7423 */ 7424 struct alc_spec *spec = codec->spec; 7425 static const struct hda_pintbl pincfgs[] = { 7426 { 0x14, 0x90170110 }, // top/treble 7427 { 0x17, 0x90170111 }, // bottom/bass 7428 { } 7429 }; 7430 7431 /* 7432 * Force DAC 0x02 for the bass speakers 0x17. 7433 */ 7434 static const hda_nid_t conn[] = { 0x02 }; 7435 7436 switch (action) { 7437 case HDA_FIXUP_ACT_PRE_PROBE: 7438 /* needed for amp of back speakers */ 7439 spec->gpio_mask |= 0x01; 7440 spec->gpio_dir |= 0x01; 7441 snd_hda_apply_pincfgs(codec, pincfgs); 7442 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 7443 break; 7444 case HDA_FIXUP_ACT_INIT: 7445 /* need to toggle GPIO to enable the amp of back speakers */ 7446 alc_update_gpio_data(codec, 0x01, true); 7447 msleep(100); 7448 alc_update_gpio_data(codec, 0x01, false); 7449 break; 7450 } 7451 7452 cs35l41_fixup_i2c_two(codec, fix, action); 7453 alc245_fixup_hp_mute_led_coefbit(codec, fix, action); 7454 alc245_fixup_hp_gpio_led(codec, fix, action); 7455 } 7456 7457 /* 7458 * ALC287 PCM hooks 7459 */ 7460 static void alc287_alc1318_playback_pcm_hook(struct hda_pcm_stream *hinfo, 7461 struct hda_codec *codec, 7462 struct snd_pcm_substream *substream, 7463 int action) 7464 { 7465 switch (action) { 7466 case HDA_GEN_PCM_ACT_OPEN: 7467 alc_write_coefex_idx(codec, 0x5a, 0x00, 0x954f); /* write gpio3 to high */ 7468 break; 7469 case HDA_GEN_PCM_ACT_CLOSE: 7470 alc_write_coefex_idx(codec, 0x5a, 0x00, 0x554f); /* write gpio3 as default value */ 7471 break; 7472 } 7473 } 7474 7475 static void alc287_s4_power_gpio3_default(struct hda_codec *codec) 7476 { 7477 if (is_s4_suspend(codec)) { 7478 alc_write_coefex_idx(codec, 0x5a, 0x00, 0x554f); /* write gpio3 as default value */ 7479 } 7480 } 7481 7482 static void alc287_fixup_lenovo_thinkpad_with_alc1318(struct hda_codec *codec, 7483 const struct hda_fixup *fix, int action) 7484 { 7485 struct alc_spec *spec = codec->spec; 7486 static const struct coef_fw coefs[] = { 7487 WRITE_COEF(0x24, 0x0013), WRITE_COEF(0x25, 0x0000), WRITE_COEF(0x26, 0xC300), 7488 WRITE_COEF(0x28, 0x0001), WRITE_COEF(0x29, 0xb023), 7489 WRITE_COEF(0x24, 0x0013), WRITE_COEF(0x25, 0x0000), WRITE_COEF(0x26, 0xC301), 7490 WRITE_COEF(0x28, 0x0001), WRITE_COEF(0x29, 0xb023), 7491 }; 7492 7493 if (action != HDA_FIXUP_ACT_PRE_PROBE) 7494 return; 7495 alc_update_coef_idx(codec, 0x10, 1<<11, 1<<11); 7496 alc_process_coef_fw(codec, coefs); 7497 spec->power_hook = alc287_s4_power_gpio3_default; 7498 spec->gen.pcm_playback_hook = alc287_alc1318_playback_pcm_hook; 7499 } 7500 7501 /* 7502 * Clear COEF 0x0d (PCBEEP passthrough) bit 0x40 where BIOS sets it wrongly 7503 * at PM resume 7504 */ 7505 static void alc283_fixup_dell_hp_resume(struct hda_codec *codec, 7506 const struct hda_fixup *fix, int action) 7507 { 7508 if (action == HDA_FIXUP_ACT_INIT) 7509 alc_write_coef_idx(codec, 0xd, 0x2800); 7510 } 7511 7512 enum { 7513 ALC269_FIXUP_GPIO2, 7514 ALC269_FIXUP_SONY_VAIO, 7515 ALC275_FIXUP_SONY_VAIO_GPIO2, 7516 ALC269_FIXUP_DELL_M101Z, 7517 ALC269_FIXUP_SKU_IGNORE, 7518 ALC269_FIXUP_ASUS_G73JW, 7519 ALC269_FIXUP_ASUS_N7601ZM_PINS, 7520 ALC269_FIXUP_ASUS_N7601ZM, 7521 ALC269_FIXUP_LENOVO_EAPD, 7522 ALC275_FIXUP_SONY_HWEQ, 7523 ALC275_FIXUP_SONY_DISABLE_AAMIX, 7524 ALC271_FIXUP_DMIC, 7525 ALC269_FIXUP_PCM_44K, 7526 ALC269_FIXUP_STEREO_DMIC, 7527 ALC269_FIXUP_HEADSET_MIC, 7528 ALC269_FIXUP_QUANTA_MUTE, 7529 ALC269_FIXUP_LIFEBOOK, 7530 ALC269_FIXUP_LIFEBOOK_EXTMIC, 7531 ALC269_FIXUP_LIFEBOOK_HP_PIN, 7532 ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT, 7533 ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, 7534 ALC269_FIXUP_AMIC, 7535 ALC269_FIXUP_DMIC, 7536 ALC269VB_FIXUP_AMIC, 7537 ALC269VB_FIXUP_DMIC, 7538 ALC269_FIXUP_HP_MUTE_LED, 7539 ALC269_FIXUP_HP_MUTE_LED_MIC1, 7540 ALC269_FIXUP_HP_MUTE_LED_MIC2, 7541 ALC269_FIXUP_HP_MUTE_LED_MIC3, 7542 ALC269_FIXUP_HP_GPIO_LED, 7543 ALC269_FIXUP_HP_GPIO_MIC1_LED, 7544 ALC269_FIXUP_HP_LINE1_MIC1_LED, 7545 ALC269_FIXUP_INV_DMIC, 7546 ALC269_FIXUP_LENOVO_DOCK, 7547 ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, 7548 ALC269_FIXUP_NO_SHUTUP, 7549 ALC286_FIXUP_SONY_MIC_NO_PRESENCE, 7550 ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT, 7551 ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 7552 ALC269_FIXUP_DELL1_LIMIT_INT_MIC_BOOST, 7553 ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, 7554 ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, 7555 ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 7556 ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET, 7557 ALC269_FIXUP_HEADSET_MODE, 7558 ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, 7559 ALC269_FIXUP_ASPIRE_HEADSET_MIC, 7560 ALC269_FIXUP_ASUS_X101_FUNC, 7561 ALC269_FIXUP_ASUS_X101_VERB, 7562 ALC269_FIXUP_ASUS_X101, 7563 ALC271_FIXUP_AMIC_MIC2, 7564 ALC271_FIXUP_HP_GATE_MIC_JACK, 7565 ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, 7566 ALC269_FIXUP_ACER_AC700, 7567 ALC269_FIXUP_LIMIT_INT_MIC_BOOST, 7568 ALC269VB_FIXUP_ASUS_ZENBOOK, 7569 ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, 7570 ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE, 7571 ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED, 7572 ALC269VB_FIXUP_ORDISSIMO_EVE2, 7573 ALC283_FIXUP_CHROME_BOOK, 7574 ALC283_FIXUP_SENSE_COMBO_JACK, 7575 ALC282_FIXUP_ASUS_TX300, 7576 ALC283_FIXUP_INT_MIC, 7577 ALC290_FIXUP_MONO_SPEAKERS, 7578 ALC290_FIXUP_MONO_SPEAKERS_HSJACK, 7579 ALC290_FIXUP_SUBWOOFER, 7580 ALC290_FIXUP_SUBWOOFER_HSJACK, 7581 ALC269_FIXUP_THINKPAD_ACPI, 7582 ALC269_FIXUP_LENOVO_XPAD_ACPI, 7583 ALC269_FIXUP_DMIC_THINKPAD_ACPI, 7584 ALC269VB_FIXUP_INFINIX_ZERO_BOOK_13, 7585 ALC269VC_FIXUP_INFINIX_Y4_MAX, 7586 ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO, 7587 ALC255_FIXUP_ACER_MIC_NO_PRESENCE, 7588 ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, 7589 ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 7590 ALC255_FIXUP_DELL1_LIMIT_INT_MIC_BOOST, 7591 ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, 7592 ALC255_FIXUP_HEADSET_MODE, 7593 ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC, 7594 ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, 7595 ALC292_FIXUP_TPT440_DOCK, 7596 ALC292_FIXUP_TPT440, 7597 ALC283_FIXUP_HEADSET_MIC, 7598 ALC255_FIXUP_MIC_MUTE_LED, 7599 ALC282_FIXUP_ASPIRE_V5_PINS, 7600 ALC269VB_FIXUP_ASPIRE_E1_COEF, 7601 ALC280_FIXUP_HP_GPIO4, 7602 ALC286_FIXUP_HP_GPIO_LED, 7603 ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, 7604 ALC280_FIXUP_HP_DOCK_PINS, 7605 ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, 7606 ALC280_FIXUP_HP_9480M, 7607 ALC245_FIXUP_HP_X360_AMP, 7608 ALC285_FIXUP_HP_SPECTRE_X360_EB1, 7609 ALC285_FIXUP_HP_ENVY_X360, 7610 ALC288_FIXUP_DELL_HEADSET_MODE, 7611 ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, 7612 ALC288_FIXUP_DELL_XPS_13, 7613 ALC288_FIXUP_DISABLE_AAMIX, 7614 ALC292_FIXUP_DELL_E7X_AAMIX, 7615 ALC292_FIXUP_DELL_E7X, 7616 ALC292_FIXUP_DISABLE_AAMIX, 7617 ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, 7618 ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE, 7619 ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 7620 ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, 7621 ALC275_FIXUP_DELL_XPS, 7622 ALC293_FIXUP_LENOVO_SPK_NOISE, 7623 ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, 7624 ALC255_FIXUP_DELL_SPK_NOISE, 7625 ALC225_FIXUP_DISABLE_MIC_VREF, 7626 ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 7627 ALC295_FIXUP_DISABLE_DAC3, 7628 ALC285_FIXUP_SPEAKER2_TO_DAC1, 7629 ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1, 7630 ALC285_FIXUP_ASUS_HEADSET_MIC, 7631 ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS, 7632 ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1, 7633 ALC285_FIXUP_ASUS_I2C_HEADSET_MIC, 7634 ALC280_FIXUP_HP_HEADSET_MIC, 7635 ALC221_FIXUP_HP_FRONT_MIC, 7636 ALC292_FIXUP_TPT460, 7637 ALC298_FIXUP_SPK_VOLUME, 7638 ALC298_FIXUP_LENOVO_SPK_VOLUME, 7639 ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, 7640 ALC269_FIXUP_ATIV_BOOK_8, 7641 ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE, 7642 ALC221_FIXUP_HP_MIC_NO_PRESENCE, 7643 ALC256_FIXUP_ASUS_HEADSET_MODE, 7644 ALC256_FIXUP_ASUS_MIC, 7645 ALC256_FIXUP_ASUS_AIO_GPIO2, 7646 ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, 7647 ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, 7648 ALC233_FIXUP_LENOVO_MULTI_CODECS, 7649 ALC233_FIXUP_ACER_HEADSET_MIC, 7650 ALC294_FIXUP_LENOVO_MIC_LOCATION, 7651 ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, 7652 ALC225_FIXUP_S3_POP_NOISE, 7653 ALC700_FIXUP_INTEL_REFERENCE, 7654 ALC274_FIXUP_DELL_BIND_DACS, 7655 ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, 7656 ALC298_FIXUP_TPT470_DOCK_FIX, 7657 ALC298_FIXUP_TPT470_DOCK, 7658 ALC255_FIXUP_DUMMY_LINEOUT_VERB, 7659 ALC255_FIXUP_DELL_HEADSET_MIC, 7660 ALC256_FIXUP_HUAWEI_MACH_WX9_PINS, 7661 ALC298_FIXUP_HUAWEI_MBX_STEREO, 7662 ALC295_FIXUP_HP_X360, 7663 ALC221_FIXUP_HP_HEADSET_MIC, 7664 ALC285_FIXUP_LENOVO_HEADPHONE_NOISE, 7665 ALC295_FIXUP_HP_AUTO_MUTE, 7666 ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE, 7667 ALC294_FIXUP_ASUS_MIC, 7668 ALC294_FIXUP_ASUS_HEADSET_MIC, 7669 ALC294_FIXUP_ASUS_SPK, 7670 ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE, 7671 ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE, 7672 ALC255_FIXUP_ACER_HEADSET_MIC, 7673 ALC295_FIXUP_CHROME_BOOK, 7674 ALC225_FIXUP_HEADSET_JACK, 7675 ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE, 7676 ALC225_FIXUP_WYSE_AUTO_MUTE, 7677 ALC225_FIXUP_WYSE_DISABLE_MIC_VREF, 7678 ALC286_FIXUP_ACER_AIO_HEADSET_MIC, 7679 ALC256_FIXUP_ASUS_HEADSET_MIC, 7680 ALC256_FIXUP_ASUS_MIC_NO_PRESENCE, 7681 ALC255_FIXUP_PREDATOR_SUBWOOFER, 7682 ALC299_FIXUP_PREDATOR_SPK, 7683 ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, 7684 ALC289_FIXUP_DELL_SPK1, 7685 ALC289_FIXUP_DELL_SPK2, 7686 ALC289_FIXUP_DUAL_SPK, 7687 ALC289_FIXUP_RTK_AMP_DUAL_SPK, 7688 ALC294_FIXUP_SPK2_TO_DAC1, 7689 ALC294_FIXUP_ASUS_DUAL_SPK, 7690 ALC285_FIXUP_THINKPAD_X1_GEN7, 7691 ALC285_FIXUP_THINKPAD_HEADSET_JACK, 7692 ALC294_FIXUP_ASUS_ALLY, 7693 ALC294_FIXUP_ASUS_ALLY_X, 7694 ALC294_FIXUP_ASUS_ALLY_PINS, 7695 ALC294_FIXUP_ASUS_ALLY_VERBS, 7696 ALC294_FIXUP_ASUS_ALLY_SPEAKER, 7697 ALC294_FIXUP_ASUS_HPE, 7698 ALC294_FIXUP_ASUS_COEF_1B, 7699 ALC294_FIXUP_ASUS_GX502_HP, 7700 ALC294_FIXUP_ASUS_GX502_PINS, 7701 ALC294_FIXUP_ASUS_GX502_VERBS, 7702 ALC294_FIXUP_ASUS_GU502_HP, 7703 ALC294_FIXUP_ASUS_GU502_PINS, 7704 ALC294_FIXUP_ASUS_GU502_VERBS, 7705 ALC294_FIXUP_ASUS_G513_PINS, 7706 ALC285_FIXUP_ASUS_G533Z_PINS, 7707 ALC285_FIXUP_HP_GPIO_LED, 7708 ALC285_FIXUP_HP_MUTE_LED, 7709 ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED, 7710 ALC236_FIXUP_HP_MUTE_LED_COEFBIT2, 7711 ALC236_FIXUP_HP_GPIO_LED, 7712 ALC236_FIXUP_HP_MUTE_LED, 7713 ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF, 7714 ALC236_FIXUP_LENOVO_INV_DMIC, 7715 ALC298_FIXUP_SAMSUNG_AMP, 7716 ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS, 7717 ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS, 7718 ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, 7719 ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, 7720 ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, 7721 ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS, 7722 ALC269VC_FIXUP_ACER_HEADSET_MIC, 7723 ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE, 7724 ALC289_FIXUP_ASUS_GA401, 7725 ALC289_FIXUP_ASUS_GA502, 7726 ALC256_FIXUP_ACER_MIC_NO_PRESENCE, 7727 ALC285_FIXUP_HP_GPIO_AMP_INIT, 7728 ALC269_FIXUP_CZC_B20, 7729 ALC269_FIXUP_CZC_TMI, 7730 ALC269_FIXUP_CZC_L101, 7731 ALC269_FIXUP_LEMOTE_A1802, 7732 ALC269_FIXUP_LEMOTE_A190X, 7733 ALC256_FIXUP_INTEL_NUC8_RUGGED, 7734 ALC233_FIXUP_INTEL_NUC8_DMIC, 7735 ALC233_FIXUP_INTEL_NUC8_BOOST, 7736 ALC256_FIXUP_INTEL_NUC10, 7737 ALC255_FIXUP_XIAOMI_HEADSET_MIC, 7738 ALC274_FIXUP_HP_MIC, 7739 ALC274_FIXUP_HP_HEADSET_MIC, 7740 ALC274_FIXUP_HP_ENVY_GPIO, 7741 ALC274_FIXUP_ASUS_ZEN_AIO_27, 7742 ALC256_FIXUP_ASUS_HPE, 7743 ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK, 7744 ALC287_FIXUP_HP_GPIO_LED, 7745 ALC256_FIXUP_HP_HEADSET_MIC, 7746 ALC245_FIXUP_HP_GPIO_LED, 7747 ALC236_FIXUP_DELL_AIO_HEADSET_MIC, 7748 ALC282_FIXUP_ACER_DISABLE_LINEOUT, 7749 ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST, 7750 ALC256_FIXUP_ACER_HEADSET_MIC, 7751 ALC285_FIXUP_IDEAPAD_S740_COEF, 7752 ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST, 7753 ALC295_FIXUP_ASUS_DACS, 7754 ALC295_FIXUP_HP_OMEN, 7755 ALC285_FIXUP_HP_SPECTRE_X360, 7756 ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, 7757 ALC623_FIXUP_LENOVO_THINKSTATION_P340, 7758 ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, 7759 ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST, 7760 ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS, 7761 ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE, 7762 ALC287_FIXUP_YOGA7_14ITL_SPEAKERS, 7763 ALC298_FIXUP_LENOVO_C940_DUET7, 7764 ALC287_FIXUP_13S_GEN2_SPEAKERS, 7765 ALC256_FIXUP_SET_COEF_DEFAULTS, 7766 ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE, 7767 ALC233_FIXUP_NO_AUDIO_JACK, 7768 ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME, 7769 ALC285_FIXUP_LEGION_Y9000X_SPEAKERS, 7770 ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE, 7771 ALC287_FIXUP_LEGION_16ACHG6, 7772 ALC287_FIXUP_CS35L41_I2C_2, 7773 ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED, 7774 ALC287_FIXUP_CS35L41_I2C_4, 7775 ALC245_FIXUP_CS35L41_SPI_2, 7776 ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED, 7777 ALC245_FIXUP_CS35L41_SPI_4, 7778 ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED, 7779 ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED, 7780 ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE, 7781 ALC287_FIXUP_LEGION_16ITHG6, 7782 ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK, 7783 ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN, 7784 ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN, 7785 ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS, 7786 ALC236_FIXUP_DELL_DUAL_CODECS, 7787 ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI, 7788 ALC287_FIXUP_TAS2781_I2C, 7789 ALC245_FIXUP_TAS2781_SPI_2, 7790 ALC287_FIXUP_YOGA7_14ARB7_I2C, 7791 ALC245_FIXUP_HP_MUTE_LED_COEFBIT, 7792 ALC245_FIXUP_HP_X360_MUTE_LEDS, 7793 ALC287_FIXUP_THINKPAD_I2S_SPK, 7794 ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD, 7795 ALC2XX_FIXUP_HEADSET_MIC, 7796 ALC289_FIXUP_DELL_CS35L41_SPI_2, 7797 ALC294_FIXUP_CS35L41_I2C_2, 7798 ALC256_FIXUP_ACER_SFG16_MICMUTE_LED, 7799 ALC256_FIXUP_HEADPHONE_AMP_VOL, 7800 ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX, 7801 ALC245_FIXUP_HP_SPECTRE_X360_16_AA0XXX, 7802 ALC285_FIXUP_ASUS_GA403U, 7803 ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC, 7804 ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1, 7805 ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC, 7806 ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1, 7807 ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318, 7808 ALC256_FIXUP_CHROME_BOOK, 7809 ALC245_FIXUP_CLEVO_NOISY_MIC, 7810 ALC269_FIXUP_VAIO_VJFH52_MIC_NO_PRESENCE, 7811 ALC233_FIXUP_MEDION_MTL_SPK, 7812 ALC294_FIXUP_BASS_SPEAKER_15, 7813 ALC283_FIXUP_DELL_HP_RESUME, 7814 }; 7815 7816 /* A special fixup for Lenovo C940 and Yoga Duet 7; 7817 * both have the very same PCI SSID, and we need to apply different fixups 7818 * depending on the codec ID 7819 */ 7820 static void alc298_fixup_lenovo_c940_duet7(struct hda_codec *codec, 7821 const struct hda_fixup *fix, 7822 int action) 7823 { 7824 int id; 7825 7826 if (codec->core.vendor_id == 0x10ec0298) 7827 id = ALC298_FIXUP_LENOVO_SPK_VOLUME; /* C940 */ 7828 else 7829 id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* Duet 7 */ 7830 __snd_hda_apply_fixup(codec, id, action, 0); 7831 } 7832 7833 static const struct hda_fixup alc269_fixups[] = { 7834 [ALC269_FIXUP_GPIO2] = { 7835 .type = HDA_FIXUP_FUNC, 7836 .v.func = alc_fixup_gpio2, 7837 }, 7838 [ALC269_FIXUP_SONY_VAIO] = { 7839 .type = HDA_FIXUP_PINCTLS, 7840 .v.pins = (const struct hda_pintbl[]) { 7841 {0x19, PIN_VREFGRD}, 7842 {} 7843 } 7844 }, 7845 [ALC275_FIXUP_SONY_VAIO_GPIO2] = { 7846 .type = HDA_FIXUP_FUNC, 7847 .v.func = alc275_fixup_gpio4_off, 7848 .chained = true, 7849 .chain_id = ALC269_FIXUP_SONY_VAIO 7850 }, 7851 [ALC269_FIXUP_DELL_M101Z] = { 7852 .type = HDA_FIXUP_VERBS, 7853 .v.verbs = (const struct hda_verb[]) { 7854 /* Enables internal speaker */ 7855 {0x20, AC_VERB_SET_COEF_INDEX, 13}, 7856 {0x20, AC_VERB_SET_PROC_COEF, 0x4040}, 7857 {} 7858 } 7859 }, 7860 [ALC269_FIXUP_SKU_IGNORE] = { 7861 .type = HDA_FIXUP_FUNC, 7862 .v.func = alc_fixup_sku_ignore, 7863 }, 7864 [ALC269_FIXUP_ASUS_G73JW] = { 7865 .type = HDA_FIXUP_PINS, 7866 .v.pins = (const struct hda_pintbl[]) { 7867 { 0x17, 0x99130111 }, /* subwoofer */ 7868 { } 7869 } 7870 }, 7871 [ALC269_FIXUP_ASUS_N7601ZM_PINS] = { 7872 .type = HDA_FIXUP_PINS, 7873 .v.pins = (const struct hda_pintbl[]) { 7874 { 0x19, 0x03A11050 }, 7875 { 0x1a, 0x03A11C30 }, 7876 { 0x21, 0x03211420 }, 7877 { } 7878 } 7879 }, 7880 [ALC269_FIXUP_ASUS_N7601ZM] = { 7881 .type = HDA_FIXUP_VERBS, 7882 .v.verbs = (const struct hda_verb[]) { 7883 {0x20, AC_VERB_SET_COEF_INDEX, 0x62}, 7884 {0x20, AC_VERB_SET_PROC_COEF, 0xa007}, 7885 {0x20, AC_VERB_SET_COEF_INDEX, 0x10}, 7886 {0x20, AC_VERB_SET_PROC_COEF, 0x8420}, 7887 {0x20, AC_VERB_SET_COEF_INDEX, 0x0f}, 7888 {0x20, AC_VERB_SET_PROC_COEF, 0x7774}, 7889 { } 7890 }, 7891 .chained = true, 7892 .chain_id = ALC269_FIXUP_ASUS_N7601ZM_PINS, 7893 }, 7894 [ALC269_FIXUP_LENOVO_EAPD] = { 7895 .type = HDA_FIXUP_VERBS, 7896 .v.verbs = (const struct hda_verb[]) { 7897 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0}, 7898 {} 7899 } 7900 }, 7901 [ALC275_FIXUP_SONY_HWEQ] = { 7902 .type = HDA_FIXUP_FUNC, 7903 .v.func = alc269_fixup_hweq, 7904 .chained = true, 7905 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2 7906 }, 7907 [ALC275_FIXUP_SONY_DISABLE_AAMIX] = { 7908 .type = HDA_FIXUP_FUNC, 7909 .v.func = alc_fixup_disable_aamix, 7910 .chained = true, 7911 .chain_id = ALC269_FIXUP_SONY_VAIO 7912 }, 7913 [ALC271_FIXUP_DMIC] = { 7914 .type = HDA_FIXUP_FUNC, 7915 .v.func = alc271_fixup_dmic, 7916 }, 7917 [ALC269_FIXUP_PCM_44K] = { 7918 .type = HDA_FIXUP_FUNC, 7919 .v.func = alc269_fixup_pcm_44k, 7920 .chained = true, 7921 .chain_id = ALC269_FIXUP_QUANTA_MUTE 7922 }, 7923 [ALC269_FIXUP_STEREO_DMIC] = { 7924 .type = HDA_FIXUP_FUNC, 7925 .v.func = alc269_fixup_stereo_dmic, 7926 }, 7927 [ALC269_FIXUP_HEADSET_MIC] = { 7928 .type = HDA_FIXUP_FUNC, 7929 .v.func = alc269_fixup_headset_mic, 7930 }, 7931 [ALC269_FIXUP_QUANTA_MUTE] = { 7932 .type = HDA_FIXUP_FUNC, 7933 .v.func = alc269_fixup_quanta_mute, 7934 }, 7935 [ALC269_FIXUP_LIFEBOOK] = { 7936 .type = HDA_FIXUP_PINS, 7937 .v.pins = (const struct hda_pintbl[]) { 7938 { 0x1a, 0x2101103f }, /* dock line-out */ 7939 { 0x1b, 0x23a11040 }, /* dock mic-in */ 7940 { } 7941 }, 7942 .chained = true, 7943 .chain_id = ALC269_FIXUP_QUANTA_MUTE 7944 }, 7945 [ALC269_FIXUP_LIFEBOOK_EXTMIC] = { 7946 .type = HDA_FIXUP_PINS, 7947 .v.pins = (const struct hda_pintbl[]) { 7948 { 0x19, 0x01a1903c }, /* headset mic, with jack detect */ 7949 { } 7950 }, 7951 }, 7952 [ALC269_FIXUP_LIFEBOOK_HP_PIN] = { 7953 .type = HDA_FIXUP_PINS, 7954 .v.pins = (const struct hda_pintbl[]) { 7955 { 0x21, 0x0221102f }, /* HP out */ 7956 { } 7957 }, 7958 }, 7959 [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = { 7960 .type = HDA_FIXUP_FUNC, 7961 .v.func = alc269_fixup_pincfg_no_hp_to_lineout, 7962 }, 7963 [ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = { 7964 .type = HDA_FIXUP_FUNC, 7965 .v.func = alc269_fixup_pincfg_U7x7_headset_mic, 7966 }, 7967 [ALC269VB_FIXUP_INFINIX_ZERO_BOOK_13] = { 7968 .type = HDA_FIXUP_PINS, 7969 .v.pins = (const struct hda_pintbl[]) { 7970 { 0x14, 0x90170151 }, /* use as internal speaker (LFE) */ 7971 { 0x1b, 0x90170152 }, /* use as internal speaker (back) */ 7972 { } 7973 }, 7974 .chained = true, 7975 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST 7976 }, 7977 [ALC269VC_FIXUP_INFINIX_Y4_MAX] = { 7978 .type = HDA_FIXUP_PINS, 7979 .v.pins = (const struct hda_pintbl[]) { 7980 { 0x1b, 0x90170150 }, /* use as internal speaker */ 7981 { } 7982 }, 7983 .chained = true, 7984 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST 7985 }, 7986 [ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO] = { 7987 .type = HDA_FIXUP_PINS, 7988 .v.pins = (const struct hda_pintbl[]) { 7989 { 0x18, 0x03a19020 }, /* headset mic */ 7990 { 0x1b, 0x90170150 }, /* speaker */ 7991 { } 7992 }, 7993 }, 7994 [ALC269_FIXUP_AMIC] = { 7995 .type = HDA_FIXUP_PINS, 7996 .v.pins = (const struct hda_pintbl[]) { 7997 { 0x14, 0x99130110 }, /* speaker */ 7998 { 0x15, 0x0121401f }, /* HP out */ 7999 { 0x18, 0x01a19c20 }, /* mic */ 8000 { 0x19, 0x99a3092f }, /* int-mic */ 8001 { } 8002 }, 8003 }, 8004 [ALC269_FIXUP_DMIC] = { 8005 .type = HDA_FIXUP_PINS, 8006 .v.pins = (const struct hda_pintbl[]) { 8007 { 0x12, 0x99a3092f }, /* int-mic */ 8008 { 0x14, 0x99130110 }, /* speaker */ 8009 { 0x15, 0x0121401f }, /* HP out */ 8010 { 0x18, 0x01a19c20 }, /* mic */ 8011 { } 8012 }, 8013 }, 8014 [ALC269VB_FIXUP_AMIC] = { 8015 .type = HDA_FIXUP_PINS, 8016 .v.pins = (const struct hda_pintbl[]) { 8017 { 0x14, 0x99130110 }, /* speaker */ 8018 { 0x18, 0x01a19c20 }, /* mic */ 8019 { 0x19, 0x99a3092f }, /* int-mic */ 8020 { 0x21, 0x0121401f }, /* HP out */ 8021 { } 8022 }, 8023 }, 8024 [ALC269VB_FIXUP_DMIC] = { 8025 .type = HDA_FIXUP_PINS, 8026 .v.pins = (const struct hda_pintbl[]) { 8027 { 0x12, 0x99a3092f }, /* int-mic */ 8028 { 0x14, 0x99130110 }, /* speaker */ 8029 { 0x18, 0x01a19c20 }, /* mic */ 8030 { 0x21, 0x0121401f }, /* HP out */ 8031 { } 8032 }, 8033 }, 8034 [ALC269_FIXUP_HP_MUTE_LED] = { 8035 .type = HDA_FIXUP_FUNC, 8036 .v.func = alc269_fixup_hp_mute_led, 8037 }, 8038 [ALC269_FIXUP_HP_MUTE_LED_MIC1] = { 8039 .type = HDA_FIXUP_FUNC, 8040 .v.func = alc269_fixup_hp_mute_led_mic1, 8041 }, 8042 [ALC269_FIXUP_HP_MUTE_LED_MIC2] = { 8043 .type = HDA_FIXUP_FUNC, 8044 .v.func = alc269_fixup_hp_mute_led_mic2, 8045 }, 8046 [ALC269_FIXUP_HP_MUTE_LED_MIC3] = { 8047 .type = HDA_FIXUP_FUNC, 8048 .v.func = alc269_fixup_hp_mute_led_mic3, 8049 .chained = true, 8050 .chain_id = ALC295_FIXUP_HP_AUTO_MUTE 8051 }, 8052 [ALC269_FIXUP_HP_GPIO_LED] = { 8053 .type = HDA_FIXUP_FUNC, 8054 .v.func = alc269_fixup_hp_gpio_led, 8055 }, 8056 [ALC269_FIXUP_HP_GPIO_MIC1_LED] = { 8057 .type = HDA_FIXUP_FUNC, 8058 .v.func = alc269_fixup_hp_gpio_mic1_led, 8059 }, 8060 [ALC269_FIXUP_HP_LINE1_MIC1_LED] = { 8061 .type = HDA_FIXUP_FUNC, 8062 .v.func = alc269_fixup_hp_line1_mic1_led, 8063 }, 8064 [ALC269_FIXUP_INV_DMIC] = { 8065 .type = HDA_FIXUP_FUNC, 8066 .v.func = alc_fixup_inv_dmic, 8067 }, 8068 [ALC269_FIXUP_NO_SHUTUP] = { 8069 .type = HDA_FIXUP_FUNC, 8070 .v.func = alc_fixup_no_shutup, 8071 }, 8072 [ALC269_FIXUP_LENOVO_DOCK] = { 8073 .type = HDA_FIXUP_PINS, 8074 .v.pins = (const struct hda_pintbl[]) { 8075 { 0x19, 0x23a11040 }, /* dock mic */ 8076 { 0x1b, 0x2121103f }, /* dock headphone */ 8077 { } 8078 }, 8079 .chained = true, 8080 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT 8081 }, 8082 [ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST] = { 8083 .type = HDA_FIXUP_FUNC, 8084 .v.func = alc269_fixup_limit_int_mic_boost, 8085 .chained = true, 8086 .chain_id = ALC269_FIXUP_LENOVO_DOCK, 8087 }, 8088 [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = { 8089 .type = HDA_FIXUP_FUNC, 8090 .v.func = alc269_fixup_pincfg_no_hp_to_lineout, 8091 .chained = true, 8092 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 8093 }, 8094 [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = { 8095 .type = HDA_FIXUP_PINS, 8096 .v.pins = (const struct hda_pintbl[]) { 8097 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8098 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 8099 { } 8100 }, 8101 .chained = true, 8102 .chain_id = ALC269_FIXUP_HEADSET_MODE 8103 }, 8104 [ALC269_FIXUP_DELL1_LIMIT_INT_MIC_BOOST] = { 8105 .type = HDA_FIXUP_FUNC, 8106 .v.func = alc269_fixup_limit_int_mic_boost, 8107 .chained = true, 8108 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE 8109 }, 8110 [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = { 8111 .type = HDA_FIXUP_PINS, 8112 .v.pins = (const struct hda_pintbl[]) { 8113 { 0x16, 0x21014020 }, /* dock line out */ 8114 { 0x19, 0x21a19030 }, /* dock mic */ 8115 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8116 { } 8117 }, 8118 .chained = true, 8119 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 8120 }, 8121 [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = { 8122 .type = HDA_FIXUP_PINS, 8123 .v.pins = (const struct hda_pintbl[]) { 8124 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8125 { } 8126 }, 8127 .chained = true, 8128 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 8129 }, 8130 [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = { 8131 .type = HDA_FIXUP_PINS, 8132 .v.pins = (const struct hda_pintbl[]) { 8133 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8134 { 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 8135 { } 8136 }, 8137 .chained = true, 8138 .chain_id = ALC269_FIXUP_HEADSET_MODE 8139 }, 8140 [ALC269_FIXUP_HEADSET_MODE] = { 8141 .type = HDA_FIXUP_FUNC, 8142 .v.func = alc_fixup_headset_mode, 8143 .chained = true, 8144 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 8145 }, 8146 [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = { 8147 .type = HDA_FIXUP_FUNC, 8148 .v.func = alc_fixup_headset_mode_no_hp_mic, 8149 }, 8150 [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = { 8151 .type = HDA_FIXUP_PINS, 8152 .v.pins = (const struct hda_pintbl[]) { 8153 { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */ 8154 { } 8155 }, 8156 .chained = true, 8157 .chain_id = ALC269_FIXUP_HEADSET_MODE, 8158 }, 8159 [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = { 8160 .type = HDA_FIXUP_PINS, 8161 .v.pins = (const struct hda_pintbl[]) { 8162 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8163 { } 8164 }, 8165 .chained = true, 8166 .chain_id = ALC269_FIXUP_HEADSET_MIC 8167 }, 8168 [ALC256_FIXUP_HUAWEI_MACH_WX9_PINS] = { 8169 .type = HDA_FIXUP_PINS, 8170 .v.pins = (const struct hda_pintbl[]) { 8171 {0x12, 0x90a60130}, 8172 {0x13, 0x40000000}, 8173 {0x14, 0x90170110}, 8174 {0x18, 0x411111f0}, 8175 {0x19, 0x04a11040}, 8176 {0x1a, 0x411111f0}, 8177 {0x1b, 0x90170112}, 8178 {0x1d, 0x40759a05}, 8179 {0x1e, 0x411111f0}, 8180 {0x21, 0x04211020}, 8181 { } 8182 }, 8183 .chained = true, 8184 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 8185 }, 8186 [ALC298_FIXUP_HUAWEI_MBX_STEREO] = { 8187 .type = HDA_FIXUP_FUNC, 8188 .v.func = alc298_fixup_huawei_mbx_stereo, 8189 .chained = true, 8190 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 8191 }, 8192 [ALC269_FIXUP_ASUS_X101_FUNC] = { 8193 .type = HDA_FIXUP_FUNC, 8194 .v.func = alc269_fixup_x101_headset_mic, 8195 }, 8196 [ALC269_FIXUP_ASUS_X101_VERB] = { 8197 .type = HDA_FIXUP_VERBS, 8198 .v.verbs = (const struct hda_verb[]) { 8199 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 8200 {0x20, AC_VERB_SET_COEF_INDEX, 0x08}, 8201 {0x20, AC_VERB_SET_PROC_COEF, 0x0310}, 8202 { } 8203 }, 8204 .chained = true, 8205 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC 8206 }, 8207 [ALC269_FIXUP_ASUS_X101] = { 8208 .type = HDA_FIXUP_PINS, 8209 .v.pins = (const struct hda_pintbl[]) { 8210 { 0x18, 0x04a1182c }, /* Headset mic */ 8211 { } 8212 }, 8213 .chained = true, 8214 .chain_id = ALC269_FIXUP_ASUS_X101_VERB 8215 }, 8216 [ALC271_FIXUP_AMIC_MIC2] = { 8217 .type = HDA_FIXUP_PINS, 8218 .v.pins = (const struct hda_pintbl[]) { 8219 { 0x14, 0x99130110 }, /* speaker */ 8220 { 0x19, 0x01a19c20 }, /* mic */ 8221 { 0x1b, 0x99a7012f }, /* int-mic */ 8222 { 0x21, 0x0121401f }, /* HP out */ 8223 { } 8224 }, 8225 }, 8226 [ALC271_FIXUP_HP_GATE_MIC_JACK] = { 8227 .type = HDA_FIXUP_FUNC, 8228 .v.func = alc271_hp_gate_mic_jack, 8229 .chained = true, 8230 .chain_id = ALC271_FIXUP_AMIC_MIC2, 8231 }, 8232 [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = { 8233 .type = HDA_FIXUP_FUNC, 8234 .v.func = alc269_fixup_limit_int_mic_boost, 8235 .chained = true, 8236 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK, 8237 }, 8238 [ALC269_FIXUP_ACER_AC700] = { 8239 .type = HDA_FIXUP_PINS, 8240 .v.pins = (const struct hda_pintbl[]) { 8241 { 0x12, 0x99a3092f }, /* int-mic */ 8242 { 0x14, 0x99130110 }, /* speaker */ 8243 { 0x18, 0x03a11c20 }, /* mic */ 8244 { 0x1e, 0x0346101e }, /* SPDIF1 */ 8245 { 0x21, 0x0321101f }, /* HP out */ 8246 { } 8247 }, 8248 .chained = true, 8249 .chain_id = ALC271_FIXUP_DMIC, 8250 }, 8251 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = { 8252 .type = HDA_FIXUP_FUNC, 8253 .v.func = alc269_fixup_limit_int_mic_boost, 8254 .chained = true, 8255 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 8256 }, 8257 [ALC269VB_FIXUP_ASUS_ZENBOOK] = { 8258 .type = HDA_FIXUP_FUNC, 8259 .v.func = alc269_fixup_limit_int_mic_boost, 8260 .chained = true, 8261 .chain_id = ALC269VB_FIXUP_DMIC, 8262 }, 8263 [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = { 8264 .type = HDA_FIXUP_VERBS, 8265 .v.verbs = (const struct hda_verb[]) { 8266 /* class-D output amp +5dB */ 8267 { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 }, 8268 { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 }, 8269 {} 8270 }, 8271 .chained = true, 8272 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK, 8273 }, 8274 [ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE] = { 8275 .type = HDA_FIXUP_PINS, 8276 .v.pins = (const struct hda_pintbl[]) { 8277 { 0x18, 0x01a110f0 }, /* use as headset mic */ 8278 { } 8279 }, 8280 .chained = true, 8281 .chain_id = ALC269_FIXUP_HEADSET_MIC 8282 }, 8283 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = { 8284 .type = HDA_FIXUP_FUNC, 8285 .v.func = alc269_fixup_limit_int_mic_boost, 8286 .chained = true, 8287 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1, 8288 }, 8289 [ALC269VB_FIXUP_ORDISSIMO_EVE2] = { 8290 .type = HDA_FIXUP_PINS, 8291 .v.pins = (const struct hda_pintbl[]) { 8292 { 0x12, 0x99a3092f }, /* int-mic */ 8293 { 0x18, 0x03a11d20 }, /* mic */ 8294 { 0x19, 0x411111f0 }, /* Unused bogus pin */ 8295 { } 8296 }, 8297 }, 8298 [ALC283_FIXUP_CHROME_BOOK] = { 8299 .type = HDA_FIXUP_FUNC, 8300 .v.func = alc283_fixup_chromebook, 8301 }, 8302 [ALC283_FIXUP_SENSE_COMBO_JACK] = { 8303 .type = HDA_FIXUP_FUNC, 8304 .v.func = alc283_fixup_sense_combo_jack, 8305 .chained = true, 8306 .chain_id = ALC283_FIXUP_CHROME_BOOK, 8307 }, 8308 [ALC282_FIXUP_ASUS_TX300] = { 8309 .type = HDA_FIXUP_FUNC, 8310 .v.func = alc282_fixup_asus_tx300, 8311 }, 8312 [ALC283_FIXUP_INT_MIC] = { 8313 .type = HDA_FIXUP_VERBS, 8314 .v.verbs = (const struct hda_verb[]) { 8315 {0x20, AC_VERB_SET_COEF_INDEX, 0x1a}, 8316 {0x20, AC_VERB_SET_PROC_COEF, 0x0011}, 8317 { } 8318 }, 8319 .chained = true, 8320 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST 8321 }, 8322 [ALC290_FIXUP_SUBWOOFER_HSJACK] = { 8323 .type = HDA_FIXUP_PINS, 8324 .v.pins = (const struct hda_pintbl[]) { 8325 { 0x17, 0x90170112 }, /* subwoofer */ 8326 { } 8327 }, 8328 .chained = true, 8329 .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, 8330 }, 8331 [ALC290_FIXUP_SUBWOOFER] = { 8332 .type = HDA_FIXUP_PINS, 8333 .v.pins = (const struct hda_pintbl[]) { 8334 { 0x17, 0x90170112 }, /* subwoofer */ 8335 { } 8336 }, 8337 .chained = true, 8338 .chain_id = ALC290_FIXUP_MONO_SPEAKERS, 8339 }, 8340 [ALC290_FIXUP_MONO_SPEAKERS] = { 8341 .type = HDA_FIXUP_FUNC, 8342 .v.func = alc290_fixup_mono_speakers, 8343 }, 8344 [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = { 8345 .type = HDA_FIXUP_FUNC, 8346 .v.func = alc290_fixup_mono_speakers, 8347 .chained = true, 8348 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, 8349 }, 8350 [ALC269_FIXUP_THINKPAD_ACPI] = { 8351 .type = HDA_FIXUP_FUNC, 8352 .v.func = alc_fixup_thinkpad_acpi, 8353 .chained = true, 8354 .chain_id = ALC269_FIXUP_SKU_IGNORE, 8355 }, 8356 [ALC269_FIXUP_LENOVO_XPAD_ACPI] = { 8357 .type = HDA_FIXUP_FUNC, 8358 .v.func = alc_fixup_ideapad_acpi, 8359 .chained = true, 8360 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 8361 }, 8362 [ALC269_FIXUP_DMIC_THINKPAD_ACPI] = { 8363 .type = HDA_FIXUP_FUNC, 8364 .v.func = alc_fixup_inv_dmic, 8365 .chained = true, 8366 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 8367 }, 8368 [ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = { 8369 .type = HDA_FIXUP_PINS, 8370 .v.pins = (const struct hda_pintbl[]) { 8371 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8372 { } 8373 }, 8374 .chained = true, 8375 .chain_id = ALC255_FIXUP_HEADSET_MODE 8376 }, 8377 [ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = { 8378 .type = HDA_FIXUP_PINS, 8379 .v.pins = (const struct hda_pintbl[]) { 8380 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8381 { } 8382 }, 8383 .chained = true, 8384 .chain_id = ALC255_FIXUP_HEADSET_MODE 8385 }, 8386 [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = { 8387 .type = HDA_FIXUP_PINS, 8388 .v.pins = (const struct hda_pintbl[]) { 8389 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8390 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 8391 { } 8392 }, 8393 .chained = true, 8394 .chain_id = ALC255_FIXUP_HEADSET_MODE 8395 }, 8396 [ALC255_FIXUP_DELL1_LIMIT_INT_MIC_BOOST] = { 8397 .type = HDA_FIXUP_FUNC, 8398 .v.func = alc269_fixup_limit_int_mic_boost, 8399 .chained = true, 8400 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE 8401 }, 8402 [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = { 8403 .type = HDA_FIXUP_PINS, 8404 .v.pins = (const struct hda_pintbl[]) { 8405 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8406 { } 8407 }, 8408 .chained = true, 8409 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC 8410 }, 8411 [ALC255_FIXUP_HEADSET_MODE] = { 8412 .type = HDA_FIXUP_FUNC, 8413 .v.func = alc_fixup_headset_mode_alc255, 8414 .chained = true, 8415 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 8416 }, 8417 [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = { 8418 .type = HDA_FIXUP_FUNC, 8419 .v.func = alc_fixup_headset_mode_alc255_no_hp_mic, 8420 }, 8421 [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = { 8422 .type = HDA_FIXUP_PINS, 8423 .v.pins = (const struct hda_pintbl[]) { 8424 { 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 8425 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8426 { } 8427 }, 8428 .chained = true, 8429 .chain_id = ALC269_FIXUP_HEADSET_MODE 8430 }, 8431 [ALC292_FIXUP_TPT440_DOCK] = { 8432 .type = HDA_FIXUP_FUNC, 8433 .v.func = alc_fixup_tpt440_dock, 8434 .chained = true, 8435 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST 8436 }, 8437 [ALC292_FIXUP_TPT440] = { 8438 .type = HDA_FIXUP_FUNC, 8439 .v.func = alc_fixup_disable_aamix, 8440 .chained = true, 8441 .chain_id = ALC292_FIXUP_TPT440_DOCK, 8442 }, 8443 [ALC283_FIXUP_HEADSET_MIC] = { 8444 .type = HDA_FIXUP_PINS, 8445 .v.pins = (const struct hda_pintbl[]) { 8446 { 0x19, 0x04a110f0 }, 8447 { }, 8448 }, 8449 }, 8450 [ALC255_FIXUP_MIC_MUTE_LED] = { 8451 .type = HDA_FIXUP_FUNC, 8452 .v.func = alc_fixup_micmute_led, 8453 }, 8454 [ALC282_FIXUP_ASPIRE_V5_PINS] = { 8455 .type = HDA_FIXUP_PINS, 8456 .v.pins = (const struct hda_pintbl[]) { 8457 { 0x12, 0x90a60130 }, 8458 { 0x14, 0x90170110 }, 8459 { 0x17, 0x40000008 }, 8460 { 0x18, 0x411111f0 }, 8461 { 0x19, 0x01a1913c }, 8462 { 0x1a, 0x411111f0 }, 8463 { 0x1b, 0x411111f0 }, 8464 { 0x1d, 0x40f89b2d }, 8465 { 0x1e, 0x411111f0 }, 8466 { 0x21, 0x0321101f }, 8467 { }, 8468 }, 8469 }, 8470 [ALC269VB_FIXUP_ASPIRE_E1_COEF] = { 8471 .type = HDA_FIXUP_FUNC, 8472 .v.func = alc269vb_fixup_aspire_e1_coef, 8473 }, 8474 [ALC280_FIXUP_HP_GPIO4] = { 8475 .type = HDA_FIXUP_FUNC, 8476 .v.func = alc280_fixup_hp_gpio4, 8477 }, 8478 [ALC286_FIXUP_HP_GPIO_LED] = { 8479 .type = HDA_FIXUP_FUNC, 8480 .v.func = alc286_fixup_hp_gpio_led, 8481 }, 8482 [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = { 8483 .type = HDA_FIXUP_FUNC, 8484 .v.func = alc280_fixup_hp_gpio2_mic_hotkey, 8485 }, 8486 [ALC280_FIXUP_HP_DOCK_PINS] = { 8487 .type = HDA_FIXUP_PINS, 8488 .v.pins = (const struct hda_pintbl[]) { 8489 { 0x1b, 0x21011020 }, /* line-out */ 8490 { 0x1a, 0x01a1903c }, /* headset mic */ 8491 { 0x18, 0x2181103f }, /* line-in */ 8492 { }, 8493 }, 8494 .chained = true, 8495 .chain_id = ALC280_FIXUP_HP_GPIO4 8496 }, 8497 [ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = { 8498 .type = HDA_FIXUP_PINS, 8499 .v.pins = (const struct hda_pintbl[]) { 8500 { 0x1b, 0x21011020 }, /* line-out */ 8501 { 0x18, 0x2181103f }, /* line-in */ 8502 { }, 8503 }, 8504 .chained = true, 8505 .chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED 8506 }, 8507 [ALC280_FIXUP_HP_9480M] = { 8508 .type = HDA_FIXUP_FUNC, 8509 .v.func = alc280_fixup_hp_9480m, 8510 }, 8511 [ALC245_FIXUP_HP_X360_AMP] = { 8512 .type = HDA_FIXUP_FUNC, 8513 .v.func = alc245_fixup_hp_x360_amp, 8514 .chained = true, 8515 .chain_id = ALC245_FIXUP_HP_GPIO_LED 8516 }, 8517 [ALC288_FIXUP_DELL_HEADSET_MODE] = { 8518 .type = HDA_FIXUP_FUNC, 8519 .v.func = alc_fixup_headset_mode_dell_alc288, 8520 .chained = true, 8521 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 8522 }, 8523 [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = { 8524 .type = HDA_FIXUP_PINS, 8525 .v.pins = (const struct hda_pintbl[]) { 8526 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8527 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 8528 { } 8529 }, 8530 .chained = true, 8531 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE 8532 }, 8533 [ALC288_FIXUP_DISABLE_AAMIX] = { 8534 .type = HDA_FIXUP_FUNC, 8535 .v.func = alc_fixup_disable_aamix, 8536 .chained = true, 8537 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE 8538 }, 8539 [ALC288_FIXUP_DELL_XPS_13] = { 8540 .type = HDA_FIXUP_FUNC, 8541 .v.func = alc_fixup_dell_xps13, 8542 .chained = true, 8543 .chain_id = ALC288_FIXUP_DISABLE_AAMIX 8544 }, 8545 [ALC292_FIXUP_DISABLE_AAMIX] = { 8546 .type = HDA_FIXUP_FUNC, 8547 .v.func = alc_fixup_disable_aamix, 8548 .chained = true, 8549 .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE 8550 }, 8551 [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = { 8552 .type = HDA_FIXUP_FUNC, 8553 .v.func = alc_fixup_disable_aamix, 8554 .chained = true, 8555 .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE 8556 }, 8557 [ALC292_FIXUP_DELL_E7X_AAMIX] = { 8558 .type = HDA_FIXUP_FUNC, 8559 .v.func = alc_fixup_dell_xps13, 8560 .chained = true, 8561 .chain_id = ALC292_FIXUP_DISABLE_AAMIX 8562 }, 8563 [ALC292_FIXUP_DELL_E7X] = { 8564 .type = HDA_FIXUP_FUNC, 8565 .v.func = alc_fixup_micmute_led, 8566 /* micmute fixup must be applied at last */ 8567 .chained_before = true, 8568 .chain_id = ALC292_FIXUP_DELL_E7X_AAMIX, 8569 }, 8570 [ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE] = { 8571 .type = HDA_FIXUP_PINS, 8572 .v.pins = (const struct hda_pintbl[]) { 8573 { 0x18, 0x01a1913c }, /* headset mic w/o jack detect */ 8574 { } 8575 }, 8576 .chained_before = true, 8577 .chain_id = ALC269_FIXUP_HEADSET_MODE, 8578 }, 8579 [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = { 8580 .type = HDA_FIXUP_PINS, 8581 .v.pins = (const struct hda_pintbl[]) { 8582 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8583 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 8584 { } 8585 }, 8586 .chained = true, 8587 .chain_id = ALC269_FIXUP_HEADSET_MODE 8588 }, 8589 [ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = { 8590 .type = HDA_FIXUP_PINS, 8591 .v.pins = (const struct hda_pintbl[]) { 8592 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8593 { } 8594 }, 8595 .chained = true, 8596 .chain_id = ALC269_FIXUP_HEADSET_MODE 8597 }, 8598 [ALC275_FIXUP_DELL_XPS] = { 8599 .type = HDA_FIXUP_VERBS, 8600 .v.verbs = (const struct hda_verb[]) { 8601 /* Enables internal speaker */ 8602 {0x20, AC_VERB_SET_COEF_INDEX, 0x1f}, 8603 {0x20, AC_VERB_SET_PROC_COEF, 0x00c0}, 8604 {0x20, AC_VERB_SET_COEF_INDEX, 0x30}, 8605 {0x20, AC_VERB_SET_PROC_COEF, 0x00b1}, 8606 {} 8607 } 8608 }, 8609 [ALC293_FIXUP_LENOVO_SPK_NOISE] = { 8610 .type = HDA_FIXUP_FUNC, 8611 .v.func = alc_fixup_disable_aamix, 8612 .chained = true, 8613 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 8614 }, 8615 [ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = { 8616 .type = HDA_FIXUP_FUNC, 8617 .v.func = alc233_fixup_lenovo_line2_mic_hotkey, 8618 }, 8619 [ALC233_FIXUP_INTEL_NUC8_DMIC] = { 8620 .type = HDA_FIXUP_FUNC, 8621 .v.func = alc_fixup_inv_dmic, 8622 .chained = true, 8623 .chain_id = ALC233_FIXUP_INTEL_NUC8_BOOST, 8624 }, 8625 [ALC233_FIXUP_INTEL_NUC8_BOOST] = { 8626 .type = HDA_FIXUP_FUNC, 8627 .v.func = alc269_fixup_limit_int_mic_boost 8628 }, 8629 [ALC255_FIXUP_DELL_SPK_NOISE] = { 8630 .type = HDA_FIXUP_FUNC, 8631 .v.func = alc_fixup_disable_aamix, 8632 .chained = true, 8633 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE 8634 }, 8635 [ALC225_FIXUP_DISABLE_MIC_VREF] = { 8636 .type = HDA_FIXUP_FUNC, 8637 .v.func = alc_fixup_disable_mic_vref, 8638 .chained = true, 8639 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE 8640 }, 8641 [ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = { 8642 .type = HDA_FIXUP_VERBS, 8643 .v.verbs = (const struct hda_verb[]) { 8644 /* Disable pass-through path for FRONT 14h */ 8645 { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 }, 8646 { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 }, 8647 {} 8648 }, 8649 .chained = true, 8650 .chain_id = ALC225_FIXUP_DISABLE_MIC_VREF 8651 }, 8652 [ALC280_FIXUP_HP_HEADSET_MIC] = { 8653 .type = HDA_FIXUP_FUNC, 8654 .v.func = alc_fixup_disable_aamix, 8655 .chained = true, 8656 .chain_id = ALC269_FIXUP_HEADSET_MIC, 8657 }, 8658 [ALC221_FIXUP_HP_FRONT_MIC] = { 8659 .type = HDA_FIXUP_PINS, 8660 .v.pins = (const struct hda_pintbl[]) { 8661 { 0x19, 0x02a19020 }, /* Front Mic */ 8662 { } 8663 }, 8664 }, 8665 [ALC292_FIXUP_TPT460] = { 8666 .type = HDA_FIXUP_FUNC, 8667 .v.func = alc_fixup_tpt440_dock, 8668 .chained = true, 8669 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE, 8670 }, 8671 [ALC298_FIXUP_SPK_VOLUME] = { 8672 .type = HDA_FIXUP_FUNC, 8673 .v.func = alc298_fixup_speaker_volume, 8674 .chained = true, 8675 .chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, 8676 }, 8677 [ALC298_FIXUP_LENOVO_SPK_VOLUME] = { 8678 .type = HDA_FIXUP_FUNC, 8679 .v.func = alc298_fixup_speaker_volume, 8680 }, 8681 [ALC295_FIXUP_DISABLE_DAC3] = { 8682 .type = HDA_FIXUP_FUNC, 8683 .v.func = alc295_fixup_disable_dac3, 8684 }, 8685 [ALC285_FIXUP_SPEAKER2_TO_DAC1] = { 8686 .type = HDA_FIXUP_FUNC, 8687 .v.func = alc285_fixup_speaker2_to_dac1, 8688 .chained = true, 8689 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 8690 }, 8691 [ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1] = { 8692 .type = HDA_FIXUP_FUNC, 8693 .v.func = alc285_fixup_speaker2_to_dac1, 8694 .chained = true, 8695 .chain_id = ALC245_FIXUP_CS35L41_SPI_2 8696 }, 8697 [ALC285_FIXUP_ASUS_HEADSET_MIC] = { 8698 .type = HDA_FIXUP_PINS, 8699 .v.pins = (const struct hda_pintbl[]) { 8700 { 0x19, 0x03a11050 }, 8701 { 0x1b, 0x03a11c30 }, 8702 { } 8703 }, 8704 .chained = true, 8705 .chain_id = ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1 8706 }, 8707 [ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS] = { 8708 .type = HDA_FIXUP_PINS, 8709 .v.pins = (const struct hda_pintbl[]) { 8710 { 0x14, 0x90170120 }, 8711 { } 8712 }, 8713 .chained = true, 8714 .chain_id = ALC285_FIXUP_ASUS_HEADSET_MIC 8715 }, 8716 [ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1] = { 8717 .type = HDA_FIXUP_FUNC, 8718 .v.func = alc285_fixup_speaker2_to_dac1, 8719 .chained = true, 8720 .chain_id = ALC287_FIXUP_CS35L41_I2C_2 8721 }, 8722 [ALC285_FIXUP_ASUS_I2C_HEADSET_MIC] = { 8723 .type = HDA_FIXUP_PINS, 8724 .v.pins = (const struct hda_pintbl[]) { 8725 { 0x19, 0x03a11050 }, 8726 { 0x1b, 0x03a11c30 }, 8727 { } 8728 }, 8729 .chained = true, 8730 .chain_id = ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1 8731 }, 8732 [ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = { 8733 .type = HDA_FIXUP_PINS, 8734 .v.pins = (const struct hda_pintbl[]) { 8735 { 0x1b, 0x90170151 }, 8736 { } 8737 }, 8738 .chained = true, 8739 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE 8740 }, 8741 [ALC269_FIXUP_ATIV_BOOK_8] = { 8742 .type = HDA_FIXUP_FUNC, 8743 .v.func = alc_fixup_auto_mute_via_amp, 8744 .chained = true, 8745 .chain_id = ALC269_FIXUP_NO_SHUTUP 8746 }, 8747 [ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE] = { 8748 .type = HDA_FIXUP_PINS, 8749 .v.pins = (const struct hda_pintbl[]) { 8750 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8751 { 0x1a, 0x01813030 }, /* use as headphone mic, without its own jack detect */ 8752 { } 8753 }, 8754 .chained = true, 8755 .chain_id = ALC269_FIXUP_HEADSET_MODE 8756 }, 8757 [ALC221_FIXUP_HP_MIC_NO_PRESENCE] = { 8758 .type = HDA_FIXUP_PINS, 8759 .v.pins = (const struct hda_pintbl[]) { 8760 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8761 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 8762 { } 8763 }, 8764 .chained = true, 8765 .chain_id = ALC269_FIXUP_HEADSET_MODE 8766 }, 8767 [ALC256_FIXUP_ASUS_HEADSET_MODE] = { 8768 .type = HDA_FIXUP_FUNC, 8769 .v.func = alc_fixup_headset_mode, 8770 }, 8771 [ALC256_FIXUP_ASUS_MIC] = { 8772 .type = HDA_FIXUP_PINS, 8773 .v.pins = (const struct hda_pintbl[]) { 8774 { 0x13, 0x90a60160 }, /* use as internal mic */ 8775 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */ 8776 { } 8777 }, 8778 .chained = true, 8779 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 8780 }, 8781 [ALC256_FIXUP_ASUS_AIO_GPIO2] = { 8782 .type = HDA_FIXUP_FUNC, 8783 /* Set up GPIO2 for the speaker amp */ 8784 .v.func = alc_fixup_gpio4, 8785 }, 8786 [ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = { 8787 .type = HDA_FIXUP_PINS, 8788 .v.pins = (const struct hda_pintbl[]) { 8789 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8790 { } 8791 }, 8792 .chained = true, 8793 .chain_id = ALC269_FIXUP_HEADSET_MIC 8794 }, 8795 [ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = { 8796 .type = HDA_FIXUP_VERBS, 8797 .v.verbs = (const struct hda_verb[]) { 8798 /* Enables internal speaker */ 8799 {0x20, AC_VERB_SET_COEF_INDEX, 0x40}, 8800 {0x20, AC_VERB_SET_PROC_COEF, 0x8800}, 8801 {} 8802 }, 8803 .chained = true, 8804 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE 8805 }, 8806 [ALC233_FIXUP_LENOVO_MULTI_CODECS] = { 8807 .type = HDA_FIXUP_FUNC, 8808 .v.func = alc233_alc662_fixup_lenovo_dual_codecs, 8809 .chained = true, 8810 .chain_id = ALC269_FIXUP_GPIO2 8811 }, 8812 [ALC233_FIXUP_ACER_HEADSET_MIC] = { 8813 .type = HDA_FIXUP_VERBS, 8814 .v.verbs = (const struct hda_verb[]) { 8815 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 }, 8816 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 }, 8817 { } 8818 }, 8819 .chained = true, 8820 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE 8821 }, 8822 [ALC294_FIXUP_LENOVO_MIC_LOCATION] = { 8823 .type = HDA_FIXUP_PINS, 8824 .v.pins = (const struct hda_pintbl[]) { 8825 /* Change the mic location from front to right, otherwise there are 8826 two front mics with the same name, pulseaudio can't handle them. 8827 This is just a temporary workaround, after applying this fixup, 8828 there will be one "Front Mic" and one "Mic" in this machine. 8829 */ 8830 { 0x1a, 0x04a19040 }, 8831 { } 8832 }, 8833 }, 8834 [ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = { 8835 .type = HDA_FIXUP_PINS, 8836 .v.pins = (const struct hda_pintbl[]) { 8837 { 0x16, 0x0101102f }, /* Rear Headset HP */ 8838 { 0x19, 0x02a1913c }, /* use as Front headset mic, without its own jack detect */ 8839 { 0x1a, 0x01a19030 }, /* Rear Headset MIC */ 8840 { 0x1b, 0x02011020 }, 8841 { } 8842 }, 8843 .chained = true, 8844 .chain_id = ALC225_FIXUP_S3_POP_NOISE 8845 }, 8846 [ALC225_FIXUP_S3_POP_NOISE] = { 8847 .type = HDA_FIXUP_FUNC, 8848 .v.func = alc225_fixup_s3_pop_noise, 8849 .chained = true, 8850 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 8851 }, 8852 [ALC700_FIXUP_INTEL_REFERENCE] = { 8853 .type = HDA_FIXUP_VERBS, 8854 .v.verbs = (const struct hda_verb[]) { 8855 /* Enables internal speaker */ 8856 {0x20, AC_VERB_SET_COEF_INDEX, 0x45}, 8857 {0x20, AC_VERB_SET_PROC_COEF, 0x5289}, 8858 {0x20, AC_VERB_SET_COEF_INDEX, 0x4A}, 8859 {0x20, AC_VERB_SET_PROC_COEF, 0x001b}, 8860 {0x58, AC_VERB_SET_COEF_INDEX, 0x00}, 8861 {0x58, AC_VERB_SET_PROC_COEF, 0x3888}, 8862 {0x20, AC_VERB_SET_COEF_INDEX, 0x6f}, 8863 {0x20, AC_VERB_SET_PROC_COEF, 0x2c0b}, 8864 {} 8865 } 8866 }, 8867 [ALC274_FIXUP_DELL_BIND_DACS] = { 8868 .type = HDA_FIXUP_FUNC, 8869 .v.func = alc274_fixup_bind_dacs, 8870 .chained = true, 8871 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE 8872 }, 8873 [ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = { 8874 .type = HDA_FIXUP_PINS, 8875 .v.pins = (const struct hda_pintbl[]) { 8876 { 0x1b, 0x0401102f }, 8877 { } 8878 }, 8879 .chained = true, 8880 .chain_id = ALC274_FIXUP_DELL_BIND_DACS 8881 }, 8882 [ALC298_FIXUP_TPT470_DOCK_FIX] = { 8883 .type = HDA_FIXUP_FUNC, 8884 .v.func = alc_fixup_tpt470_dock, 8885 .chained = true, 8886 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE 8887 }, 8888 [ALC298_FIXUP_TPT470_DOCK] = { 8889 .type = HDA_FIXUP_FUNC, 8890 .v.func = alc_fixup_tpt470_dacs, 8891 .chained = true, 8892 .chain_id = ALC298_FIXUP_TPT470_DOCK_FIX 8893 }, 8894 [ALC255_FIXUP_DUMMY_LINEOUT_VERB] = { 8895 .type = HDA_FIXUP_PINS, 8896 .v.pins = (const struct hda_pintbl[]) { 8897 { 0x14, 0x0201101f }, 8898 { } 8899 }, 8900 .chained = true, 8901 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE 8902 }, 8903 [ALC255_FIXUP_DELL_HEADSET_MIC] = { 8904 .type = HDA_FIXUP_PINS, 8905 .v.pins = (const struct hda_pintbl[]) { 8906 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8907 { } 8908 }, 8909 .chained = true, 8910 .chain_id = ALC269_FIXUP_HEADSET_MIC 8911 }, 8912 [ALC295_FIXUP_HP_X360] = { 8913 .type = HDA_FIXUP_FUNC, 8914 .v.func = alc295_fixup_hp_top_speakers, 8915 .chained = true, 8916 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3 8917 }, 8918 [ALC221_FIXUP_HP_HEADSET_MIC] = { 8919 .type = HDA_FIXUP_PINS, 8920 .v.pins = (const struct hda_pintbl[]) { 8921 { 0x19, 0x0181313f}, 8922 { } 8923 }, 8924 .chained = true, 8925 .chain_id = ALC269_FIXUP_HEADSET_MIC 8926 }, 8927 [ALC285_FIXUP_LENOVO_HEADPHONE_NOISE] = { 8928 .type = HDA_FIXUP_FUNC, 8929 .v.func = alc285_fixup_invalidate_dacs, 8930 .chained = true, 8931 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 8932 }, 8933 [ALC295_FIXUP_HP_AUTO_MUTE] = { 8934 .type = HDA_FIXUP_FUNC, 8935 .v.func = alc_fixup_auto_mute_via_amp, 8936 }, 8937 [ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE] = { 8938 .type = HDA_FIXUP_PINS, 8939 .v.pins = (const struct hda_pintbl[]) { 8940 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8941 { } 8942 }, 8943 .chained = true, 8944 .chain_id = ALC269_FIXUP_HEADSET_MIC 8945 }, 8946 [ALC294_FIXUP_ASUS_MIC] = { 8947 .type = HDA_FIXUP_PINS, 8948 .v.pins = (const struct hda_pintbl[]) { 8949 { 0x13, 0x90a60160 }, /* use as internal mic */ 8950 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */ 8951 { } 8952 }, 8953 .chained = true, 8954 .chain_id = ALC269_FIXUP_HEADSET_MIC 8955 }, 8956 [ALC294_FIXUP_ASUS_HEADSET_MIC] = { 8957 .type = HDA_FIXUP_PINS, 8958 .v.pins = (const struct hda_pintbl[]) { 8959 { 0x19, 0x01a1103c }, /* use as headset mic */ 8960 { } 8961 }, 8962 .chained = true, 8963 .chain_id = ALC269_FIXUP_HEADSET_MIC 8964 }, 8965 [ALC294_FIXUP_ASUS_SPK] = { 8966 .type = HDA_FIXUP_VERBS, 8967 .v.verbs = (const struct hda_verb[]) { 8968 /* Set EAPD high */ 8969 { 0x20, AC_VERB_SET_COEF_INDEX, 0x40 }, 8970 { 0x20, AC_VERB_SET_PROC_COEF, 0x8800 }, 8971 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f }, 8972 { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 }, 8973 { } 8974 }, 8975 .chained = true, 8976 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC 8977 }, 8978 [ALC295_FIXUP_CHROME_BOOK] = { 8979 .type = HDA_FIXUP_FUNC, 8980 .v.func = alc295_fixup_chromebook, 8981 .chained = true, 8982 .chain_id = ALC225_FIXUP_HEADSET_JACK 8983 }, 8984 [ALC225_FIXUP_HEADSET_JACK] = { 8985 .type = HDA_FIXUP_FUNC, 8986 .v.func = alc_fixup_headset_jack, 8987 }, 8988 [ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = { 8989 .type = HDA_FIXUP_PINS, 8990 .v.pins = (const struct hda_pintbl[]) { 8991 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8992 { } 8993 }, 8994 .chained = true, 8995 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 8996 }, 8997 [ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE] = { 8998 .type = HDA_FIXUP_VERBS, 8999 .v.verbs = (const struct hda_verb[]) { 9000 /* Disable PCBEEP-IN passthrough */ 9001 { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 }, 9002 { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 }, 9003 { } 9004 }, 9005 .chained = true, 9006 .chain_id = ALC285_FIXUP_LENOVO_HEADPHONE_NOISE 9007 }, 9008 [ALC255_FIXUP_ACER_HEADSET_MIC] = { 9009 .type = HDA_FIXUP_PINS, 9010 .v.pins = (const struct hda_pintbl[]) { 9011 { 0x19, 0x03a11130 }, 9012 { 0x1a, 0x90a60140 }, /* use as internal mic */ 9013 { } 9014 }, 9015 .chained = true, 9016 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC 9017 }, 9018 [ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE] = { 9019 .type = HDA_FIXUP_PINS, 9020 .v.pins = (const struct hda_pintbl[]) { 9021 { 0x16, 0x01011020 }, /* Rear Line out */ 9022 { 0x19, 0x01a1913c }, /* use as Front headset mic, without its own jack detect */ 9023 { } 9024 }, 9025 .chained = true, 9026 .chain_id = ALC225_FIXUP_WYSE_AUTO_MUTE 9027 }, 9028 [ALC225_FIXUP_WYSE_AUTO_MUTE] = { 9029 .type = HDA_FIXUP_FUNC, 9030 .v.func = alc_fixup_auto_mute_via_amp, 9031 .chained = true, 9032 .chain_id = ALC225_FIXUP_WYSE_DISABLE_MIC_VREF 9033 }, 9034 [ALC225_FIXUP_WYSE_DISABLE_MIC_VREF] = { 9035 .type = HDA_FIXUP_FUNC, 9036 .v.func = alc_fixup_disable_mic_vref, 9037 .chained = true, 9038 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 9039 }, 9040 [ALC286_FIXUP_ACER_AIO_HEADSET_MIC] = { 9041 .type = HDA_FIXUP_VERBS, 9042 .v.verbs = (const struct hda_verb[]) { 9043 { 0x20, AC_VERB_SET_COEF_INDEX, 0x4f }, 9044 { 0x20, AC_VERB_SET_PROC_COEF, 0x5029 }, 9045 { } 9046 }, 9047 .chained = true, 9048 .chain_id = ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE 9049 }, 9050 [ALC256_FIXUP_ASUS_HEADSET_MIC] = { 9051 .type = HDA_FIXUP_PINS, 9052 .v.pins = (const struct hda_pintbl[]) { 9053 { 0x19, 0x03a11020 }, /* headset mic with jack detect */ 9054 { } 9055 }, 9056 .chained = true, 9057 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 9058 }, 9059 [ALC256_FIXUP_ASUS_MIC_NO_PRESENCE] = { 9060 .type = HDA_FIXUP_PINS, 9061 .v.pins = (const struct hda_pintbl[]) { 9062 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */ 9063 { } 9064 }, 9065 .chained = true, 9066 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 9067 }, 9068 [ALC255_FIXUP_PREDATOR_SUBWOOFER] = { 9069 .type = HDA_FIXUP_PINS, 9070 .v.pins = (const struct hda_pintbl[]) { 9071 { 0x17, 0x90170151 }, /* use as internal speaker (LFE) */ 9072 { 0x1b, 0x90170152 } /* use as internal speaker (back) */ 9073 } 9074 }, 9075 [ALC299_FIXUP_PREDATOR_SPK] = { 9076 .type = HDA_FIXUP_PINS, 9077 .v.pins = (const struct hda_pintbl[]) { 9078 { 0x21, 0x90170150 }, /* use as headset mic, without its own jack detect */ 9079 { } 9080 } 9081 }, 9082 [ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = { 9083 .type = HDA_FIXUP_PINS, 9084 .v.pins = (const struct hda_pintbl[]) { 9085 { 0x19, 0x04a11040 }, 9086 { 0x21, 0x04211020 }, 9087 { } 9088 }, 9089 .chained = true, 9090 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 9091 }, 9092 [ALC289_FIXUP_DELL_SPK1] = { 9093 .type = HDA_FIXUP_PINS, 9094 .v.pins = (const struct hda_pintbl[]) { 9095 { 0x14, 0x90170140 }, 9096 { } 9097 }, 9098 .chained = true, 9099 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE 9100 }, 9101 [ALC289_FIXUP_DELL_SPK2] = { 9102 .type = HDA_FIXUP_PINS, 9103 .v.pins = (const struct hda_pintbl[]) { 9104 { 0x17, 0x90170130 }, /* bass spk */ 9105 { } 9106 }, 9107 .chained = true, 9108 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE 9109 }, 9110 [ALC289_FIXUP_DUAL_SPK] = { 9111 .type = HDA_FIXUP_FUNC, 9112 .v.func = alc285_fixup_speaker2_to_dac1, 9113 .chained = true, 9114 .chain_id = ALC289_FIXUP_DELL_SPK2 9115 }, 9116 [ALC289_FIXUP_RTK_AMP_DUAL_SPK] = { 9117 .type = HDA_FIXUP_FUNC, 9118 .v.func = alc285_fixup_speaker2_to_dac1, 9119 .chained = true, 9120 .chain_id = ALC289_FIXUP_DELL_SPK1 9121 }, 9122 [ALC294_FIXUP_SPK2_TO_DAC1] = { 9123 .type = HDA_FIXUP_FUNC, 9124 .v.func = alc285_fixup_speaker2_to_dac1, 9125 .chained = true, 9126 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC 9127 }, 9128 [ALC294_FIXUP_ASUS_DUAL_SPK] = { 9129 .type = HDA_FIXUP_FUNC, 9130 /* The GPIO must be pulled to initialize the AMP */ 9131 .v.func = alc_fixup_gpio4, 9132 .chained = true, 9133 .chain_id = ALC294_FIXUP_SPK2_TO_DAC1 9134 }, 9135 [ALC294_FIXUP_ASUS_ALLY] = { 9136 .type = HDA_FIXUP_FUNC, 9137 .v.func = cs35l41_fixup_i2c_two, 9138 .chained = true, 9139 .chain_id = ALC294_FIXUP_ASUS_ALLY_PINS 9140 }, 9141 [ALC294_FIXUP_ASUS_ALLY_X] = { 9142 .type = HDA_FIXUP_FUNC, 9143 .v.func = tas2781_fixup_i2c, 9144 .chained = true, 9145 .chain_id = ALC294_FIXUP_ASUS_ALLY_PINS 9146 }, 9147 [ALC294_FIXUP_ASUS_ALLY_PINS] = { 9148 .type = HDA_FIXUP_PINS, 9149 .v.pins = (const struct hda_pintbl[]) { 9150 { 0x19, 0x03a11050 }, 9151 { 0x1a, 0x03a11c30 }, 9152 { 0x21, 0x03211420 }, 9153 { } 9154 }, 9155 .chained = true, 9156 .chain_id = ALC294_FIXUP_ASUS_ALLY_VERBS 9157 }, 9158 [ALC294_FIXUP_ASUS_ALLY_VERBS] = { 9159 .type = HDA_FIXUP_VERBS, 9160 .v.verbs = (const struct hda_verb[]) { 9161 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 }, 9162 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 }, 9163 { 0x20, AC_VERB_SET_COEF_INDEX, 0x46 }, 9164 { 0x20, AC_VERB_SET_PROC_COEF, 0x0004 }, 9165 { 0x20, AC_VERB_SET_COEF_INDEX, 0x47 }, 9166 { 0x20, AC_VERB_SET_PROC_COEF, 0xa47a }, 9167 { 0x20, AC_VERB_SET_COEF_INDEX, 0x49 }, 9168 { 0x20, AC_VERB_SET_PROC_COEF, 0x0049}, 9169 { 0x20, AC_VERB_SET_COEF_INDEX, 0x4a }, 9170 { 0x20, AC_VERB_SET_PROC_COEF, 0x201b }, 9171 { 0x20, AC_VERB_SET_COEF_INDEX, 0x6b }, 9172 { 0x20, AC_VERB_SET_PROC_COEF, 0x4278}, 9173 { } 9174 }, 9175 .chained = true, 9176 .chain_id = ALC294_FIXUP_ASUS_ALLY_SPEAKER 9177 }, 9178 [ALC294_FIXUP_ASUS_ALLY_SPEAKER] = { 9179 .type = HDA_FIXUP_FUNC, 9180 .v.func = alc285_fixup_speaker2_to_dac1, 9181 }, 9182 [ALC285_FIXUP_THINKPAD_X1_GEN7] = { 9183 .type = HDA_FIXUP_FUNC, 9184 .v.func = alc285_fixup_thinkpad_x1_gen7, 9185 .chained = true, 9186 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 9187 }, 9188 [ALC285_FIXUP_THINKPAD_HEADSET_JACK] = { 9189 .type = HDA_FIXUP_FUNC, 9190 .v.func = alc_fixup_headset_jack, 9191 .chained = true, 9192 .chain_id = ALC285_FIXUP_THINKPAD_X1_GEN7 9193 }, 9194 [ALC294_FIXUP_ASUS_HPE] = { 9195 .type = HDA_FIXUP_VERBS, 9196 .v.verbs = (const struct hda_verb[]) { 9197 /* Set EAPD high */ 9198 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f }, 9199 { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 }, 9200 { } 9201 }, 9202 .chained = true, 9203 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC 9204 }, 9205 [ALC294_FIXUP_ASUS_GX502_PINS] = { 9206 .type = HDA_FIXUP_PINS, 9207 .v.pins = (const struct hda_pintbl[]) { 9208 { 0x19, 0x03a11050 }, /* front HP mic */ 9209 { 0x1a, 0x01a11830 }, /* rear external mic */ 9210 { 0x21, 0x03211020 }, /* front HP out */ 9211 { } 9212 }, 9213 .chained = true, 9214 .chain_id = ALC294_FIXUP_ASUS_GX502_VERBS 9215 }, 9216 [ALC294_FIXUP_ASUS_GX502_VERBS] = { 9217 .type = HDA_FIXUP_VERBS, 9218 .v.verbs = (const struct hda_verb[]) { 9219 /* set 0x15 to HP-OUT ctrl */ 9220 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 9221 /* unmute the 0x15 amp */ 9222 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 }, 9223 { } 9224 }, 9225 .chained = true, 9226 .chain_id = ALC294_FIXUP_ASUS_GX502_HP 9227 }, 9228 [ALC294_FIXUP_ASUS_GX502_HP] = { 9229 .type = HDA_FIXUP_FUNC, 9230 .v.func = alc294_fixup_gx502_hp, 9231 }, 9232 [ALC294_FIXUP_ASUS_GU502_PINS] = { 9233 .type = HDA_FIXUP_PINS, 9234 .v.pins = (const struct hda_pintbl[]) { 9235 { 0x19, 0x01a11050 }, /* rear HP mic */ 9236 { 0x1a, 0x01a11830 }, /* rear external mic */ 9237 { 0x21, 0x012110f0 }, /* rear HP out */ 9238 { } 9239 }, 9240 .chained = true, 9241 .chain_id = ALC294_FIXUP_ASUS_GU502_VERBS 9242 }, 9243 [ALC294_FIXUP_ASUS_GU502_VERBS] = { 9244 .type = HDA_FIXUP_VERBS, 9245 .v.verbs = (const struct hda_verb[]) { 9246 /* set 0x15 to HP-OUT ctrl */ 9247 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 9248 /* unmute the 0x15 amp */ 9249 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 }, 9250 /* set 0x1b to HP-OUT */ 9251 { 0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 9252 { } 9253 }, 9254 .chained = true, 9255 .chain_id = ALC294_FIXUP_ASUS_GU502_HP 9256 }, 9257 [ALC294_FIXUP_ASUS_GU502_HP] = { 9258 .type = HDA_FIXUP_FUNC, 9259 .v.func = alc294_fixup_gu502_hp, 9260 }, 9261 [ALC294_FIXUP_ASUS_G513_PINS] = { 9262 .type = HDA_FIXUP_PINS, 9263 .v.pins = (const struct hda_pintbl[]) { 9264 { 0x19, 0x03a11050 }, /* front HP mic */ 9265 { 0x1a, 0x03a11c30 }, /* rear external mic */ 9266 { 0x21, 0x03211420 }, /* front HP out */ 9267 { } 9268 }, 9269 }, 9270 [ALC285_FIXUP_ASUS_G533Z_PINS] = { 9271 .type = HDA_FIXUP_PINS, 9272 .v.pins = (const struct hda_pintbl[]) { 9273 { 0x14, 0x90170152 }, /* Speaker Surround Playback Switch */ 9274 { 0x19, 0x03a19020 }, /* Mic Boost Volume */ 9275 { 0x1a, 0x03a11c30 }, /* Mic Boost Volume */ 9276 { 0x1e, 0x90170151 }, /* Rear jack, IN OUT EAPD Detect */ 9277 { 0x21, 0x03211420 }, 9278 { } 9279 }, 9280 }, 9281 [ALC294_FIXUP_ASUS_COEF_1B] = { 9282 .type = HDA_FIXUP_VERBS, 9283 .v.verbs = (const struct hda_verb[]) { 9284 /* Set bit 10 to correct noisy output after reboot from 9285 * Windows 10 (due to pop noise reduction?) 9286 */ 9287 { 0x20, AC_VERB_SET_COEF_INDEX, 0x1b }, 9288 { 0x20, AC_VERB_SET_PROC_COEF, 0x4e4b }, 9289 { } 9290 }, 9291 .chained = true, 9292 .chain_id = ALC289_FIXUP_ASUS_GA401, 9293 }, 9294 [ALC285_FIXUP_HP_GPIO_LED] = { 9295 .type = HDA_FIXUP_FUNC, 9296 .v.func = alc285_fixup_hp_gpio_led, 9297 }, 9298 [ALC285_FIXUP_HP_MUTE_LED] = { 9299 .type = HDA_FIXUP_FUNC, 9300 .v.func = alc285_fixup_hp_mute_led, 9301 }, 9302 [ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED] = { 9303 .type = HDA_FIXUP_FUNC, 9304 .v.func = alc285_fixup_hp_spectre_x360_mute_led, 9305 }, 9306 [ALC236_FIXUP_HP_MUTE_LED_COEFBIT2] = { 9307 .type = HDA_FIXUP_FUNC, 9308 .v.func = alc236_fixup_hp_mute_led_coefbit2, 9309 }, 9310 [ALC236_FIXUP_HP_GPIO_LED] = { 9311 .type = HDA_FIXUP_FUNC, 9312 .v.func = alc236_fixup_hp_gpio_led, 9313 }, 9314 [ALC236_FIXUP_HP_MUTE_LED] = { 9315 .type = HDA_FIXUP_FUNC, 9316 .v.func = alc236_fixup_hp_mute_led, 9317 }, 9318 [ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF] = { 9319 .type = HDA_FIXUP_FUNC, 9320 .v.func = alc236_fixup_hp_mute_led_micmute_vref, 9321 }, 9322 [ALC236_FIXUP_LENOVO_INV_DMIC] = { 9323 .type = HDA_FIXUP_FUNC, 9324 .v.func = alc_fixup_inv_dmic, 9325 .chained = true, 9326 .chain_id = ALC283_FIXUP_INT_MIC, 9327 }, 9328 [ALC298_FIXUP_SAMSUNG_AMP] = { 9329 .type = HDA_FIXUP_FUNC, 9330 .v.func = alc298_fixup_samsung_amp, 9331 .chained = true, 9332 .chain_id = ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET 9333 }, 9334 [ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS] = { 9335 .type = HDA_FIXUP_FUNC, 9336 .v.func = alc298_fixup_samsung_amp_v2_2_amps 9337 }, 9338 [ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS] = { 9339 .type = HDA_FIXUP_FUNC, 9340 .v.func = alc298_fixup_samsung_amp_v2_4_amps 9341 }, 9342 [ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = { 9343 .type = HDA_FIXUP_VERBS, 9344 .v.verbs = (const struct hda_verb[]) { 9345 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc5 }, 9346 { } 9347 }, 9348 }, 9349 [ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = { 9350 .type = HDA_FIXUP_VERBS, 9351 .v.verbs = (const struct hda_verb[]) { 9352 { 0x20, AC_VERB_SET_COEF_INDEX, 0x08}, 9353 { 0x20, AC_VERB_SET_PROC_COEF, 0x2fcf}, 9354 { } 9355 }, 9356 }, 9357 [ALC295_FIXUP_ASUS_MIC_NO_PRESENCE] = { 9358 .type = HDA_FIXUP_PINS, 9359 .v.pins = (const struct hda_pintbl[]) { 9360 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 9361 { } 9362 }, 9363 .chained = true, 9364 .chain_id = ALC269_FIXUP_HEADSET_MODE 9365 }, 9366 [ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS] = { 9367 .type = HDA_FIXUP_PINS, 9368 .v.pins = (const struct hda_pintbl[]) { 9369 { 0x14, 0x90100120 }, /* use as internal speaker */ 9370 { 0x18, 0x02a111f0 }, /* use as headset mic, without its own jack detect */ 9371 { 0x1a, 0x01011020 }, /* use as line out */ 9372 { }, 9373 }, 9374 .chained = true, 9375 .chain_id = ALC269_FIXUP_HEADSET_MIC 9376 }, 9377 [ALC269VC_FIXUP_ACER_HEADSET_MIC] = { 9378 .type = HDA_FIXUP_PINS, 9379 .v.pins = (const struct hda_pintbl[]) { 9380 { 0x18, 0x02a11030 }, /* use as headset mic */ 9381 { } 9382 }, 9383 .chained = true, 9384 .chain_id = ALC269_FIXUP_HEADSET_MIC 9385 }, 9386 [ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE] = { 9387 .type = HDA_FIXUP_PINS, 9388 .v.pins = (const struct hda_pintbl[]) { 9389 { 0x18, 0x01a11130 }, /* use as headset mic, without its own jack detect */ 9390 { } 9391 }, 9392 .chained = true, 9393 .chain_id = ALC269_FIXUP_HEADSET_MIC 9394 }, 9395 [ALC289_FIXUP_ASUS_GA401] = { 9396 .type = HDA_FIXUP_FUNC, 9397 .v.func = alc289_fixup_asus_ga401, 9398 .chained = true, 9399 .chain_id = ALC289_FIXUP_ASUS_GA502, 9400 }, 9401 [ALC289_FIXUP_ASUS_GA502] = { 9402 .type = HDA_FIXUP_PINS, 9403 .v.pins = (const struct hda_pintbl[]) { 9404 { 0x19, 0x03a11020 }, /* headset mic with jack detect */ 9405 { } 9406 }, 9407 }, 9408 [ALC256_FIXUP_ACER_MIC_NO_PRESENCE] = { 9409 .type = HDA_FIXUP_PINS, 9410 .v.pins = (const struct hda_pintbl[]) { 9411 { 0x19, 0x02a11120 }, /* use as headset mic, without its own jack detect */ 9412 { } 9413 }, 9414 .chained = true, 9415 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 9416 }, 9417 [ALC285_FIXUP_HP_GPIO_AMP_INIT] = { 9418 .type = HDA_FIXUP_FUNC, 9419 .v.func = alc285_fixup_hp_gpio_amp_init, 9420 .chained = true, 9421 .chain_id = ALC285_FIXUP_HP_GPIO_LED 9422 }, 9423 [ALC269_FIXUP_CZC_B20] = { 9424 .type = HDA_FIXUP_PINS, 9425 .v.pins = (const struct hda_pintbl[]) { 9426 { 0x12, 0x411111f0 }, 9427 { 0x14, 0x90170110 }, /* speaker */ 9428 { 0x15, 0x032f1020 }, /* HP out */ 9429 { 0x17, 0x411111f0 }, 9430 { 0x18, 0x03ab1040 }, /* mic */ 9431 { 0x19, 0xb7a7013f }, 9432 { 0x1a, 0x0181305f }, 9433 { 0x1b, 0x411111f0 }, 9434 { 0x1d, 0x411111f0 }, 9435 { 0x1e, 0x411111f0 }, 9436 { } 9437 }, 9438 .chain_id = ALC269_FIXUP_DMIC, 9439 }, 9440 [ALC269_FIXUP_CZC_TMI] = { 9441 .type = HDA_FIXUP_PINS, 9442 .v.pins = (const struct hda_pintbl[]) { 9443 { 0x12, 0x4000c000 }, 9444 { 0x14, 0x90170110 }, /* speaker */ 9445 { 0x15, 0x0421401f }, /* HP out */ 9446 { 0x17, 0x411111f0 }, 9447 { 0x18, 0x04a19020 }, /* mic */ 9448 { 0x19, 0x411111f0 }, 9449 { 0x1a, 0x411111f0 }, 9450 { 0x1b, 0x411111f0 }, 9451 { 0x1d, 0x40448505 }, 9452 { 0x1e, 0x411111f0 }, 9453 { 0x20, 0x8000ffff }, 9454 { } 9455 }, 9456 .chain_id = ALC269_FIXUP_DMIC, 9457 }, 9458 [ALC269_FIXUP_CZC_L101] = { 9459 .type = HDA_FIXUP_PINS, 9460 .v.pins = (const struct hda_pintbl[]) { 9461 { 0x12, 0x40000000 }, 9462 { 0x14, 0x01014010 }, /* speaker */ 9463 { 0x15, 0x411111f0 }, /* HP out */ 9464 { 0x16, 0x411111f0 }, 9465 { 0x18, 0x01a19020 }, /* mic */ 9466 { 0x19, 0x02a19021 }, 9467 { 0x1a, 0x0181302f }, 9468 { 0x1b, 0x0221401f }, 9469 { 0x1c, 0x411111f0 }, 9470 { 0x1d, 0x4044c601 }, 9471 { 0x1e, 0x411111f0 }, 9472 { } 9473 }, 9474 .chain_id = ALC269_FIXUP_DMIC, 9475 }, 9476 [ALC269_FIXUP_LEMOTE_A1802] = { 9477 .type = HDA_FIXUP_PINS, 9478 .v.pins = (const struct hda_pintbl[]) { 9479 { 0x12, 0x40000000 }, 9480 { 0x14, 0x90170110 }, /* speaker */ 9481 { 0x17, 0x411111f0 }, 9482 { 0x18, 0x03a19040 }, /* mic1 */ 9483 { 0x19, 0x90a70130 }, /* mic2 */ 9484 { 0x1a, 0x411111f0 }, 9485 { 0x1b, 0x411111f0 }, 9486 { 0x1d, 0x40489d2d }, 9487 { 0x1e, 0x411111f0 }, 9488 { 0x20, 0x0003ffff }, 9489 { 0x21, 0x03214020 }, 9490 { } 9491 }, 9492 .chain_id = ALC269_FIXUP_DMIC, 9493 }, 9494 [ALC269_FIXUP_LEMOTE_A190X] = { 9495 .type = HDA_FIXUP_PINS, 9496 .v.pins = (const struct hda_pintbl[]) { 9497 { 0x14, 0x99130110 }, /* speaker */ 9498 { 0x15, 0x0121401f }, /* HP out */ 9499 { 0x18, 0x01a19c20 }, /* rear mic */ 9500 { 0x19, 0x99a3092f }, /* front mic */ 9501 { 0x1b, 0x0201401f }, /* front lineout */ 9502 { } 9503 }, 9504 .chain_id = ALC269_FIXUP_DMIC, 9505 }, 9506 [ALC256_FIXUP_INTEL_NUC8_RUGGED] = { 9507 .type = HDA_FIXUP_PINS, 9508 .v.pins = (const struct hda_pintbl[]) { 9509 { 0x1b, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 9510 { } 9511 }, 9512 .chained = true, 9513 .chain_id = ALC269_FIXUP_HEADSET_MODE 9514 }, 9515 [ALC256_FIXUP_INTEL_NUC10] = { 9516 .type = HDA_FIXUP_PINS, 9517 .v.pins = (const struct hda_pintbl[]) { 9518 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 9519 { } 9520 }, 9521 .chained = true, 9522 .chain_id = ALC269_FIXUP_HEADSET_MODE 9523 }, 9524 [ALC255_FIXUP_XIAOMI_HEADSET_MIC] = { 9525 .type = HDA_FIXUP_VERBS, 9526 .v.verbs = (const struct hda_verb[]) { 9527 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 }, 9528 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 }, 9529 { } 9530 }, 9531 .chained = true, 9532 .chain_id = ALC289_FIXUP_ASUS_GA502 9533 }, 9534 [ALC274_FIXUP_HP_MIC] = { 9535 .type = HDA_FIXUP_VERBS, 9536 .v.verbs = (const struct hda_verb[]) { 9537 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 }, 9538 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 }, 9539 { } 9540 }, 9541 }, 9542 [ALC274_FIXUP_HP_HEADSET_MIC] = { 9543 .type = HDA_FIXUP_FUNC, 9544 .v.func = alc274_fixup_hp_headset_mic, 9545 .chained = true, 9546 .chain_id = ALC274_FIXUP_HP_MIC 9547 }, 9548 [ALC274_FIXUP_HP_ENVY_GPIO] = { 9549 .type = HDA_FIXUP_FUNC, 9550 .v.func = alc274_fixup_hp_envy_gpio, 9551 }, 9552 [ALC274_FIXUP_ASUS_ZEN_AIO_27] = { 9553 .type = HDA_FIXUP_VERBS, 9554 .v.verbs = (const struct hda_verb[]) { 9555 { 0x20, AC_VERB_SET_COEF_INDEX, 0x10 }, 9556 { 0x20, AC_VERB_SET_PROC_COEF, 0xc420 }, 9557 { 0x20, AC_VERB_SET_COEF_INDEX, 0x40 }, 9558 { 0x20, AC_VERB_SET_PROC_COEF, 0x8800 }, 9559 { 0x20, AC_VERB_SET_COEF_INDEX, 0x49 }, 9560 { 0x20, AC_VERB_SET_PROC_COEF, 0x0249 }, 9561 { 0x20, AC_VERB_SET_COEF_INDEX, 0x4a }, 9562 { 0x20, AC_VERB_SET_PROC_COEF, 0x202b }, 9563 { 0x20, AC_VERB_SET_COEF_INDEX, 0x62 }, 9564 { 0x20, AC_VERB_SET_PROC_COEF, 0xa007 }, 9565 { 0x20, AC_VERB_SET_COEF_INDEX, 0x6b }, 9566 { 0x20, AC_VERB_SET_PROC_COEF, 0x5060 }, 9567 {} 9568 }, 9569 .chained = true, 9570 .chain_id = ALC2XX_FIXUP_HEADSET_MIC, 9571 }, 9572 [ALC256_FIXUP_ASUS_HPE] = { 9573 .type = HDA_FIXUP_VERBS, 9574 .v.verbs = (const struct hda_verb[]) { 9575 /* Set EAPD high */ 9576 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f }, 9577 { 0x20, AC_VERB_SET_PROC_COEF, 0x7778 }, 9578 { } 9579 }, 9580 .chained = true, 9581 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC 9582 }, 9583 [ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK] = { 9584 .type = HDA_FIXUP_FUNC, 9585 .v.func = alc_fixup_headset_jack, 9586 .chained = true, 9587 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 9588 }, 9589 [ALC287_FIXUP_HP_GPIO_LED] = { 9590 .type = HDA_FIXUP_FUNC, 9591 .v.func = alc287_fixup_hp_gpio_led, 9592 }, 9593 [ALC256_FIXUP_HP_HEADSET_MIC] = { 9594 .type = HDA_FIXUP_FUNC, 9595 .v.func = alc274_fixup_hp_headset_mic, 9596 }, 9597 [ALC236_FIXUP_DELL_AIO_HEADSET_MIC] = { 9598 .type = HDA_FIXUP_FUNC, 9599 .v.func = alc_fixup_no_int_mic, 9600 .chained = true, 9601 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE 9602 }, 9603 [ALC282_FIXUP_ACER_DISABLE_LINEOUT] = { 9604 .type = HDA_FIXUP_PINS, 9605 .v.pins = (const struct hda_pintbl[]) { 9606 { 0x1b, 0x411111f0 }, 9607 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 9608 { }, 9609 }, 9610 .chained = true, 9611 .chain_id = ALC269_FIXUP_HEADSET_MODE 9612 }, 9613 [ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST] = { 9614 .type = HDA_FIXUP_FUNC, 9615 .v.func = alc269_fixup_limit_int_mic_boost, 9616 .chained = true, 9617 .chain_id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, 9618 }, 9619 [ALC256_FIXUP_ACER_HEADSET_MIC] = { 9620 .type = HDA_FIXUP_PINS, 9621 .v.pins = (const struct hda_pintbl[]) { 9622 { 0x19, 0x02a1113c }, /* use as headset mic, without its own jack detect */ 9623 { 0x1a, 0x90a1092f }, /* use as internal mic */ 9624 { } 9625 }, 9626 .chained = true, 9627 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 9628 }, 9629 [ALC285_FIXUP_IDEAPAD_S740_COEF] = { 9630 .type = HDA_FIXUP_FUNC, 9631 .v.func = alc285_fixup_ideapad_s740_coef, 9632 .chained = true, 9633 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 9634 }, 9635 [ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST] = { 9636 .type = HDA_FIXUP_FUNC, 9637 .v.func = alc269_fixup_limit_int_mic_boost, 9638 .chained = true, 9639 .chain_id = ALC285_FIXUP_HP_MUTE_LED, 9640 }, 9641 [ALC295_FIXUP_ASUS_DACS] = { 9642 .type = HDA_FIXUP_FUNC, 9643 .v.func = alc295_fixup_asus_dacs, 9644 }, 9645 [ALC295_FIXUP_HP_OMEN] = { 9646 .type = HDA_FIXUP_PINS, 9647 .v.pins = (const struct hda_pintbl[]) { 9648 { 0x12, 0xb7a60130 }, 9649 { 0x13, 0x40000000 }, 9650 { 0x14, 0x411111f0 }, 9651 { 0x16, 0x411111f0 }, 9652 { 0x17, 0x90170110 }, 9653 { 0x18, 0x411111f0 }, 9654 { 0x19, 0x02a11030 }, 9655 { 0x1a, 0x411111f0 }, 9656 { 0x1b, 0x04a19030 }, 9657 { 0x1d, 0x40600001 }, 9658 { 0x1e, 0x411111f0 }, 9659 { 0x21, 0x03211020 }, 9660 {} 9661 }, 9662 .chained = true, 9663 .chain_id = ALC269_FIXUP_HP_LINE1_MIC1_LED, 9664 }, 9665 [ALC285_FIXUP_HP_SPECTRE_X360] = { 9666 .type = HDA_FIXUP_FUNC, 9667 .v.func = alc285_fixup_hp_spectre_x360, 9668 }, 9669 [ALC285_FIXUP_HP_SPECTRE_X360_EB1] = { 9670 .type = HDA_FIXUP_FUNC, 9671 .v.func = alc285_fixup_hp_spectre_x360_eb1 9672 }, 9673 [ALC285_FIXUP_HP_ENVY_X360] = { 9674 .type = HDA_FIXUP_FUNC, 9675 .v.func = alc285_fixup_hp_envy_x360, 9676 .chained = true, 9677 .chain_id = ALC285_FIXUP_HP_GPIO_AMP_INIT, 9678 }, 9679 [ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP] = { 9680 .type = HDA_FIXUP_FUNC, 9681 .v.func = alc285_fixup_ideapad_s740_coef, 9682 .chained = true, 9683 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK, 9684 }, 9685 [ALC623_FIXUP_LENOVO_THINKSTATION_P340] = { 9686 .type = HDA_FIXUP_FUNC, 9687 .v.func = alc_fixup_no_shutup, 9688 .chained = true, 9689 .chain_id = ALC283_FIXUP_HEADSET_MIC, 9690 }, 9691 [ALC255_FIXUP_ACER_HEADPHONE_AND_MIC] = { 9692 .type = HDA_FIXUP_PINS, 9693 .v.pins = (const struct hda_pintbl[]) { 9694 { 0x21, 0x03211030 }, /* Change the Headphone location to Left */ 9695 { } 9696 }, 9697 .chained = true, 9698 .chain_id = ALC255_FIXUP_XIAOMI_HEADSET_MIC 9699 }, 9700 [ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST] = { 9701 .type = HDA_FIXUP_FUNC, 9702 .v.func = alc269_fixup_limit_int_mic_boost, 9703 .chained = true, 9704 .chain_id = ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF, 9705 }, 9706 [ALC285_FIXUP_LEGION_Y9000X_SPEAKERS] = { 9707 .type = HDA_FIXUP_FUNC, 9708 .v.func = alc285_fixup_ideapad_s740_coef, 9709 .chained = true, 9710 .chain_id = ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE, 9711 }, 9712 [ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE] = { 9713 .type = HDA_FIXUP_FUNC, 9714 .v.func = alc287_fixup_legion_15imhg05_speakers, 9715 .chained = true, 9716 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 9717 }, 9718 [ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS] = { 9719 .type = HDA_FIXUP_VERBS, 9720 //.v.verbs = legion_15imhg05_coefs, 9721 .v.verbs = (const struct hda_verb[]) { 9722 // set left speaker Legion 7i. 9723 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 9724 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 }, 9725 9726 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9727 { 0x20, AC_VERB_SET_PROC_COEF, 0xc }, 9728 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9729 { 0x20, AC_VERB_SET_PROC_COEF, 0x1a }, 9730 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9731 9732 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9733 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 9734 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9735 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9736 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9737 9738 // set right speaker Legion 7i. 9739 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 9740 { 0x20, AC_VERB_SET_PROC_COEF, 0x42 }, 9741 9742 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9743 { 0x20, AC_VERB_SET_PROC_COEF, 0xc }, 9744 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9745 { 0x20, AC_VERB_SET_PROC_COEF, 0x2a }, 9746 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9747 9748 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9749 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 9750 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9751 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9752 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9753 {} 9754 }, 9755 .chained = true, 9756 .chain_id = ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE, 9757 }, 9758 [ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE] = { 9759 .type = HDA_FIXUP_FUNC, 9760 .v.func = alc287_fixup_legion_15imhg05_speakers, 9761 .chained = true, 9762 .chain_id = ALC269_FIXUP_HEADSET_MODE, 9763 }, 9764 [ALC287_FIXUP_YOGA7_14ITL_SPEAKERS] = { 9765 .type = HDA_FIXUP_VERBS, 9766 .v.verbs = (const struct hda_verb[]) { 9767 // set left speaker Yoga 7i. 9768 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 9769 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 }, 9770 9771 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9772 { 0x20, AC_VERB_SET_PROC_COEF, 0xc }, 9773 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9774 { 0x20, AC_VERB_SET_PROC_COEF, 0x1a }, 9775 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9776 9777 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9778 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 9779 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9780 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9781 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9782 9783 // set right speaker Yoga 7i. 9784 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 9785 { 0x20, AC_VERB_SET_PROC_COEF, 0x46 }, 9786 9787 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9788 { 0x20, AC_VERB_SET_PROC_COEF, 0xc }, 9789 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9790 { 0x20, AC_VERB_SET_PROC_COEF, 0x2a }, 9791 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9792 9793 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9794 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 9795 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9796 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9797 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9798 {} 9799 }, 9800 .chained = true, 9801 .chain_id = ALC269_FIXUP_HEADSET_MODE, 9802 }, 9803 [ALC298_FIXUP_LENOVO_C940_DUET7] = { 9804 .type = HDA_FIXUP_FUNC, 9805 .v.func = alc298_fixup_lenovo_c940_duet7, 9806 }, 9807 [ALC287_FIXUP_13S_GEN2_SPEAKERS] = { 9808 .type = HDA_FIXUP_VERBS, 9809 .v.verbs = (const struct hda_verb[]) { 9810 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 9811 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 }, 9812 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9813 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 9814 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9815 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9816 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9817 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 9818 { 0x20, AC_VERB_SET_PROC_COEF, 0x42 }, 9819 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9820 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 9821 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9822 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9823 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9824 {} 9825 }, 9826 .chained = true, 9827 .chain_id = ALC269_FIXUP_HEADSET_MODE, 9828 }, 9829 [ALC256_FIXUP_SET_COEF_DEFAULTS] = { 9830 .type = HDA_FIXUP_FUNC, 9831 .v.func = alc256_fixup_set_coef_defaults, 9832 }, 9833 [ALC245_FIXUP_HP_GPIO_LED] = { 9834 .type = HDA_FIXUP_FUNC, 9835 .v.func = alc245_fixup_hp_gpio_led, 9836 }, 9837 [ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = { 9838 .type = HDA_FIXUP_PINS, 9839 .v.pins = (const struct hda_pintbl[]) { 9840 { 0x19, 0x03a11120 }, /* use as headset mic, without its own jack detect */ 9841 { } 9842 }, 9843 .chained = true, 9844 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, 9845 }, 9846 [ALC233_FIXUP_NO_AUDIO_JACK] = { 9847 .type = HDA_FIXUP_FUNC, 9848 .v.func = alc233_fixup_no_audio_jack, 9849 }, 9850 [ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME] = { 9851 .type = HDA_FIXUP_FUNC, 9852 .v.func = alc256_fixup_mic_no_presence_and_resume, 9853 .chained = true, 9854 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 9855 }, 9856 [ALC287_FIXUP_LEGION_16ACHG6] = { 9857 .type = HDA_FIXUP_FUNC, 9858 .v.func = alc287_fixup_legion_16achg6_speakers, 9859 }, 9860 [ALC287_FIXUP_CS35L41_I2C_2] = { 9861 .type = HDA_FIXUP_FUNC, 9862 .v.func = cs35l41_fixup_i2c_two, 9863 }, 9864 [ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED] = { 9865 .type = HDA_FIXUP_FUNC, 9866 .v.func = cs35l41_fixup_i2c_two, 9867 .chained = true, 9868 .chain_id = ALC285_FIXUP_HP_MUTE_LED, 9869 }, 9870 [ALC287_FIXUP_CS35L41_I2C_4] = { 9871 .type = HDA_FIXUP_FUNC, 9872 .v.func = cs35l41_fixup_i2c_four, 9873 }, 9874 [ALC245_FIXUP_CS35L41_SPI_2] = { 9875 .type = HDA_FIXUP_FUNC, 9876 .v.func = cs35l41_fixup_spi_two, 9877 }, 9878 [ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED] = { 9879 .type = HDA_FIXUP_FUNC, 9880 .v.func = cs35l41_fixup_spi_two, 9881 .chained = true, 9882 .chain_id = ALC285_FIXUP_HP_GPIO_LED, 9883 }, 9884 [ALC245_FIXUP_CS35L41_SPI_4] = { 9885 .type = HDA_FIXUP_FUNC, 9886 .v.func = cs35l41_fixup_spi_four, 9887 }, 9888 [ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED] = { 9889 .type = HDA_FIXUP_FUNC, 9890 .v.func = cs35l41_fixup_spi_four, 9891 .chained = true, 9892 .chain_id = ALC285_FIXUP_HP_GPIO_LED, 9893 }, 9894 [ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED] = { 9895 .type = HDA_FIXUP_VERBS, 9896 .v.verbs = (const struct hda_verb[]) { 9897 { 0x20, AC_VERB_SET_COEF_INDEX, 0x19 }, 9898 { 0x20, AC_VERB_SET_PROC_COEF, 0x8e11 }, 9899 { } 9900 }, 9901 .chained = true, 9902 .chain_id = ALC285_FIXUP_HP_MUTE_LED, 9903 }, 9904 [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET] = { 9905 .type = HDA_FIXUP_FUNC, 9906 .v.func = alc_fixup_dell4_mic_no_presence_quiet, 9907 .chained = true, 9908 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 9909 }, 9910 [ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE] = { 9911 .type = HDA_FIXUP_PINS, 9912 .v.pins = (const struct hda_pintbl[]) { 9913 { 0x19, 0x02a1112c }, /* use as headset mic, without its own jack detect */ 9914 { } 9915 }, 9916 .chained = true, 9917 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 9918 }, 9919 [ALC287_FIXUP_LEGION_16ITHG6] = { 9920 .type = HDA_FIXUP_FUNC, 9921 .v.func = alc287_fixup_legion_16ithg6_speakers, 9922 }, 9923 [ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK] = { 9924 .type = HDA_FIXUP_VERBS, 9925 .v.verbs = (const struct hda_verb[]) { 9926 // enable left speaker 9927 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 9928 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 }, 9929 9930 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9931 { 0x20, AC_VERB_SET_PROC_COEF, 0xc }, 9932 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9933 { 0x20, AC_VERB_SET_PROC_COEF, 0x1a }, 9934 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9935 9936 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9937 { 0x20, AC_VERB_SET_PROC_COEF, 0xf }, 9938 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9939 { 0x20, AC_VERB_SET_PROC_COEF, 0x42 }, 9940 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9941 9942 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9943 { 0x20, AC_VERB_SET_PROC_COEF, 0x10 }, 9944 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9945 { 0x20, AC_VERB_SET_PROC_COEF, 0x40 }, 9946 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9947 9948 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9949 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 9950 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9951 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9952 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9953 9954 // enable right speaker 9955 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 9956 { 0x20, AC_VERB_SET_PROC_COEF, 0x46 }, 9957 9958 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9959 { 0x20, AC_VERB_SET_PROC_COEF, 0xc }, 9960 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9961 { 0x20, AC_VERB_SET_PROC_COEF, 0x2a }, 9962 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9963 9964 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9965 { 0x20, AC_VERB_SET_PROC_COEF, 0xf }, 9966 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9967 { 0x20, AC_VERB_SET_PROC_COEF, 0x46 }, 9968 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9969 9970 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9971 { 0x20, AC_VERB_SET_PROC_COEF, 0x10 }, 9972 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9973 { 0x20, AC_VERB_SET_PROC_COEF, 0x44 }, 9974 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9975 9976 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 9977 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 9978 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9979 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 9980 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 9981 9982 { }, 9983 }, 9984 }, 9985 [ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN] = { 9986 .type = HDA_FIXUP_FUNC, 9987 .v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin, 9988 .chained = true, 9989 .chain_id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK, 9990 }, 9991 [ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN] = { 9992 .type = HDA_FIXUP_FUNC, 9993 .v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin, 9994 .chained = true, 9995 .chain_id = ALC287_FIXUP_CS35L41_I2C_2, 9996 }, 9997 [ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS] = { 9998 .type = HDA_FIXUP_FUNC, 9999 .v.func = alc295_fixup_dell_inspiron_top_speakers, 10000 .chained = true, 10001 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 10002 }, 10003 [ALC236_FIXUP_DELL_DUAL_CODECS] = { 10004 .type = HDA_FIXUP_PINS, 10005 .v.func = alc1220_fixup_gb_dual_codecs, 10006 .chained = true, 10007 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 10008 }, 10009 [ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI] = { 10010 .type = HDA_FIXUP_FUNC, 10011 .v.func = cs35l41_fixup_i2c_two, 10012 .chained = true, 10013 .chain_id = ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK, 10014 }, 10015 [ALC287_FIXUP_TAS2781_I2C] = { 10016 .type = HDA_FIXUP_FUNC, 10017 .v.func = tas2781_fixup_i2c, 10018 .chained = true, 10019 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK, 10020 }, 10021 [ALC245_FIXUP_TAS2781_SPI_2] = { 10022 .type = HDA_FIXUP_FUNC, 10023 .v.func = tas2781_fixup_spi, 10024 .chained = true, 10025 .chain_id = ALC285_FIXUP_HP_GPIO_LED, 10026 }, 10027 [ALC287_FIXUP_YOGA7_14ARB7_I2C] = { 10028 .type = HDA_FIXUP_FUNC, 10029 .v.func = yoga7_14arb7_fixup_i2c, 10030 .chained = true, 10031 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK, 10032 }, 10033 [ALC245_FIXUP_HP_MUTE_LED_COEFBIT] = { 10034 .type = HDA_FIXUP_FUNC, 10035 .v.func = alc245_fixup_hp_mute_led_coefbit, 10036 }, 10037 [ALC245_FIXUP_HP_X360_MUTE_LEDS] = { 10038 .type = HDA_FIXUP_FUNC, 10039 .v.func = alc245_fixup_hp_mute_led_coefbit, 10040 .chained = true, 10041 .chain_id = ALC245_FIXUP_HP_GPIO_LED 10042 }, 10043 [ALC287_FIXUP_THINKPAD_I2S_SPK] = { 10044 .type = HDA_FIXUP_FUNC, 10045 .v.func = alc287_fixup_bind_dacs, 10046 .chained = true, 10047 .chain_id = ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK, 10048 }, 10049 [ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD] = { 10050 .type = HDA_FIXUP_FUNC, 10051 .v.func = alc287_fixup_bind_dacs, 10052 .chained = true, 10053 .chain_id = ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI, 10054 }, 10055 [ALC2XX_FIXUP_HEADSET_MIC] = { 10056 .type = HDA_FIXUP_FUNC, 10057 .v.func = alc_fixup_headset_mic, 10058 }, 10059 [ALC289_FIXUP_DELL_CS35L41_SPI_2] = { 10060 .type = HDA_FIXUP_FUNC, 10061 .v.func = cs35l41_fixup_spi_two, 10062 .chained = true, 10063 .chain_id = ALC289_FIXUP_DUAL_SPK 10064 }, 10065 [ALC294_FIXUP_CS35L41_I2C_2] = { 10066 .type = HDA_FIXUP_FUNC, 10067 .v.func = cs35l41_fixup_i2c_two, 10068 }, 10069 [ALC256_FIXUP_ACER_SFG16_MICMUTE_LED] = { 10070 .type = HDA_FIXUP_FUNC, 10071 .v.func = alc256_fixup_acer_sfg16_micmute_led, 10072 }, 10073 [ALC256_FIXUP_HEADPHONE_AMP_VOL] = { 10074 .type = HDA_FIXUP_FUNC, 10075 .v.func = alc256_decrease_headphone_amp_val, 10076 }, 10077 [ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX] = { 10078 .type = HDA_FIXUP_FUNC, 10079 .v.func = alc245_fixup_hp_spectre_x360_eu0xxx, 10080 }, 10081 [ALC245_FIXUP_HP_SPECTRE_X360_16_AA0XXX] = { 10082 .type = HDA_FIXUP_FUNC, 10083 .v.func = alc245_fixup_hp_spectre_x360_16_aa0xxx, 10084 }, 10085 [ALC285_FIXUP_ASUS_GA403U] = { 10086 .type = HDA_FIXUP_FUNC, 10087 .v.func = alc285_fixup_asus_ga403u, 10088 }, 10089 [ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC] = { 10090 .type = HDA_FIXUP_PINS, 10091 .v.pins = (const struct hda_pintbl[]) { 10092 { 0x19, 0x03a11050 }, 10093 { 0x1b, 0x03a11c30 }, 10094 { } 10095 }, 10096 .chained = true, 10097 .chain_id = ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1 10098 }, 10099 [ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1] = { 10100 .type = HDA_FIXUP_FUNC, 10101 .v.func = alc285_fixup_speaker2_to_dac1, 10102 .chained = true, 10103 .chain_id = ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC, 10104 }, 10105 [ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC] = { 10106 .type = HDA_FIXUP_PINS, 10107 .v.pins = (const struct hda_pintbl[]) { 10108 { 0x19, 0x03a11050 }, 10109 { 0x1b, 0x03a11c30 }, 10110 { } 10111 }, 10112 }, 10113 [ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1] = { 10114 .type = HDA_FIXUP_FUNC, 10115 .v.func = alc285_fixup_speaker2_to_dac1, 10116 .chained = true, 10117 .chain_id = ALC285_FIXUP_ASUS_GA403U, 10118 }, 10119 [ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318] = { 10120 .type = HDA_FIXUP_FUNC, 10121 .v.func = alc287_fixup_lenovo_thinkpad_with_alc1318, 10122 .chained = true, 10123 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 10124 }, 10125 [ALC256_FIXUP_CHROME_BOOK] = { 10126 .type = HDA_FIXUP_FUNC, 10127 .v.func = alc256_fixup_chromebook, 10128 .chained = true, 10129 .chain_id = ALC225_FIXUP_HEADSET_JACK 10130 }, 10131 [ALC245_FIXUP_CLEVO_NOISY_MIC] = { 10132 .type = HDA_FIXUP_FUNC, 10133 .v.func = alc269_fixup_limit_int_mic_boost, 10134 .chained = true, 10135 .chain_id = ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE, 10136 }, 10137 [ALC269_FIXUP_VAIO_VJFH52_MIC_NO_PRESENCE] = { 10138 .type = HDA_FIXUP_PINS, 10139 .v.pins = (const struct hda_pintbl[]) { 10140 { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */ 10141 { 0x1b, 0x20a11040 }, /* dock mic */ 10142 { } 10143 }, 10144 .chained = true, 10145 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST 10146 }, 10147 [ALC233_FIXUP_MEDION_MTL_SPK] = { 10148 .type = HDA_FIXUP_PINS, 10149 .v.pins = (const struct hda_pintbl[]) { 10150 { 0x1b, 0x90170110 }, 10151 { } 10152 }, 10153 }, 10154 [ALC294_FIXUP_BASS_SPEAKER_15] = { 10155 .type = HDA_FIXUP_FUNC, 10156 .v.func = alc294_fixup_bass_speaker_15, 10157 }, 10158 [ALC283_FIXUP_DELL_HP_RESUME] = { 10159 .type = HDA_FIXUP_FUNC, 10160 .v.func = alc283_fixup_dell_hp_resume, 10161 }, 10162 }; 10163 10164 static const struct hda_quirk alc269_fixup_tbl[] = { 10165 SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC), 10166 SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC), 10167 SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC), 10168 SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700), 10169 SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC), 10170 SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK), 10171 SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK), 10172 SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572), 10173 SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572), 10174 SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS), 10175 SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC), 10176 SND_PCI_QUIRK(0x1025, 0x0840, "Acer Aspire E1", ALC269VB_FIXUP_ASPIRE_E1_COEF), 10177 SND_PCI_QUIRK(0x1025, 0x100c, "Acer Aspire E5-574G", ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST), 10178 SND_PCI_QUIRK(0x1025, 0x101c, "Acer Veriton N2510G", ALC269_FIXUP_LIFEBOOK), 10179 SND_PCI_QUIRK(0x1025, 0x102b, "Acer Aspire C24-860", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE), 10180 SND_PCI_QUIRK(0x1025, 0x1065, "Acer Aspire C20-820", ALC269VC_FIXUP_ACER_HEADSET_MIC), 10181 SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK), 10182 SND_PCI_QUIRK(0x1025, 0x1094, "Acer Aspire E5-575T", ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST), 10183 SND_PCI_QUIRK(0x1025, 0x1099, "Acer Aspire E5-523G", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 10184 SND_PCI_QUIRK(0x1025, 0x110e, "Acer Aspire ES1-432", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 10185 SND_PCI_QUIRK(0x1025, 0x1166, "Acer Veriton N4640G", ALC269_FIXUP_LIFEBOOK), 10186 SND_PCI_QUIRK(0x1025, 0x1167, "Acer Veriton N6640G", ALC269_FIXUP_LIFEBOOK), 10187 SND_PCI_QUIRK(0x1025, 0x1177, "Acer Predator G9-593", ALC255_FIXUP_PREDATOR_SUBWOOFER), 10188 SND_PCI_QUIRK(0x1025, 0x1178, "Acer Predator G9-593", ALC255_FIXUP_PREDATOR_SUBWOOFER), 10189 SND_PCI_QUIRK(0x1025, 0x1246, "Acer Predator Helios 500", ALC299_FIXUP_PREDATOR_SPK), 10190 SND_PCI_QUIRK(0x1025, 0x1247, "Acer vCopperbox", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS), 10191 SND_PCI_QUIRK(0x1025, 0x1248, "Acer Veriton N4660G", ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE), 10192 SND_PCI_QUIRK(0x1025, 0x1269, "Acer SWIFT SF314-54", ALC256_FIXUP_ACER_HEADSET_MIC), 10193 SND_PCI_QUIRK(0x1025, 0x126a, "Acer Swift SF114-32", ALC256_FIXUP_ACER_MIC_NO_PRESENCE), 10194 SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), 10195 SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), 10196 SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), 10197 SND_PCI_QUIRK(0x1025, 0x129c, "Acer SWIFT SF314-55", ALC256_FIXUP_ACER_HEADSET_MIC), 10198 SND_PCI_QUIRK(0x1025, 0x129d, "Acer SWIFT SF313-51", ALC256_FIXUP_ACER_MIC_NO_PRESENCE), 10199 SND_PCI_QUIRK(0x1025, 0x1300, "Acer SWIFT SF314-56", ALC256_FIXUP_ACER_MIC_NO_PRESENCE), 10200 SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), 10201 SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC), 10202 SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC), 10203 SND_PCI_QUIRK(0x1025, 0x1360, "Acer Aspire A115", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 10204 SND_PCI_QUIRK(0x1025, 0x141f, "Acer Spin SP513-54N", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 10205 SND_PCI_QUIRK(0x1025, 0x142b, "Acer Swift SF314-42", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 10206 SND_PCI_QUIRK(0x1025, 0x1430, "Acer TravelMate B311R-31", ALC256_FIXUP_ACER_MIC_NO_PRESENCE), 10207 SND_PCI_QUIRK(0x1025, 0x1466, "Acer Aspire A515-56", ALC255_FIXUP_ACER_HEADPHONE_AND_MIC), 10208 SND_PCI_QUIRK(0x1025, 0x1534, "Acer Predator PH315-54", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 10209 SND_PCI_QUIRK(0x1025, 0x159c, "Acer Nitro 5 AN515-58", ALC2XX_FIXUP_HEADSET_MIC), 10210 SND_PCI_QUIRK(0x1025, 0x169a, "Acer Swift SFG16", ALC256_FIXUP_ACER_SFG16_MICMUTE_LED), 10211 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z), 10212 SND_PCI_QUIRK(0x1028, 0x053c, "Dell Latitude E5430", ALC292_FIXUP_DELL_E7X), 10213 SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS), 10214 SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X), 10215 SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X), 10216 SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X), 10217 SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X), 10218 SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER), 10219 SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE), 10220 SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE), 10221 SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE), 10222 SND_PCI_QUIRK(0x1028, 0x0604, "Dell Venue 11 Pro 7130", ALC283_FIXUP_DELL_HP_RESUME), 10223 SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK), 10224 SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK), 10225 SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X), 10226 SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X), 10227 SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK), 10228 SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 10229 SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 10230 SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13), 10231 SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE), 10232 SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK), 10233 SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE), 10234 SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 10235 SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 10236 SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 10237 SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 10238 SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 10239 SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 10240 SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 10241 SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER), 10242 SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE), 10243 SND_PCI_QUIRK(0x1028, 0x0738, "Dell Precision 5820", ALC269_FIXUP_NO_SHUTUP), 10244 SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME), 10245 SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME), 10246 SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER), 10247 SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3), 10248 SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE), 10249 SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB), 10250 SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB), 10251 SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC), 10252 SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC), 10253 SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB), 10254 SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE), 10255 SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE), 10256 SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB), 10257 SND_PCI_QUIRK(0x1028, 0x097d, "Dell Precision", ALC289_FIXUP_DUAL_SPK), 10258 SND_PCI_QUIRK(0x1028, 0x097e, "Dell Precision", ALC289_FIXUP_DUAL_SPK), 10259 SND_PCI_QUIRK(0x1028, 0x098d, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE), 10260 SND_PCI_QUIRK(0x1028, 0x09bf, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE), 10261 SND_PCI_QUIRK(0x1028, 0x0a2e, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC), 10262 SND_PCI_QUIRK(0x1028, 0x0a30, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC), 10263 SND_PCI_QUIRK(0x1028, 0x0a38, "Dell Latitude 7520", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET), 10264 SND_PCI_QUIRK(0x1028, 0x0a58, "Dell", ALC255_FIXUP_DELL_HEADSET_MIC), 10265 SND_PCI_QUIRK(0x1028, 0x0a61, "Dell XPS 15 9510", ALC289_FIXUP_DUAL_SPK), 10266 SND_PCI_QUIRK(0x1028, 0x0a62, "Dell Precision 5560", ALC289_FIXUP_DUAL_SPK), 10267 SND_PCI_QUIRK(0x1028, 0x0a9d, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE), 10268 SND_PCI_QUIRK(0x1028, 0x0a9e, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE), 10269 SND_PCI_QUIRK(0x1028, 0x0b19, "Dell XPS 15 9520", ALC289_FIXUP_DUAL_SPK), 10270 SND_PCI_QUIRK(0x1028, 0x0b1a, "Dell Precision 5570", ALC289_FIXUP_DUAL_SPK), 10271 SND_PCI_QUIRK(0x1028, 0x0b27, "Dell", ALC245_FIXUP_CS35L41_SPI_2), 10272 SND_PCI_QUIRK(0x1028, 0x0b28, "Dell", ALC245_FIXUP_CS35L41_SPI_2), 10273 SND_PCI_QUIRK(0x1028, 0x0b37, "Dell Inspiron 16 Plus 7620 2-in-1", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS), 10274 SND_PCI_QUIRK(0x1028, 0x0b71, "Dell Inspiron 16 Plus 7620", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS), 10275 SND_PCI_QUIRK(0x1028, 0x0beb, "Dell XPS 15 9530 (2023)", ALC289_FIXUP_DELL_CS35L41_SPI_2), 10276 SND_PCI_QUIRK(0x1028, 0x0c03, "Dell Precision 5340", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE), 10277 SND_PCI_QUIRK(0x1028, 0x0c0b, "Dell Oasis 14 RPL-P", ALC289_FIXUP_RTK_AMP_DUAL_SPK), 10278 SND_PCI_QUIRK(0x1028, 0x0c0d, "Dell Oasis", ALC289_FIXUP_RTK_AMP_DUAL_SPK), 10279 SND_PCI_QUIRK(0x1028, 0x0c0e, "Dell Oasis 16", ALC289_FIXUP_RTK_AMP_DUAL_SPK), 10280 SND_PCI_QUIRK(0x1028, 0x0c19, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS), 10281 SND_PCI_QUIRK(0x1028, 0x0c1a, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS), 10282 SND_PCI_QUIRK(0x1028, 0x0c1b, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS), 10283 SND_PCI_QUIRK(0x1028, 0x0c1c, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS), 10284 SND_PCI_QUIRK(0x1028, 0x0c1d, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS), 10285 SND_PCI_QUIRK(0x1028, 0x0c1e, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS), 10286 SND_PCI_QUIRK(0x1028, 0x0c28, "Dell Inspiron 16 Plus 7630", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS), 10287 SND_PCI_QUIRK(0x1028, 0x0c4d, "Dell", ALC287_FIXUP_CS35L41_I2C_4), 10288 SND_PCI_QUIRK(0x1028, 0x0c94, "Dell Polaris 3 metal", ALC287_FIXUP_TAS2781_I2C), 10289 SND_PCI_QUIRK(0x1028, 0x0c96, "Dell Polaris 2in1", ALC287_FIXUP_TAS2781_I2C), 10290 SND_PCI_QUIRK(0x1028, 0x0cbd, "Dell Oasis 13 CS MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2), 10291 SND_PCI_QUIRK(0x1028, 0x0cbe, "Dell Oasis 13 2-IN-1 MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2), 10292 SND_PCI_QUIRK(0x1028, 0x0cbf, "Dell Oasis 13 Low Weight MTU-L", ALC289_FIXUP_DELL_CS35L41_SPI_2), 10293 SND_PCI_QUIRK(0x1028, 0x0cc0, "Dell Oasis 13", ALC289_FIXUP_RTK_AMP_DUAL_SPK), 10294 SND_PCI_QUIRK(0x1028, 0x0cc1, "Dell Oasis 14 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2), 10295 SND_PCI_QUIRK(0x1028, 0x0cc2, "Dell Oasis 14 2-in-1 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2), 10296 SND_PCI_QUIRK(0x1028, 0x0cc3, "Dell Oasis 14 Low Weight MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2), 10297 SND_PCI_QUIRK(0x1028, 0x0cc4, "Dell Oasis 16 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2), 10298 SND_PCI_QUIRK(0x1028, 0x0cc5, "Dell Oasis 14", ALC289_FIXUP_RTK_AMP_DUAL_SPK), 10299 SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 10300 SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 10301 SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2), 10302 SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED), 10303 SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED), 10304 SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10305 SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10306 SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10307 SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10308 SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC), 10309 SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10310 SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10311 SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 10312 SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 10313 SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 10314 SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 10315 SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 10316 SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10317 SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10318 SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10319 SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10320 SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10321 SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10322 SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED), 10323 SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY), 10324 SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10325 SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10326 SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10327 SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10328 SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10329 SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10330 SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10331 SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10332 SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED), 10333 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10334 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS), 10335 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10336 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS), 10337 SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10338 SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10339 SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10340 SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10341 SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10342 SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10343 SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10344 SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10345 SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10346 SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10347 SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10348 SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10349 SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10350 SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10351 SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M), 10352 SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10353 SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 10354 SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10355 SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10356 SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10357 SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 10358 SND_PCI_QUIRK(0x103c, 0x2b5e, "HP 288 Pro G2 MT", ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE), 10359 SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE), 10360 SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE), 10361 SND_PCI_QUIRK(0x103c, 0x8077, "HP", ALC256_FIXUP_HP_HEADSET_MIC), 10362 SND_PCI_QUIRK(0x103c, 0x8158, "HP", ALC256_FIXUP_HP_HEADSET_MIC), 10363 SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC295_FIXUP_HP_X360), 10364 SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC), 10365 SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360), 10366 SND_PCI_QUIRK(0x103c, 0x827f, "HP x360", ALC269_FIXUP_HP_MUTE_LED_MIC3), 10367 SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE), 10368 SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE), 10369 SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3), 10370 SND_PCI_QUIRK(0x103c, 0x841c, "HP Pavilion 15-CK0xx", ALC269_FIXUP_HP_MUTE_LED_MIC3), 10371 SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3), 10372 SND_PCI_QUIRK(0x103c, 0x84a6, "HP 250 G7 Notebook PC", ALC269_FIXUP_HP_LINE1_MIC1_LED), 10373 SND_PCI_QUIRK(0x103c, 0x84ae, "HP 15-db0403ng", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10374 SND_PCI_QUIRK(0x103c, 0x84da, "HP OMEN dc0019-ur", ALC295_FIXUP_HP_OMEN), 10375 SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3), 10376 SND_PCI_QUIRK(0x103c, 0x8519, "HP Spectre x360 15-df0xxx", ALC285_FIXUP_HP_SPECTRE_X360), 10377 SND_PCI_QUIRK(0x103c, 0x8537, "HP ProBook 440 G6", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10378 SND_PCI_QUIRK(0x103c, 0x85de, "HP Envy x360 13-ar0xxx", ALC285_FIXUP_HP_ENVY_X360), 10379 SND_PCI_QUIRK(0x103c, 0x860f, "HP ZBook 15 G6", ALC285_FIXUP_HP_GPIO_AMP_INIT), 10380 SND_PCI_QUIRK(0x103c, 0x861f, "HP Elite Dragonfly G1", ALC285_FIXUP_HP_GPIO_AMP_INIT), 10381 SND_PCI_QUIRK(0x103c, 0x869d, "HP", ALC236_FIXUP_HP_MUTE_LED), 10382 SND_PCI_QUIRK(0x103c, 0x86c1, "HP Laptop 15-da3001TU", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10383 SND_PCI_QUIRK(0x103c, 0x86c7, "HP Envy AiO 32", ALC274_FIXUP_HP_ENVY_GPIO), 10384 SND_PCI_QUIRK(0x103c, 0x86e7, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1), 10385 SND_PCI_QUIRK(0x103c, 0x86e8, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1), 10386 SND_PCI_QUIRK(0x103c, 0x86f9, "HP Spectre x360 13-aw0xxx", ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED), 10387 SND_PCI_QUIRK(0x103c, 0x8716, "HP Elite Dragonfly G2 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT), 10388 SND_PCI_QUIRK(0x103c, 0x8720, "HP EliteBook x360 1040 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT), 10389 SND_PCI_QUIRK(0x103c, 0x8724, "HP EliteBook 850 G7", ALC285_FIXUP_HP_GPIO_LED), 10390 SND_PCI_QUIRK(0x103c, 0x8728, "HP EliteBook 840 G7", ALC285_FIXUP_HP_GPIO_LED), 10391 SND_PCI_QUIRK(0x103c, 0x8729, "HP", ALC285_FIXUP_HP_GPIO_LED), 10392 SND_PCI_QUIRK(0x103c, 0x8730, "HP ProBook 445 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10393 SND_PCI_QUIRK(0x103c, 0x8735, "HP ProBook 435 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10394 SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_AMP_INIT), 10395 SND_PCI_QUIRK(0x103c, 0x8760, "HP", ALC285_FIXUP_HP_MUTE_LED), 10396 SND_PCI_QUIRK(0x103c, 0x876e, "HP ENVY x360 Convertible 13-ay0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS), 10397 SND_PCI_QUIRK(0x103c, 0x877a, "HP", ALC285_FIXUP_HP_MUTE_LED), 10398 SND_PCI_QUIRK(0x103c, 0x877d, "HP", ALC236_FIXUP_HP_MUTE_LED), 10399 SND_PCI_QUIRK(0x103c, 0x8780, "HP ZBook Fury 17 G7 Mobile Workstation", 10400 ALC285_FIXUP_HP_GPIO_AMP_INIT), 10401 SND_PCI_QUIRK(0x103c, 0x8783, "HP ZBook Fury 15 G7 Mobile Workstation", 10402 ALC285_FIXUP_HP_GPIO_AMP_INIT), 10403 SND_PCI_QUIRK(0x103c, 0x8786, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED), 10404 SND_PCI_QUIRK(0x103c, 0x8787, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED), 10405 SND_PCI_QUIRK(0x103c, 0x8788, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED), 10406 SND_PCI_QUIRK(0x103c, 0x87b7, "HP Laptop 14-fq0xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10407 SND_PCI_QUIRK(0x103c, 0x87c8, "HP", ALC287_FIXUP_HP_GPIO_LED), 10408 SND_PCI_QUIRK(0x103c, 0x87d3, "HP Laptop 15-gw0xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10409 SND_PCI_QUIRK(0x103c, 0x87df, "HP ProBook 430 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 10410 SND_PCI_QUIRK(0x103c, 0x87e5, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 10411 SND_PCI_QUIRK(0x103c, 0x87e7, "HP ProBook 450 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 10412 SND_PCI_QUIRK(0x103c, 0x87f1, "HP ProBook 630 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 10413 SND_PCI_QUIRK(0x103c, 0x87f2, "HP ProBook 640 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 10414 SND_PCI_QUIRK(0x103c, 0x87f4, "HP", ALC287_FIXUP_HP_GPIO_LED), 10415 SND_PCI_QUIRK(0x103c, 0x87f5, "HP", ALC287_FIXUP_HP_GPIO_LED), 10416 SND_PCI_QUIRK(0x103c, 0x87f6, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP), 10417 SND_PCI_QUIRK(0x103c, 0x87f7, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP), 10418 SND_PCI_QUIRK(0x103c, 0x87fd, "HP Laptop 14-dq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10419 SND_PCI_QUIRK(0x103c, 0x87fe, "HP Laptop 15s-fq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10420 SND_PCI_QUIRK(0x103c, 0x8805, "HP ProBook 650 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 10421 SND_PCI_QUIRK(0x103c, 0x880d, "HP EliteBook 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED), 10422 SND_PCI_QUIRK(0x103c, 0x8811, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1), 10423 SND_PCI_QUIRK(0x103c, 0x8812, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1), 10424 SND_PCI_QUIRK(0x103c, 0x881d, "HP 250 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10425 SND_PCI_QUIRK(0x103c, 0x8846, "HP EliteBook 850 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED), 10426 SND_PCI_QUIRK(0x103c, 0x8847, "HP EliteBook x360 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED), 10427 SND_PCI_QUIRK(0x103c, 0x884b, "HP EliteBook 840 Aero G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED), 10428 SND_PCI_QUIRK(0x103c, 0x884c, "HP EliteBook 840 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED), 10429 SND_PCI_QUIRK(0x103c, 0x8862, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST), 10430 SND_PCI_QUIRK(0x103c, 0x8863, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST), 10431 SND_PCI_QUIRK(0x103c, 0x886d, "HP ZBook Fury 17.3 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT), 10432 SND_PCI_QUIRK(0x103c, 0x8870, "HP ZBook Fury 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT), 10433 SND_PCI_QUIRK(0x103c, 0x8873, "HP ZBook Studio 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT), 10434 SND_PCI_QUIRK(0x103c, 0x887a, "HP Laptop 15s-eq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10435 SND_PCI_QUIRK(0x103c, 0x887c, "HP Laptop 14s-fq1xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10436 SND_PCI_QUIRK(0x103c, 0x888a, "HP ENVY x360 Convertible 15-eu0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS), 10437 SND_PCI_QUIRK(0x103c, 0x888d, "HP ZBook Power 15.6 inch G8 Mobile Workstation PC", ALC236_FIXUP_HP_GPIO_LED), 10438 SND_PCI_QUIRK(0x103c, 0x8895, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED), 10439 SND_PCI_QUIRK(0x103c, 0x8896, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_MUTE_LED), 10440 SND_PCI_QUIRK(0x103c, 0x8898, "HP EliteBook 845 G8 Notebook PC", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST), 10441 SND_PCI_QUIRK(0x103c, 0x88d0, "HP Pavilion 15-eh1xxx (mainboard 88D0)", ALC287_FIXUP_HP_GPIO_LED), 10442 SND_PCI_QUIRK(0x103c, 0x88dd, "HP Pavilion 15z-ec200", ALC285_FIXUP_HP_MUTE_LED), 10443 SND_PCI_QUIRK(0x103c, 0x8902, "HP OMEN 16", ALC285_FIXUP_HP_MUTE_LED), 10444 SND_PCI_QUIRK(0x103c, 0x890e, "HP 255 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10445 SND_PCI_QUIRK(0x103c, 0x8919, "HP Pavilion Aero Laptop 13-be0xxx", ALC287_FIXUP_HP_GPIO_LED), 10446 SND_PCI_QUIRK(0x103c, 0x896d, "HP ZBook Firefly 16 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10447 SND_PCI_QUIRK(0x103c, 0x896e, "HP EliteBook x360 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10448 SND_PCI_QUIRK(0x103c, 0x8971, "HP EliteBook 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10449 SND_PCI_QUIRK(0x103c, 0x8972, "HP EliteBook 840 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10450 SND_PCI_QUIRK(0x103c, 0x8973, "HP EliteBook 860 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10451 SND_PCI_QUIRK(0x103c, 0x8974, "HP EliteBook 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10452 SND_PCI_QUIRK(0x103c, 0x8975, "HP EliteBook x360 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10453 SND_PCI_QUIRK(0x103c, 0x897d, "HP mt440 Mobile Thin Client U74", ALC236_FIXUP_HP_GPIO_LED), 10454 SND_PCI_QUIRK(0x103c, 0x8981, "HP Elite Dragonfly G3", ALC245_FIXUP_CS35L41_SPI_4), 10455 SND_PCI_QUIRK(0x103c, 0x898e, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2), 10456 SND_PCI_QUIRK(0x103c, 0x898f, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2), 10457 SND_PCI_QUIRK(0x103c, 0x8991, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 10458 SND_PCI_QUIRK(0x103c, 0x8992, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2), 10459 SND_PCI_QUIRK(0x103c, 0x8994, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 10460 SND_PCI_QUIRK(0x103c, 0x8995, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2), 10461 SND_PCI_QUIRK(0x103c, 0x89a4, "HP ProBook 440 G9", ALC236_FIXUP_HP_GPIO_LED), 10462 SND_PCI_QUIRK(0x103c, 0x89a6, "HP ProBook 450 G9", ALC236_FIXUP_HP_GPIO_LED), 10463 SND_PCI_QUIRK(0x103c, 0x89aa, "HP EliteBook 630 G9", ALC236_FIXUP_HP_GPIO_LED), 10464 SND_PCI_QUIRK(0x103c, 0x89ac, "HP EliteBook 640 G9", ALC236_FIXUP_HP_GPIO_LED), 10465 SND_PCI_QUIRK(0x103c, 0x89ae, "HP EliteBook 650 G9", ALC236_FIXUP_HP_GPIO_LED), 10466 SND_PCI_QUIRK(0x103c, 0x89c0, "HP ZBook Power 15.6 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10467 SND_PCI_QUIRK(0x103c, 0x89c3, "Zbook Studio G9", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED), 10468 SND_PCI_QUIRK(0x103c, 0x89c6, "Zbook Fury 17 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10469 SND_PCI_QUIRK(0x103c, 0x89ca, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10470 SND_PCI_QUIRK(0x103c, 0x89d3, "HP EliteBook 645 G9 (MB 89D2)", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10471 SND_PCI_QUIRK(0x103c, 0x89e7, "HP Elite x2 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10472 SND_PCI_QUIRK(0x103c, 0x8a0f, "HP Pavilion 14-ec1xxx", ALC287_FIXUP_HP_GPIO_LED), 10473 SND_PCI_QUIRK(0x103c, 0x8a20, "HP Laptop 15s-fq5xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10474 SND_PCI_QUIRK(0x103c, 0x8a25, "HP Victus 16-d1xxx (MB 8A25)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT), 10475 SND_PCI_QUIRK(0x103c, 0x8a28, "HP Envy 13", ALC287_FIXUP_CS35L41_I2C_2), 10476 SND_PCI_QUIRK(0x103c, 0x8a29, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10477 SND_PCI_QUIRK(0x103c, 0x8a2a, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10478 SND_PCI_QUIRK(0x103c, 0x8a2b, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10479 SND_PCI_QUIRK(0x103c, 0x8a2c, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2), 10480 SND_PCI_QUIRK(0x103c, 0x8a2d, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2), 10481 SND_PCI_QUIRK(0x103c, 0x8a2e, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2), 10482 SND_PCI_QUIRK(0x103c, 0x8a30, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 10483 SND_PCI_QUIRK(0x103c, 0x8a31, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10484 SND_PCI_QUIRK(0x103c, 0x8a6e, "HP EDNA 360", ALC287_FIXUP_CS35L41_I2C_4), 10485 SND_PCI_QUIRK(0x103c, 0x8a74, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 10486 SND_PCI_QUIRK(0x103c, 0x8a78, "HP Dev One", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST), 10487 SND_PCI_QUIRK(0x103c, 0x8aa0, "HP ProBook 440 G9 (MB 8A9E)", ALC236_FIXUP_HP_GPIO_LED), 10488 SND_PCI_QUIRK(0x103c, 0x8aa3, "HP ProBook 450 G9 (MB 8AA1)", ALC236_FIXUP_HP_GPIO_LED), 10489 SND_PCI_QUIRK(0x103c, 0x8aa8, "HP EliteBook 640 G9 (MB 8AA6)", ALC236_FIXUP_HP_GPIO_LED), 10490 SND_PCI_QUIRK(0x103c, 0x8aab, "HP EliteBook 650 G9 (MB 8AA9)", ALC236_FIXUP_HP_GPIO_LED), 10491 SND_PCI_QUIRK(0x103c, 0x8ab9, "HP EliteBook 840 G8 (MB 8AB8)", ALC285_FIXUP_HP_GPIO_LED), 10492 SND_PCI_QUIRK(0x103c, 0x8abb, "HP ZBook Firefly 14 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10493 SND_PCI_QUIRK(0x103c, 0x8ad1, "HP EliteBook 840 14 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10494 SND_PCI_QUIRK(0x103c, 0x8ad2, "HP EliteBook 860 16 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10495 SND_PCI_QUIRK(0x103c, 0x8ad8, "HP 800 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10496 SND_PCI_QUIRK(0x103c, 0x8b0f, "HP Elite mt645 G7 Mobile Thin Client U81", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10497 SND_PCI_QUIRK(0x103c, 0x8b2f, "HP 255 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2), 10498 SND_PCI_QUIRK(0x103c, 0x8b3a, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10499 SND_PCI_QUIRK(0x103c, 0x8b3f, "HP mt440 Mobile Thin Client U91", ALC236_FIXUP_HP_GPIO_LED), 10500 SND_PCI_QUIRK(0x103c, 0x8b42, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10501 SND_PCI_QUIRK(0x103c, 0x8b43, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10502 SND_PCI_QUIRK(0x103c, 0x8b44, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10503 SND_PCI_QUIRK(0x103c, 0x8b45, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10504 SND_PCI_QUIRK(0x103c, 0x8b46, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10505 SND_PCI_QUIRK(0x103c, 0x8b47, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10506 SND_PCI_QUIRK(0x103c, 0x8b59, "HP Elite mt645 G7 Mobile Thin Client U89", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10507 SND_PCI_QUIRK(0x103c, 0x8b5d, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10508 SND_PCI_QUIRK(0x103c, 0x8b5e, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10509 SND_PCI_QUIRK(0x103c, 0x8b5f, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10510 SND_PCI_QUIRK(0x103c, 0x8b63, "HP Elite Dragonfly 13.5 inch G4", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED), 10511 SND_PCI_QUIRK(0x103c, 0x8b65, "HP ProBook 455 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10512 SND_PCI_QUIRK(0x103c, 0x8b66, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10513 SND_PCI_QUIRK(0x103c, 0x8b70, "HP EliteBook 835 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 10514 SND_PCI_QUIRK(0x103c, 0x8b72, "HP EliteBook 845 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 10515 SND_PCI_QUIRK(0x103c, 0x8b74, "HP EliteBook 845W G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 10516 SND_PCI_QUIRK(0x103c, 0x8b77, "HP ElieBook 865 G10", ALC287_FIXUP_CS35L41_I2C_2), 10517 SND_PCI_QUIRK(0x103c, 0x8b7a, "HP", ALC236_FIXUP_HP_GPIO_LED), 10518 SND_PCI_QUIRK(0x103c, 0x8b7d, "HP", ALC236_FIXUP_HP_GPIO_LED), 10519 SND_PCI_QUIRK(0x103c, 0x8b87, "HP", ALC236_FIXUP_HP_GPIO_LED), 10520 SND_PCI_QUIRK(0x103c, 0x8b8a, "HP", ALC236_FIXUP_HP_GPIO_LED), 10521 SND_PCI_QUIRK(0x103c, 0x8b8b, "HP", ALC236_FIXUP_HP_GPIO_LED), 10522 SND_PCI_QUIRK(0x103c, 0x8b8d, "HP", ALC236_FIXUP_HP_GPIO_LED), 10523 SND_PCI_QUIRK(0x103c, 0x8b8f, "HP", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED), 10524 SND_PCI_QUIRK(0x103c, 0x8b92, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10525 SND_PCI_QUIRK(0x103c, 0x8b96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10526 SND_PCI_QUIRK(0x103c, 0x8b97, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10527 SND_PCI_QUIRK(0x103c, 0x8bb3, "HP Slim OMEN", ALC287_FIXUP_CS35L41_I2C_2), 10528 SND_PCI_QUIRK(0x103c, 0x8bb4, "HP Slim OMEN", ALC287_FIXUP_CS35L41_I2C_2), 10529 SND_PCI_QUIRK(0x103c, 0x8bdd, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 10530 SND_PCI_QUIRK(0x103c, 0x8bde, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 10531 SND_PCI_QUIRK(0x103c, 0x8bdf, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10532 SND_PCI_QUIRK(0x103c, 0x8be0, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10533 SND_PCI_QUIRK(0x103c, 0x8be1, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10534 SND_PCI_QUIRK(0x103c, 0x8be2, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10535 SND_PCI_QUIRK(0x103c, 0x8be3, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10536 SND_PCI_QUIRK(0x103c, 0x8be5, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2), 10537 SND_PCI_QUIRK(0x103c, 0x8be6, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2), 10538 SND_PCI_QUIRK(0x103c, 0x8be7, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 10539 SND_PCI_QUIRK(0x103c, 0x8be8, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 10540 SND_PCI_QUIRK(0x103c, 0x8be9, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10541 SND_PCI_QUIRK(0x103c, 0x8bf0, "HP", ALC236_FIXUP_HP_GPIO_LED), 10542 SND_PCI_QUIRK(0x103c, 0x8c15, "HP Spectre x360 2-in-1 Laptop 14-eu0xxx", ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX), 10543 SND_PCI_QUIRK(0x103c, 0x8c16, "HP Spectre x360 2-in-1 Laptop 16-aa0xxx", ALC245_FIXUP_HP_SPECTRE_X360_16_AA0XXX), 10544 SND_PCI_QUIRK(0x103c, 0x8c17, "HP Spectre 16", ALC287_FIXUP_CS35L41_I2C_2), 10545 SND_PCI_QUIRK(0x103c, 0x8c21, "HP Pavilion Plus Laptop 14-ey0XXX", ALC245_FIXUP_HP_X360_MUTE_LEDS), 10546 SND_PCI_QUIRK(0x103c, 0x8c30, "HP Victus 15-fb1xxx", ALC245_FIXUP_HP_MUTE_LED_COEFBIT), 10547 SND_PCI_QUIRK(0x103c, 0x8c46, "HP EliteBook 830 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10548 SND_PCI_QUIRK(0x103c, 0x8c47, "HP EliteBook 840 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10549 SND_PCI_QUIRK(0x103c, 0x8c48, "HP EliteBook 860 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10550 SND_PCI_QUIRK(0x103c, 0x8c49, "HP Elite x360 830 2-in-1 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10551 SND_PCI_QUIRK(0x103c, 0x8c4d, "HP Omen", ALC287_FIXUP_CS35L41_I2C_2), 10552 SND_PCI_QUIRK(0x103c, 0x8c4e, "HP Omen", ALC287_FIXUP_CS35L41_I2C_2), 10553 SND_PCI_QUIRK(0x103c, 0x8c4f, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2), 10554 SND_PCI_QUIRK(0x103c, 0x8c50, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 10555 SND_PCI_QUIRK(0x103c, 0x8c51, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 10556 SND_PCI_QUIRK(0x103c, 0x8c52, "HP EliteBook 1040 G11", ALC285_FIXUP_HP_GPIO_LED), 10557 SND_PCI_QUIRK(0x103c, 0x8c53, "HP Elite x360 1040 2-in-1 G11", ALC285_FIXUP_HP_GPIO_LED), 10558 SND_PCI_QUIRK(0x103c, 0x8c66, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2), 10559 SND_PCI_QUIRK(0x103c, 0x8c67, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 10560 SND_PCI_QUIRK(0x103c, 0x8c68, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2), 10561 SND_PCI_QUIRK(0x103c, 0x8c6a, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2), 10562 SND_PCI_QUIRK(0x103c, 0x8c70, "HP EliteBook 835 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 10563 SND_PCI_QUIRK(0x103c, 0x8c71, "HP EliteBook 845 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 10564 SND_PCI_QUIRK(0x103c, 0x8c72, "HP EliteBook 865 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 10565 SND_PCI_QUIRK(0x103c, 0x8c7b, "HP ProBook 445 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10566 SND_PCI_QUIRK(0x103c, 0x8c7c, "HP ProBook 445 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10567 SND_PCI_QUIRK(0x103c, 0x8c7d, "HP ProBook 465 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10568 SND_PCI_QUIRK(0x103c, 0x8c7e, "HP ProBook 465 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10569 SND_PCI_QUIRK(0x103c, 0x8c7f, "HP EliteBook 645 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10570 SND_PCI_QUIRK(0x103c, 0x8c80, "HP EliteBook 645 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10571 SND_PCI_QUIRK(0x103c, 0x8c81, "HP EliteBook 665 G11", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10572 SND_PCI_QUIRK(0x103c, 0x8c89, "HP ProBook 460 G11", ALC236_FIXUP_HP_GPIO_LED), 10573 SND_PCI_QUIRK(0x103c, 0x8c8a, "HP EliteBook 630", ALC236_FIXUP_HP_GPIO_LED), 10574 SND_PCI_QUIRK(0x103c, 0x8c8c, "HP EliteBook 660", ALC236_FIXUP_HP_GPIO_LED), 10575 SND_PCI_QUIRK(0x103c, 0x8c8d, "HP ProBook 440 G11", ALC236_FIXUP_HP_GPIO_LED), 10576 SND_PCI_QUIRK(0x103c, 0x8c8e, "HP ProBook 460 G11", ALC236_FIXUP_HP_GPIO_LED), 10577 SND_PCI_QUIRK(0x103c, 0x8c90, "HP EliteBook 640", ALC236_FIXUP_HP_GPIO_LED), 10578 SND_PCI_QUIRK(0x103c, 0x8c91, "HP EliteBook 660", ALC236_FIXUP_HP_GPIO_LED), 10579 SND_PCI_QUIRK(0x103c, 0x8c96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10580 SND_PCI_QUIRK(0x103c, 0x8c97, "HP ZBook", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10581 SND_PCI_QUIRK(0x103c, 0x8ca1, "HP ZBook Power", ALC236_FIXUP_HP_GPIO_LED), 10582 SND_PCI_QUIRK(0x103c, 0x8ca2, "HP ZBook Power", ALC236_FIXUP_HP_GPIO_LED), 10583 SND_PCI_QUIRK(0x103c, 0x8ca4, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10584 SND_PCI_QUIRK(0x103c, 0x8ca7, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED), 10585 SND_PCI_QUIRK(0x103c, 0x8caf, "HP Elite mt645 G8 Mobile Thin Client", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 10586 SND_PCI_QUIRK(0x103c, 0x8cbd, "HP Pavilion Aero Laptop 13-bg0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS), 10587 SND_PCI_QUIRK(0x103c, 0x8cdd, "HP Spectre", ALC287_FIXUP_CS35L41_I2C_2), 10588 SND_PCI_QUIRK(0x103c, 0x8cde, "HP Spectre", ALC287_FIXUP_CS35L41_I2C_2), 10589 SND_PCI_QUIRK(0x103c, 0x8cdf, "HP SnowWhite", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 10590 SND_PCI_QUIRK(0x103c, 0x8ce0, "HP SnowWhite", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED), 10591 SND_PCI_QUIRK(0x103c, 0x8cf5, "HP ZBook Studio 16", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED), 10592 SND_PCI_QUIRK(0x103c, 0x8d01, "HP ZBook Power 14 G12", ALC285_FIXUP_HP_GPIO_LED), 10593 SND_PCI_QUIRK(0x103c, 0x8d84, "HP EliteBook X G1i", ALC285_FIXUP_HP_GPIO_LED), 10594 SND_PCI_QUIRK(0x103c, 0x8d91, "HP ZBook Firefly 14 G12", ALC285_FIXUP_HP_GPIO_LED), 10595 SND_PCI_QUIRK(0x103c, 0x8d92, "HP ZBook Firefly 16 G12", ALC285_FIXUP_HP_GPIO_LED), 10596 SND_PCI_QUIRK(0x103c, 0x8de8, "HP Gemtree", ALC245_FIXUP_TAS2781_SPI_2), 10597 SND_PCI_QUIRK(0x103c, 0x8de9, "HP Gemtree", ALC245_FIXUP_TAS2781_SPI_2), 10598 SND_PCI_QUIRK(0x103c, 0x8e18, "HP ZBook Firefly 14 G12A", ALC285_FIXUP_HP_GPIO_LED), 10599 SND_PCI_QUIRK(0x103c, 0x8e19, "HP ZBook Firefly 14 G12A", ALC285_FIXUP_HP_GPIO_LED), 10600 SND_PCI_QUIRK(0x103c, 0x8e1a, "HP ZBook Firefly 14 G12A", ALC285_FIXUP_HP_GPIO_LED), 10601 SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC), 10602 SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300), 10603 SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 10604 SND_PCI_QUIRK(0x1043, 0x10a1, "ASUS UX391UA", ALC294_FIXUP_ASUS_SPK), 10605 SND_PCI_QUIRK(0x1043, 0x10a4, "ASUS TP3407SA", ALC287_FIXUP_TAS2781_I2C), 10606 SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC), 10607 SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE), 10608 SND_PCI_QUIRK(0x1043, 0x10d3, "ASUS K6500ZC", ALC294_FIXUP_ASUS_SPK), 10609 SND_PCI_QUIRK(0x1043, 0x1154, "ASUS TP3607SH", ALC287_FIXUP_TAS2781_I2C), 10610 SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 10611 SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE), 10612 SND_PCI_QUIRK(0x1043, 0x1204, "ASUS Strix G615JHR_JMR_JPR", ALC287_FIXUP_TAS2781_I2C), 10613 SND_PCI_QUIRK(0x1043, 0x1214, "ASUS Strix G615LH_LM_LP", ALC287_FIXUP_TAS2781_I2C), 10614 SND_PCI_QUIRK(0x1043, 0x125e, "ASUS Q524UQK", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE), 10615 SND_PCI_QUIRK(0x1043, 0x1271, "ASUS X430UN", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE), 10616 SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE), 10617 SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE), 10618 SND_PCI_QUIRK(0x1043, 0x12a3, "Asus N7691ZM", ALC269_FIXUP_ASUS_N7601ZM), 10619 SND_PCI_QUIRK(0x1043, 0x12af, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2), 10620 SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC), 10621 SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC), 10622 SND_PCI_QUIRK(0x1043, 0x1313, "Asus K42JZ", ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE), 10623 SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC), 10624 SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK), 10625 SND_PCI_QUIRK(0x1043, 0x1433, "ASUS GX650PY/PZ/PV/PU/PYV/PZV/PIV/PVV", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC), 10626 SND_PCI_QUIRK(0x1043, 0x1463, "Asus GA402X/GA402N", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC), 10627 SND_PCI_QUIRK(0x1043, 0x1473, "ASUS GU604VI/VC/VE/VG/VJ/VQ/VU/VV/VY/VZ", ALC285_FIXUP_ASUS_HEADSET_MIC), 10628 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS GU603VQ/VU/VV/VJ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC), 10629 SND_PCI_QUIRK(0x1043, 0x1493, "ASUS GV601VV/VU/VJ/VQ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC), 10630 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G614JY/JZ/JG", ALC245_FIXUP_CS35L41_SPI_2), 10631 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS G513PI/PU/PV", ALC287_FIXUP_CS35L41_I2C_2), 10632 SND_PCI_QUIRK(0x1043, 0x1503, "ASUS G733PY/PZ/PZV/PYV", ALC287_FIXUP_CS35L41_I2C_2), 10633 SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A), 10634 SND_PCI_QUIRK(0x1043, 0x1533, "ASUS GV302XA/XJ/XQ/XU/XV/XI", ALC287_FIXUP_CS35L41_I2C_2), 10635 SND_PCI_QUIRK(0x1043, 0x1573, "ASUS GZ301VV/VQ/VU/VJ/VA/VC/VE/VVC/VQC/VUC/VJC/VEC/VCC", ALC285_FIXUP_ASUS_HEADSET_MIC), 10636 SND_PCI_QUIRK(0x1043, 0x1662, "ASUS GV301QH", ALC294_FIXUP_ASUS_DUAL_SPK), 10637 SND_PCI_QUIRK(0x1043, 0x1663, "ASUS GU603ZI/ZJ/ZQ/ZU/ZV", ALC285_FIXUP_ASUS_HEADSET_MIC), 10638 SND_PCI_QUIRK(0x1043, 0x1683, "ASUS UM3402YAR", ALC287_FIXUP_CS35L41_I2C_2), 10639 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS UX3402VA", ALC245_FIXUP_CS35L41_SPI_2), 10640 SND_PCI_QUIRK(0x1043, 0x16b2, "ASUS GU603", ALC289_FIXUP_ASUS_GA401), 10641 SND_PCI_QUIRK(0x1043, 0x16d3, "ASUS UX5304VA", ALC245_FIXUP_CS35L41_SPI_2), 10642 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC), 10643 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS UX7602VI/BZ", ALC245_FIXUP_CS35L41_SPI_2), 10644 SND_PCI_QUIRK(0x1043, 0x1740, "ASUS UX430UA", ALC295_FIXUP_ASUS_DACS), 10645 SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_DUAL_SPK), 10646 SND_PCI_QUIRK(0x1043, 0x17f3, "ROG Ally NR2301L/X", ALC294_FIXUP_ASUS_ALLY), 10647 SND_PCI_QUIRK(0x1043, 0x1eb3, "ROG Ally X RC72LA", ALC294_FIXUP_ASUS_ALLY_X), 10648 SND_PCI_QUIRK(0x1043, 0x1863, "ASUS UX6404VI/VV", ALC245_FIXUP_CS35L41_SPI_2), 10649 SND_PCI_QUIRK(0x1043, 0x1881, "ASUS Zephyrus S/M", ALC294_FIXUP_ASUS_GX502_PINS), 10650 SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC), 10651 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS UM3504DA", ALC294_FIXUP_CS35L41_I2C_2), 10652 SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC), 10653 SND_PCI_QUIRK(0x1043, 0x194e, "ASUS UX563FD", ALC294_FIXUP_ASUS_HPE), 10654 SND_PCI_QUIRK(0x1043, 0x1970, "ASUS UX550VE", ALC289_FIXUP_ASUS_GA401), 10655 SND_PCI_QUIRK(0x1043, 0x1982, "ASUS B1400CEPE", ALC256_FIXUP_ASUS_HPE), 10656 SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE), 10657 SND_PCI_QUIRK(0x1043, 0x19e1, "ASUS UX581LV", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE), 10658 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW), 10659 SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC), 10660 SND_PCI_QUIRK(0x1043, 0x1a63, "ASUS UX3405MA", ALC245_FIXUP_CS35L41_SPI_2), 10661 SND_PCI_QUIRK(0x1043, 0x1a83, "ASUS UM5302LA", ALC294_FIXUP_CS35L41_I2C_2), 10662 SND_PCI_QUIRK(0x1043, 0x1a8f, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2), 10663 SND_PCI_QUIRK(0x1043, 0x1b11, "ASUS UX431DA", ALC294_FIXUP_ASUS_COEF_1B), 10664 SND_PCI_QUIRK(0x1043, 0x1b13, "ASUS U41SV/GA403U", ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC), 10665 SND_PCI_QUIRK(0x1043, 0x1b93, "ASUS G614JVR/JIR", ALC245_FIXUP_CS35L41_SPI_2), 10666 SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE), 10667 SND_PCI_QUIRK(0x1043, 0x1c03, "ASUS UM3406HA", ALC287_FIXUP_CS35L41_I2C_2), 10668 SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 10669 SND_PCI_QUIRK(0x1043, 0x1c33, "ASUS UX5304MA", ALC245_FIXUP_CS35L41_SPI_2), 10670 SND_PCI_QUIRK(0x1043, 0x1c43, "ASUS UX8406MA", ALC245_FIXUP_CS35L41_SPI_2), 10671 SND_PCI_QUIRK(0x1043, 0x1c62, "ASUS GU603", ALC289_FIXUP_ASUS_GA401), 10672 SND_PCI_QUIRK(0x1043, 0x1c63, "ASUS GU605M", ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1), 10673 SND_PCI_QUIRK(0x1043, 0x1c92, "ASUS ROG Strix G15", ALC285_FIXUP_ASUS_G533Z_PINS), 10674 SND_PCI_QUIRK(0x1043, 0x1c9f, "ASUS G614JU/JV/JI", ALC285_FIXUP_ASUS_HEADSET_MIC), 10675 SND_PCI_QUIRK(0x1043, 0x1caf, "ASUS G634JY/JZ/JI/JG", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS), 10676 SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC), 10677 SND_PCI_QUIRK(0x1043, 0x1ccf, "ASUS G814JU/JV/JI", ALC245_FIXUP_CS35L41_SPI_2), 10678 SND_PCI_QUIRK(0x1043, 0x1cdf, "ASUS G814JY/JZ/JG", ALC245_FIXUP_CS35L41_SPI_2), 10679 SND_PCI_QUIRK(0x1043, 0x1cef, "ASUS G834JY/JZ/JI/JG", ALC285_FIXUP_ASUS_HEADSET_MIC), 10680 SND_PCI_QUIRK(0x1043, 0x1d1f, "ASUS G713PI/PU/PV/PVN", ALC287_FIXUP_CS35L41_I2C_2), 10681 SND_PCI_QUIRK(0x1043, 0x1d42, "ASUS Zephyrus G14 2022", ALC289_FIXUP_ASUS_GA401), 10682 SND_PCI_QUIRK(0x1043, 0x1d4e, "ASUS TM420", ALC256_FIXUP_ASUS_HPE), 10683 SND_PCI_QUIRK(0x1043, 0x1da2, "ASUS UP6502ZA/ZD", ALC245_FIXUP_CS35L41_SPI_2), 10684 SND_PCI_QUIRK(0x1043, 0x1df3, "ASUS UM5606WA", ALC294_FIXUP_BASS_SPEAKER_15), 10685 SND_PCI_QUIRK(0x1043, 0x1e02, "ASUS UX3402ZA", ALC245_FIXUP_CS35L41_SPI_2), 10686 SND_PCI_QUIRK(0x1043, 0x1e11, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA502), 10687 SND_PCI_QUIRK(0x1043, 0x1e12, "ASUS UM3402", ALC287_FIXUP_CS35L41_I2C_2), 10688 SND_PCI_QUIRK(0x1043, 0x1e1f, "ASUS Vivobook 15 X1504VAP", ALC2XX_FIXUP_HEADSET_MIC), 10689 SND_PCI_QUIRK(0x1043, 0x1e51, "ASUS Zephyrus M15", ALC294_FIXUP_ASUS_GU502_PINS), 10690 SND_PCI_QUIRK(0x1043, 0x1e5e, "ASUS ROG Strix G513", ALC294_FIXUP_ASUS_G513_PINS), 10691 SND_PCI_QUIRK(0x1043, 0x1e63, "ASUS H7606W", ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1), 10692 SND_PCI_QUIRK(0x1043, 0x1e83, "ASUS GA605W", ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1), 10693 SND_PCI_QUIRK(0x1043, 0x1e8e, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA401), 10694 SND_PCI_QUIRK(0x1043, 0x1eb3, "ASUS Ally RCLA72", ALC287_FIXUP_TAS2781_I2C), 10695 SND_PCI_QUIRK(0x1043, 0x1ed3, "ASUS HN7306W", ALC287_FIXUP_CS35L41_I2C_2), 10696 SND_PCI_QUIRK(0x1043, 0x1ee2, "ASUS UM6702RA/RC", ALC287_FIXUP_CS35L41_I2C_2), 10697 SND_PCI_QUIRK(0x1043, 0x1c52, "ASUS Zephyrus G15 2022", ALC289_FIXUP_ASUS_GA401), 10698 SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401), 10699 SND_PCI_QUIRK(0x1043, 0x1f12, "ASUS UM5302", ALC287_FIXUP_CS35L41_I2C_2), 10700 SND_PCI_QUIRK(0x1043, 0x1f1f, "ASUS H7604JI/JV/J3D", ALC245_FIXUP_CS35L41_SPI_2), 10701 SND_PCI_QUIRK(0x1043, 0x1f62, "ASUS UX7602ZM", ALC245_FIXUP_CS35L41_SPI_2), 10702 SND_PCI_QUIRK(0x1043, 0x1f92, "ASUS ROG Flow X16", ALC289_FIXUP_ASUS_GA401), 10703 SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2), 10704 SND_PCI_QUIRK(0x1043, 0x31d0, "ASUS Zen AIO 27 Z272SD_A272SD", ALC274_FIXUP_ASUS_ZEN_AIO_27), 10705 SND_PCI_QUIRK(0x1043, 0x3a20, "ASUS G614JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS), 10706 SND_PCI_QUIRK(0x1043, 0x3a30, "ASUS G814JVR/JIR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS), 10707 SND_PCI_QUIRK(0x1043, 0x3a40, "ASUS G814JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS), 10708 SND_PCI_QUIRK(0x1043, 0x3a50, "ASUS G834JYR/JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS), 10709 SND_PCI_QUIRK(0x1043, 0x3a60, "ASUS G634JYR/JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS), 10710 SND_PCI_QUIRK(0x1043, 0x3e30, "ASUS TP3607SA", ALC287_FIXUP_TAS2781_I2C), 10711 SND_PCI_QUIRK(0x1043, 0x3ee0, "ASUS Strix G815_JHR_JMR_JPR", ALC287_FIXUP_TAS2781_I2C), 10712 SND_PCI_QUIRK(0x1043, 0x3ef0, "ASUS Strix G635LR_LW_LX", ALC287_FIXUP_TAS2781_I2C), 10713 SND_PCI_QUIRK(0x1043, 0x3f00, "ASUS Strix G815LH_LM_LP", ALC287_FIXUP_TAS2781_I2C), 10714 SND_PCI_QUIRK(0x1043, 0x3f10, "ASUS Strix G835LR_LW_LX", ALC287_FIXUP_TAS2781_I2C), 10715 SND_PCI_QUIRK(0x1043, 0x3f20, "ASUS Strix G615LR_LW", ALC287_FIXUP_TAS2781_I2C), 10716 SND_PCI_QUIRK(0x1043, 0x3f30, "ASUS Strix G815LR_LW", ALC287_FIXUP_TAS2781_I2C), 10717 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC), 10718 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC), 10719 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC), 10720 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC), 10721 SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101), 10722 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2), 10723 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ), 10724 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ), 10725 SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX), 10726 SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE), 10727 SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE), 10728 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK), 10729 SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT), 10730 SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN), 10731 SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC), 10732 SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN), 10733 SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC), 10734 SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE), 10735 SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE), 10736 SND_PCI_QUIRK(0x10ec, 0x119e, "Positivo SU C1400", ALC269_FIXUP_ASPIRE_HEADSET_MIC), 10737 SND_PCI_QUIRK(0x10ec, 0x11bc, "VAIO VJFE-IL", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 10738 SND_PCI_QUIRK(0x10ec, 0x1230, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 10739 SND_PCI_QUIRK(0x10ec, 0x124c, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 10740 SND_PCI_QUIRK(0x10ec, 0x1252, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 10741 SND_PCI_QUIRK(0x10ec, 0x1254, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 10742 SND_PCI_QUIRK(0x10ec, 0x12cc, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 10743 SND_PCI_QUIRK(0x10ec, 0x12f6, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 10744 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_ASPIRE_HEADSET_MIC), 10745 SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC), 10746 SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_AMP), 10747 SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_AMP), 10748 SND_PCI_QUIRK(0x144d, 0xc189, "Samsung Galaxy Flex Book (NT950QCG-X716)", ALC298_FIXUP_SAMSUNG_AMP), 10749 SND_PCI_QUIRK(0x144d, 0xc18a, "Samsung Galaxy Book Ion (NP930XCJ-K01US)", ALC298_FIXUP_SAMSUNG_AMP), 10750 SND_PCI_QUIRK(0x144d, 0xc1a3, "Samsung Galaxy Book Pro (NP935XDB-KC1SE)", ALC298_FIXUP_SAMSUNG_AMP), 10751 SND_PCI_QUIRK(0x144d, 0xc1a4, "Samsung Galaxy Book Pro 360 (NT935QBD)", ALC298_FIXUP_SAMSUNG_AMP), 10752 SND_PCI_QUIRK(0x144d, 0xc1a6, "Samsung Galaxy Book Pro 360 (NP930QBD)", ALC298_FIXUP_SAMSUNG_AMP), 10753 SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8), 10754 SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_AMP), 10755 SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_AMP), 10756 SND_PCI_QUIRK(0x144d, 0xc832, "Samsung Galaxy Book Flex Alpha (NP730QCJ)", ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), 10757 SND_PCI_QUIRK(0x144d, 0xca03, "Samsung Galaxy Book2 Pro 360 (NP930QED)", ALC298_FIXUP_SAMSUNG_AMP), 10758 SND_PCI_QUIRK(0x144d, 0xca06, "Samsung Galaxy Book3 360 (NP730QFG)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), 10759 SND_PCI_QUIRK(0x144d, 0xc868, "Samsung Galaxy Book2 Pro (NP930XED)", ALC298_FIXUP_SAMSUNG_AMP), 10760 SND_PCI_QUIRK(0x144d, 0xc870, "Samsung Galaxy Book2 Pro (NP950XED)", ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS), 10761 SND_PCI_QUIRK(0x144d, 0xc872, "Samsung Galaxy Book2 Pro (NP950XEE)", ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS), 10762 SND_PCI_QUIRK(0x144d, 0xc886, "Samsung Galaxy Book3 Pro (NP964XFG)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS), 10763 SND_PCI_QUIRK(0x144d, 0xc1ca, "Samsung Galaxy Book3 Pro 360 (NP960QFG)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS), 10764 SND_PCI_QUIRK(0x144d, 0xc1cc, "Samsung Galaxy Book3 Ultra (NT960XFH)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS), 10765 SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC), 10766 SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC), 10767 SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC), 10768 SND_PCI_QUIRK(0x152d, 0x1082, "Quanta NL3", ALC269_FIXUP_LIFEBOOK), 10769 SND_PCI_QUIRK(0x152d, 0x1262, "Huawei NBLB-WAX9N", ALC2XX_FIXUP_HEADSET_MIC), 10770 SND_PCI_QUIRK(0x1558, 0x0353, "Clevo V35[05]SN[CDE]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10771 SND_PCI_QUIRK(0x1558, 0x1323, "Clevo N130ZU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10772 SND_PCI_QUIRK(0x1558, 0x1325, "Clevo N15[01][CW]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10773 SND_PCI_QUIRK(0x1558, 0x1401, "Clevo L140[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10774 SND_PCI_QUIRK(0x1558, 0x1403, "Clevo N140CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10775 SND_PCI_QUIRK(0x1558, 0x1404, "Clevo N150CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10776 SND_PCI_QUIRK(0x1558, 0x14a1, "Clevo L141MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10777 SND_PCI_QUIRK(0x1558, 0x2624, "Clevo L240TU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10778 SND_PCI_QUIRK(0x1558, 0x28c1, "Clevo V370VND", ALC2XX_FIXUP_HEADSET_MIC), 10779 SND_PCI_QUIRK(0x1558, 0x4018, "Clevo NV40M[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10780 SND_PCI_QUIRK(0x1558, 0x4019, "Clevo NV40MZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10781 SND_PCI_QUIRK(0x1558, 0x4020, "Clevo NV40MB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10782 SND_PCI_QUIRK(0x1558, 0x4041, "Clevo NV4[15]PZ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10783 SND_PCI_QUIRK(0x1558, 0x40a1, "Clevo NL40GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10784 SND_PCI_QUIRK(0x1558, 0x40c1, "Clevo NL40[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10785 SND_PCI_QUIRK(0x1558, 0x40d1, "Clevo NL41DU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10786 SND_PCI_QUIRK(0x1558, 0x5015, "Clevo NH5[58]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10787 SND_PCI_QUIRK(0x1558, 0x5017, "Clevo NH7[79]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10788 SND_PCI_QUIRK(0x1558, 0x50a3, "Clevo NJ51GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10789 SND_PCI_QUIRK(0x1558, 0x50b3, "Clevo NK50S[BEZ]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10790 SND_PCI_QUIRK(0x1558, 0x50b6, "Clevo NK50S5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10791 SND_PCI_QUIRK(0x1558, 0x50b8, "Clevo NK50SZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10792 SND_PCI_QUIRK(0x1558, 0x50d5, "Clevo NP50D5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10793 SND_PCI_QUIRK(0x1558, 0x50e1, "Clevo NH5[58]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10794 SND_PCI_QUIRK(0x1558, 0x50e2, "Clevo NH7[79]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10795 SND_PCI_QUIRK(0x1558, 0x50f0, "Clevo NH50A[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10796 SND_PCI_QUIRK(0x1558, 0x50f2, "Clevo NH50E[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10797 SND_PCI_QUIRK(0x1558, 0x50f3, "Clevo NH58DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10798 SND_PCI_QUIRK(0x1558, 0x50f5, "Clevo NH55EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10799 SND_PCI_QUIRK(0x1558, 0x50f6, "Clevo NH55DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10800 SND_PCI_QUIRK(0x1558, 0x5101, "Clevo S510WU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10801 SND_PCI_QUIRK(0x1558, 0x5157, "Clevo W517GU1", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10802 SND_PCI_QUIRK(0x1558, 0x51a1, "Clevo NS50MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10803 SND_PCI_QUIRK(0x1558, 0x51b1, "Clevo NS50AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10804 SND_PCI_QUIRK(0x1558, 0x51b3, "Clevo NS70AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10805 SND_PCI_QUIRK(0x1558, 0x5630, "Clevo NP50RNJS", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10806 SND_PCI_QUIRK(0x1558, 0x70a1, "Clevo NB70T[HJK]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10807 SND_PCI_QUIRK(0x1558, 0x70b3, "Clevo NK70SB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10808 SND_PCI_QUIRK(0x1558, 0x70f2, "Clevo NH79EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10809 SND_PCI_QUIRK(0x1558, 0x70f3, "Clevo NH77DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10810 SND_PCI_QUIRK(0x1558, 0x70f4, "Clevo NH77EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10811 SND_PCI_QUIRK(0x1558, 0x70f6, "Clevo NH77DPQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10812 SND_PCI_QUIRK(0x1558, 0x7716, "Clevo NS50PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10813 SND_PCI_QUIRK(0x1558, 0x7717, "Clevo NS70PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10814 SND_PCI_QUIRK(0x1558, 0x7718, "Clevo L140PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10815 SND_PCI_QUIRK(0x1558, 0x7724, "Clevo L140AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10816 SND_PCI_QUIRK(0x1558, 0x8228, "Clevo NR40BU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10817 SND_PCI_QUIRK(0x1558, 0x8520, "Clevo NH50D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10818 SND_PCI_QUIRK(0x1558, 0x8521, "Clevo NH77D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10819 SND_PCI_QUIRK(0x1558, 0x8535, "Clevo NH50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10820 SND_PCI_QUIRK(0x1558, 0x8536, "Clevo NH79D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10821 SND_PCI_QUIRK(0x1558, 0x8550, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10822 SND_PCI_QUIRK(0x1558, 0x8551, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10823 SND_PCI_QUIRK(0x1558, 0x8560, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC), 10824 SND_PCI_QUIRK(0x1558, 0x8561, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC), 10825 SND_PCI_QUIRK(0x1558, 0x8562, "Clevo NH[57][0-9]RZ[Q]", ALC269_FIXUP_DMIC), 10826 SND_PCI_QUIRK(0x1558, 0x8668, "Clevo NP50B[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10827 SND_PCI_QUIRK(0x1558, 0x866d, "Clevo NP5[05]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10828 SND_PCI_QUIRK(0x1558, 0x867c, "Clevo NP7[01]PNP", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10829 SND_PCI_QUIRK(0x1558, 0x867d, "Clevo NP7[01]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10830 SND_PCI_QUIRK(0x1558, 0x8680, "Clevo NJ50LU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10831 SND_PCI_QUIRK(0x1558, 0x8686, "Clevo NH50[CZ]U", ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME), 10832 SND_PCI_QUIRK(0x1558, 0x8a20, "Clevo NH55DCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10833 SND_PCI_QUIRK(0x1558, 0x8a51, "Clevo NH70RCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10834 SND_PCI_QUIRK(0x1558, 0x8d50, "Clevo NH55RCQ-M", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10835 SND_PCI_QUIRK(0x1558, 0x951d, "Clevo N950T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10836 SND_PCI_QUIRK(0x1558, 0x9600, "Clevo N960K[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10837 SND_PCI_QUIRK(0x1558, 0x961d, "Clevo N960S[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10838 SND_PCI_QUIRK(0x1558, 0x971d, "Clevo N970T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10839 SND_PCI_QUIRK(0x1558, 0xa500, "Clevo NL5[03]RU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10840 SND_PCI_QUIRK(0x1558, 0xa554, "VAIO VJFH52", ALC269_FIXUP_VAIO_VJFH52_MIC_NO_PRESENCE), 10841 SND_PCI_QUIRK(0x1558, 0xa600, "Clevo NL50NU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10842 SND_PCI_QUIRK(0x1558, 0xa650, "Clevo NP[567]0SN[CD]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10843 SND_PCI_QUIRK(0x1558, 0xa671, "Clevo NP70SN[CDE]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10844 SND_PCI_QUIRK(0x1558, 0xa741, "Clevo V54x_6x_TNE", ALC245_FIXUP_CLEVO_NOISY_MIC), 10845 SND_PCI_QUIRK(0x1558, 0xa763, "Clevo V54x_6x_TU", ALC245_FIXUP_CLEVO_NOISY_MIC), 10846 SND_PCI_QUIRK(0x1558, 0xb018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10847 SND_PCI_QUIRK(0x1558, 0xb019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10848 SND_PCI_QUIRK(0x1558, 0xb022, "Clevo NH77D[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10849 SND_PCI_QUIRK(0x1558, 0xc018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10850 SND_PCI_QUIRK(0x1558, 0xc019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10851 SND_PCI_QUIRK(0x1558, 0xc022, "Clevo NH77[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 10852 SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS), 10853 SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340), 10854 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE), 10855 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE), 10856 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE), 10857 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE), 10858 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE), 10859 SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK), 10860 SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST), 10861 SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK), 10862 SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK), 10863 SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK), 10864 SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK), 10865 SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440), 10866 SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK), 10867 SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK), 10868 SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK), 10869 SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK), 10870 SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK), 10871 SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 10872 SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK), 10873 SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK), 10874 SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK), 10875 SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 10876 SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 10877 SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460), 10878 SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460), 10879 SND_PCI_QUIRK(0x17aa, 0x2234, "Thinkpad ICE-1", ALC287_FIXUP_TAS2781_I2C), 10880 SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK), 10881 SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 10882 SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 10883 SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460), 10884 SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 10885 SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 10886 SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 10887 SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 10888 SND_PCI_QUIRK(0x17aa, 0x2292, "Thinkpad X1 Carbon 7th", ALC285_FIXUP_THINKPAD_HEADSET_JACK), 10889 SND_PCI_QUIRK(0x17aa, 0x22be, "Thinkpad X1 Carbon 8th", ALC285_FIXUP_THINKPAD_HEADSET_JACK), 10890 SND_PCI_QUIRK(0x17aa, 0x22c1, "Thinkpad P1 Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK), 10891 SND_PCI_QUIRK(0x17aa, 0x22c2, "Thinkpad X1 Extreme Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK), 10892 SND_PCI_QUIRK(0x17aa, 0x22f1, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 10893 SND_PCI_QUIRK(0x17aa, 0x22f2, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 10894 SND_PCI_QUIRK(0x17aa, 0x22f3, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 10895 SND_PCI_QUIRK(0x17aa, 0x2316, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 10896 SND_PCI_QUIRK(0x17aa, 0x2317, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 10897 SND_PCI_QUIRK(0x17aa, 0x2318, "Thinkpad Z13 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 10898 SND_PCI_QUIRK(0x17aa, 0x2319, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 10899 SND_PCI_QUIRK(0x17aa, 0x231a, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 10900 SND_PCI_QUIRK(0x17aa, 0x231e, "Thinkpad", ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318), 10901 SND_PCI_QUIRK(0x17aa, 0x231f, "Thinkpad", ALC287_FIXUP_LENOVO_THKPAD_WH_ALC1318), 10902 SND_PCI_QUIRK(0x17aa, 0x2326, "Hera2", ALC287_FIXUP_TAS2781_I2C), 10903 SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY), 10904 SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY), 10905 SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 10906 SND_PCI_QUIRK(0x17aa, 0x3111, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 10907 SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 10908 SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 10909 SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 10910 SND_PCI_QUIRK(0x17aa, 0x3151, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC), 10911 SND_PCI_QUIRK(0x17aa, 0x3176, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC), 10912 SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC), 10913 SND_PCI_QUIRK(0x17aa, 0x31af, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340), 10914 SND_PCI_QUIRK(0x17aa, 0x334b, "Lenovo ThinkCentre M70 Gen5", ALC283_FIXUP_HEADSET_MIC), 10915 SND_PCI_QUIRK(0x17aa, 0x3801, "Lenovo Yoga9 14IAP7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN), 10916 HDA_CODEC_QUIRK(0x17aa, 0x3802, "DuetITL 2021", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS), 10917 SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo Yoga Pro 9 14IRP8", ALC287_FIXUP_TAS2781_I2C), 10918 SND_PCI_QUIRK(0x17aa, 0x3813, "Legion 7i 15IMHG05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS), 10919 SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940 / Yoga Duet 7", ALC298_FIXUP_LENOVO_C940_DUET7), 10920 SND_PCI_QUIRK(0x17aa, 0x3819, "Lenovo 13s Gen2 ITL", ALC287_FIXUP_13S_GEN2_SPEAKERS), 10921 HDA_CODEC_QUIRK(0x17aa, 0x3820, "IdeaPad 330-17IKB 81DM", ALC269_FIXUP_ASPIRE_HEADSET_MIC), 10922 SND_PCI_QUIRK(0x17aa, 0x3820, "Yoga Duet 7 13ITL6", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS), 10923 SND_PCI_QUIRK(0x17aa, 0x3824, "Legion Y9000X 2020", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS), 10924 SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF), 10925 SND_PCI_QUIRK(0x17aa, 0x3834, "Lenovo IdeaPad Slim 9i 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS), 10926 SND_PCI_QUIRK(0x17aa, 0x383d, "Legion Y9000X 2019", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS), 10927 SND_PCI_QUIRK(0x17aa, 0x3843, "Yoga 9i", ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP), 10928 SND_PCI_QUIRK(0x17aa, 0x3847, "Legion 7 16ACHG6", ALC287_FIXUP_LEGION_16ACHG6), 10929 SND_PCI_QUIRK(0x17aa, 0x384a, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS), 10930 SND_PCI_QUIRK(0x17aa, 0x3852, "Lenovo Yoga 7 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS), 10931 SND_PCI_QUIRK(0x17aa, 0x3853, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS), 10932 SND_PCI_QUIRK(0x17aa, 0x3855, "Legion 7 16ITHG6", ALC287_FIXUP_LEGION_16ITHG6), 10933 SND_PCI_QUIRK(0x17aa, 0x3865, "Lenovo 13X", ALC287_FIXUP_CS35L41_I2C_2), 10934 SND_PCI_QUIRK(0x17aa, 0x3866, "Lenovo 13X", ALC287_FIXUP_CS35L41_I2C_2), 10935 SND_PCI_QUIRK(0x17aa, 0x3869, "Lenovo Yoga7 14IAL7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN), 10936 HDA_CODEC_QUIRK(0x17aa, 0x386e, "Legion Y9000X 2022 IAH7", ALC287_FIXUP_CS35L41_I2C_2), 10937 SND_PCI_QUIRK(0x17aa, 0x386e, "Yoga Pro 7 14ARP8", ALC285_FIXUP_SPEAKER2_TO_DAC1), 10938 HDA_CODEC_QUIRK(0x17aa, 0x38a8, "Legion Pro 7 16ARX8H", ALC287_FIXUP_TAS2781_I2C), /* this must match before PCI SSID 17aa:386f below */ 10939 SND_PCI_QUIRK(0x17aa, 0x386f, "Legion Pro 7i 16IAX7", ALC287_FIXUP_CS35L41_I2C_2), 10940 SND_PCI_QUIRK(0x17aa, 0x3870, "Lenovo Yoga 7 14ARB7", ALC287_FIXUP_YOGA7_14ARB7_I2C), 10941 SND_PCI_QUIRK(0x17aa, 0x3877, "Lenovo Legion 7 Slim 16ARHA7", ALC287_FIXUP_CS35L41_I2C_2), 10942 SND_PCI_QUIRK(0x17aa, 0x3878, "Lenovo Legion 7 Slim 16ARHA7", ALC287_FIXUP_CS35L41_I2C_2), 10943 SND_PCI_QUIRK(0x17aa, 0x387d, "Yoga S780-16 pro Quad AAC", ALC287_FIXUP_TAS2781_I2C), 10944 SND_PCI_QUIRK(0x17aa, 0x387e, "Yoga S780-16 pro Quad YC", ALC287_FIXUP_TAS2781_I2C), 10945 SND_PCI_QUIRK(0x17aa, 0x387f, "Yoga S780-16 pro dual LX", ALC287_FIXUP_TAS2781_I2C), 10946 SND_PCI_QUIRK(0x17aa, 0x3880, "Yoga S780-16 pro dual YC", ALC287_FIXUP_TAS2781_I2C), 10947 SND_PCI_QUIRK(0x17aa, 0x3881, "YB9 dual power mode2 YC", ALC287_FIXUP_TAS2781_I2C), 10948 SND_PCI_QUIRK(0x17aa, 0x3882, "Lenovo Yoga Pro 7 14APH8", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN), 10949 SND_PCI_QUIRK(0x17aa, 0x3884, "Y780 YG DUAL", ALC287_FIXUP_TAS2781_I2C), 10950 SND_PCI_QUIRK(0x17aa, 0x3886, "Y780 VECO DUAL", ALC287_FIXUP_TAS2781_I2C), 10951 SND_PCI_QUIRK(0x17aa, 0x3891, "Lenovo Yoga Pro 7 14AHP9", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN), 10952 SND_PCI_QUIRK(0x17aa, 0x38a5, "Y580P AMD dual", ALC287_FIXUP_TAS2781_I2C), 10953 SND_PCI_QUIRK(0x17aa, 0x38a7, "Y780P AMD YG dual", ALC287_FIXUP_TAS2781_I2C), 10954 SND_PCI_QUIRK(0x17aa, 0x38a8, "Y780P AMD VECO dual", ALC287_FIXUP_TAS2781_I2C), 10955 SND_PCI_QUIRK(0x17aa, 0x38a9, "Thinkbook 16P", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 10956 SND_PCI_QUIRK(0x17aa, 0x38ab, "Thinkbook 16P", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 10957 SND_PCI_QUIRK(0x17aa, 0x38b4, "Legion Slim 7 16IRH8", ALC287_FIXUP_CS35L41_I2C_2), 10958 SND_PCI_QUIRK(0x17aa, 0x38b5, "Legion Slim 7 16IRH8", ALC287_FIXUP_CS35L41_I2C_2), 10959 SND_PCI_QUIRK(0x17aa, 0x38b6, "Legion Slim 7 16APH8", ALC287_FIXUP_CS35L41_I2C_2), 10960 SND_PCI_QUIRK(0x17aa, 0x38b7, "Legion Slim 7 16APH8", ALC287_FIXUP_CS35L41_I2C_2), 10961 SND_PCI_QUIRK(0x17aa, 0x38b8, "Yoga S780-14.5 proX AMD YC Dual", ALC287_FIXUP_TAS2781_I2C), 10962 SND_PCI_QUIRK(0x17aa, 0x38b9, "Yoga S780-14.5 proX AMD LX Dual", ALC287_FIXUP_TAS2781_I2C), 10963 SND_PCI_QUIRK(0x17aa, 0x38ba, "Yoga S780-14.5 Air AMD quad YC", ALC287_FIXUP_TAS2781_I2C), 10964 SND_PCI_QUIRK(0x17aa, 0x38bb, "Yoga S780-14.5 Air AMD quad AAC", ALC287_FIXUP_TAS2781_I2C), 10965 SND_PCI_QUIRK(0x17aa, 0x38be, "Yoga S980-14.5 proX YC Dual", ALC287_FIXUP_TAS2781_I2C), 10966 SND_PCI_QUIRK(0x17aa, 0x38bf, "Yoga S980-14.5 proX LX Dual", ALC287_FIXUP_TAS2781_I2C), 10967 SND_PCI_QUIRK(0x17aa, 0x38c3, "Y980 DUAL", ALC287_FIXUP_TAS2781_I2C), 10968 SND_PCI_QUIRK(0x17aa, 0x38c7, "Thinkbook 13x Gen 4", ALC287_FIXUP_CS35L41_I2C_4), 10969 SND_PCI_QUIRK(0x17aa, 0x38c8, "Thinkbook 13x Gen 4", ALC287_FIXUP_CS35L41_I2C_4), 10970 SND_PCI_QUIRK(0x17aa, 0x38cb, "Y790 YG DUAL", ALC287_FIXUP_TAS2781_I2C), 10971 SND_PCI_QUIRK(0x17aa, 0x38cd, "Y790 VECO DUAL", ALC287_FIXUP_TAS2781_I2C), 10972 SND_PCI_QUIRK(0x17aa, 0x38d2, "Lenovo Yoga 9 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN), 10973 SND_PCI_QUIRK(0x17aa, 0x38d3, "Yoga S990-16 Pro IMH YC Dual", ALC287_FIXUP_TAS2781_I2C), 10974 SND_PCI_QUIRK(0x17aa, 0x38d4, "Yoga S990-16 Pro IMH VECO Dual", ALC287_FIXUP_TAS2781_I2C), 10975 SND_PCI_QUIRK(0x17aa, 0x38d5, "Yoga S990-16 Pro IMH YC Quad", ALC287_FIXUP_TAS2781_I2C), 10976 SND_PCI_QUIRK(0x17aa, 0x38d6, "Yoga S990-16 Pro IMH VECO Quad", ALC287_FIXUP_TAS2781_I2C), 10977 SND_PCI_QUIRK(0x17aa, 0x38d7, "Lenovo Yoga 9 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN), 10978 SND_PCI_QUIRK(0x17aa, 0x38df, "Yoga Y990 Intel YC Dual", ALC287_FIXUP_TAS2781_I2C), 10979 SND_PCI_QUIRK(0x17aa, 0x38e0, "Yoga Y990 Intel VECO Dual", ALC287_FIXUP_TAS2781_I2C), 10980 SND_PCI_QUIRK(0x17aa, 0x38f8, "Yoga Book 9i", ALC287_FIXUP_TAS2781_I2C), 10981 SND_PCI_QUIRK(0x17aa, 0x38df, "Y990 YG DUAL", ALC287_FIXUP_TAS2781_I2C), 10982 SND_PCI_QUIRK(0x17aa, 0x38f9, "Thinkbook 16P Gen5", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 10983 SND_PCI_QUIRK(0x17aa, 0x38fa, "Thinkbook 16P Gen5", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD), 10984 SND_PCI_QUIRK(0x17aa, 0x38fd, "ThinkBook plus Gen5 Hybrid", ALC287_FIXUP_TAS2781_I2C), 10985 SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI), 10986 SND_PCI_QUIRK(0x17aa, 0x3913, "Lenovo 145", ALC236_FIXUP_LENOVO_INV_DMIC), 10987 SND_PCI_QUIRK(0x17aa, 0x391f, "Yoga S990-16 pro Quad YC Quad", ALC287_FIXUP_TAS2781_I2C), 10988 SND_PCI_QUIRK(0x17aa, 0x3920, "Yoga S990-16 pro Quad VECO Quad", ALC287_FIXUP_TAS2781_I2C), 10989 SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC), 10990 SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI), 10991 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K), 10992 SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 10993 SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC), 10994 SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK), 10995 SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 10996 SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK), 10997 SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK), 10998 SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK), 10999 SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK), 11000 SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE), 11001 SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460), 11002 SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460), 11003 SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460), 11004 SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 11005 SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 11006 SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 11007 SND_PCI_QUIRK(0x17aa, 0x508b, "Thinkpad X12 Gen 1", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS), 11008 SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 11009 SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 11010 SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 11011 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD), 11012 SND_PCI_QUIRK(0x17aa, 0x9e56, "Lenovo ZhaoYang CF4620Z", ALC286_FIXUP_SONY_MIC_NO_PRESENCE), 11013 SND_PCI_QUIRK(0x1849, 0x0269, "Positivo Master C6400", ALC269VB_FIXUP_ASUS_ZENBOOK), 11014 SND_PCI_QUIRK(0x1849, 0x1233, "ASRock NUC Box 1100", ALC233_FIXUP_NO_AUDIO_JACK), 11015 SND_PCI_QUIRK(0x1849, 0xa233, "Positivo Master C6300", ALC269_FIXUP_HEADSET_MIC), 11016 SND_PCI_QUIRK(0x1854, 0x0440, "LG CQ6", ALC256_FIXUP_HEADPHONE_AMP_VOL), 11017 SND_PCI_QUIRK(0x1854, 0x0441, "LG CQ6 AIO", ALC256_FIXUP_HEADPHONE_AMP_VOL), 11018 SND_PCI_QUIRK(0x1854, 0x0488, "LG gram 16 (16Z90R)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS), 11019 SND_PCI_QUIRK(0x1854, 0x048a, "LG gram 17 (17ZD90R)", ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS), 11020 SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS), 11021 SND_PCI_QUIRK(0x19e5, 0x320f, "Huawei WRT-WX9 ", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE), 11022 SND_PCI_QUIRK(0x19e5, 0x3212, "Huawei KLV-WX9 ", ALC256_FIXUP_ACER_HEADSET_MIC), 11023 SND_PCI_QUIRK(0x1b35, 0x1235, "CZC B20", ALC269_FIXUP_CZC_B20), 11024 SND_PCI_QUIRK(0x1b35, 0x1236, "CZC TMI", ALC269_FIXUP_CZC_TMI), 11025 SND_PCI_QUIRK(0x1b35, 0x1237, "CZC L101", ALC269_FIXUP_CZC_L101), 11026 SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */ 11027 SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802), 11028 SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X), 11029 SND_PCI_QUIRK(0x1c6c, 0x122a, "Positivo N14AP7", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 11030 SND_PCI_QUIRK(0x1c6c, 0x1251, "Positivo N14KP6-TG", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE), 11031 SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_SET_COEF_DEFAULTS), 11032 SND_PCI_QUIRK(0x1d05, 0x1096, "TongFang GMxMRxx", ALC269_FIXUP_NO_SHUTUP), 11033 SND_PCI_QUIRK(0x1d05, 0x1100, "TongFang GKxNRxx", ALC269_FIXUP_NO_SHUTUP), 11034 SND_PCI_QUIRK(0x1d05, 0x1111, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP), 11035 SND_PCI_QUIRK(0x1d05, 0x1119, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP), 11036 SND_PCI_QUIRK(0x1d05, 0x1129, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP), 11037 SND_PCI_QUIRK(0x1d05, 0x1147, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP), 11038 SND_PCI_QUIRK(0x1d05, 0x115c, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP), 11039 SND_PCI_QUIRK(0x1d05, 0x121b, "TongFang GMxAGxx", ALC269_FIXUP_NO_SHUTUP), 11040 SND_PCI_QUIRK(0x1d05, 0x1387, "TongFang GMxIXxx", ALC2XX_FIXUP_HEADSET_MIC), 11041 SND_PCI_QUIRK(0x1d05, 0x1409, "TongFang GMxIXxx", ALC2XX_FIXUP_HEADSET_MIC), 11042 SND_PCI_QUIRK(0x1d17, 0x3288, "Haier Boyue G42", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS), 11043 SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC), 11044 SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE), 11045 SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC), 11046 SND_PCI_QUIRK(0x1d72, 0x1945, "Redmi G", ALC256_FIXUP_ASUS_HEADSET_MIC), 11047 SND_PCI_QUIRK(0x1d72, 0x1947, "RedmiBook Air", ALC255_FIXUP_XIAOMI_HEADSET_MIC), 11048 SND_PCI_QUIRK(0x1f66, 0x0105, "Ayaneo Portable Game Player", ALC287_FIXUP_CS35L41_I2C_2), 11049 SND_PCI_QUIRK(0x2014, 0x800a, "Positivo ARN50", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 11050 SND_PCI_QUIRK(0x2782, 0x0214, "VAIO VJFE-CL", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 11051 SND_PCI_QUIRK(0x2782, 0x0228, "Infinix ZERO BOOK 13", ALC269VB_FIXUP_INFINIX_ZERO_BOOK_13), 11052 SND_PCI_QUIRK(0x2782, 0x0232, "CHUWI CoreBook XPro", ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO), 11053 SND_PCI_QUIRK(0x2782, 0x1701, "Infinix Y4 Max", ALC269VC_FIXUP_INFINIX_Y4_MAX), 11054 SND_PCI_QUIRK(0x2782, 0x1705, "MEDION E15433", ALC269VC_FIXUP_INFINIX_Y4_MAX), 11055 SND_PCI_QUIRK(0x2782, 0x1707, "Vaio VJFE-ADL", ALC298_FIXUP_SPK_VOLUME), 11056 SND_PCI_QUIRK(0x2782, 0x4900, "MEDION E15443", ALC233_FIXUP_MEDION_MTL_SPK), 11057 SND_PCI_QUIRK(0x8086, 0x2074, "Intel NUC 8", ALC233_FIXUP_INTEL_NUC8_DMIC), 11058 SND_PCI_QUIRK(0x8086, 0x2080, "Intel NUC 8 Rugged", ALC256_FIXUP_INTEL_NUC8_RUGGED), 11059 SND_PCI_QUIRK(0x8086, 0x2081, "Intel NUC 10", ALC256_FIXUP_INTEL_NUC10), 11060 SND_PCI_QUIRK(0x8086, 0x3038, "Intel NUC 13", ALC295_FIXUP_CHROME_BOOK), 11061 SND_PCI_QUIRK(0xf111, 0x0001, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE), 11062 SND_PCI_QUIRK(0xf111, 0x0006, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE), 11063 SND_PCI_QUIRK(0xf111, 0x0009, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE), 11064 SND_PCI_QUIRK(0xf111, 0x000c, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE), 11065 11066 #if 0 11067 /* Below is a quirk table taken from the old code. 11068 * Basically the device should work as is without the fixup table. 11069 * If BIOS doesn't give a proper info, enable the corresponding 11070 * fixup entry. 11071 */ 11072 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A", 11073 ALC269_FIXUP_AMIC), 11074 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC), 11075 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC), 11076 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC), 11077 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC), 11078 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC), 11079 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC), 11080 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC), 11081 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC), 11082 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC), 11083 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC), 11084 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC), 11085 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC), 11086 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC), 11087 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC), 11088 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC), 11089 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC), 11090 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC), 11091 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC), 11092 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC), 11093 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC), 11094 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC), 11095 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC), 11096 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC), 11097 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC), 11098 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC), 11099 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC), 11100 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC), 11101 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC), 11102 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC), 11103 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC), 11104 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC), 11105 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC), 11106 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC), 11107 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC), 11108 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC), 11109 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC), 11110 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC), 11111 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC), 11112 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC), 11113 #endif 11114 {} 11115 }; 11116 11117 static const struct hda_quirk alc269_fixup_vendor_tbl[] = { 11118 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC), 11119 SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED), 11120 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO), 11121 SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo XPAD", ALC269_FIXUP_LENOVO_XPAD_ACPI), 11122 SND_PCI_QUIRK_VENDOR(0x19e5, "Huawei Matebook", ALC255_FIXUP_MIC_MUTE_LED), 11123 {} 11124 }; 11125 11126 static const struct hda_model_fixup alc269_fixup_models[] = { 11127 {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"}, 11128 {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"}, 11129 {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"}, 11130 {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"}, 11131 {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"}, 11132 {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"}, 11133 {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"}, 11134 {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"}, 11135 {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"}, 11136 {.id = ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, .name = "lenovo-dock-limit-boost"}, 11137 {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"}, 11138 {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"}, 11139 {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"}, 11140 {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"}, 11141 {.id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, .name = "dell-headset3"}, 11142 {.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, .name = "dell-headset4"}, 11143 {.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET, .name = "dell-headset4-quiet"}, 11144 {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"}, 11145 {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"}, 11146 {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"}, 11147 {.id = ALC292_FIXUP_TPT440, .name = "tpt440"}, 11148 {.id = ALC292_FIXUP_TPT460, .name = "tpt460"}, 11149 {.id = ALC298_FIXUP_TPT470_DOCK_FIX, .name = "tpt470-dock-fix"}, 11150 {.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"}, 11151 {.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"}, 11152 {.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"}, 11153 {.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"}, 11154 {.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"}, 11155 {.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"}, 11156 {.id = ALC269_FIXUP_LENOVO_EAPD, .name = "lenovo-eapd"}, 11157 {.id = ALC275_FIXUP_SONY_HWEQ, .name = "sony-hweq"}, 11158 {.id = ALC269_FIXUP_PCM_44K, .name = "pcm44k"}, 11159 {.id = ALC269_FIXUP_LIFEBOOK, .name = "lifebook"}, 11160 {.id = ALC269_FIXUP_LIFEBOOK_EXTMIC, .name = "lifebook-extmic"}, 11161 {.id = ALC269_FIXUP_LIFEBOOK_HP_PIN, .name = "lifebook-hp-pin"}, 11162 {.id = ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, .name = "lifebook-u7x7"}, 11163 {.id = ALC269VB_FIXUP_AMIC, .name = "alc269vb-amic"}, 11164 {.id = ALC269VB_FIXUP_DMIC, .name = "alc269vb-dmic"}, 11165 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC1, .name = "hp-mute-led-mic1"}, 11166 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC2, .name = "hp-mute-led-mic2"}, 11167 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC3, .name = "hp-mute-led-mic3"}, 11168 {.id = ALC269_FIXUP_HP_GPIO_MIC1_LED, .name = "hp-gpio-mic1"}, 11169 {.id = ALC269_FIXUP_HP_LINE1_MIC1_LED, .name = "hp-line1-mic1"}, 11170 {.id = ALC269_FIXUP_NO_SHUTUP, .name = "noshutup"}, 11171 {.id = ALC286_FIXUP_SONY_MIC_NO_PRESENCE, .name = "sony-nomic"}, 11172 {.id = ALC269_FIXUP_ASPIRE_HEADSET_MIC, .name = "aspire-headset-mic"}, 11173 {.id = ALC269_FIXUP_ASUS_X101, .name = "asus-x101"}, 11174 {.id = ALC271_FIXUP_HP_GATE_MIC_JACK, .name = "acer-ao7xx"}, 11175 {.id = ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, .name = "acer-aspire-e1"}, 11176 {.id = ALC269_FIXUP_ACER_AC700, .name = "acer-ac700"}, 11177 {.id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, .name = "limit-mic-boost"}, 11178 {.id = ALC269VB_FIXUP_ASUS_ZENBOOK, .name = "asus-zenbook"}, 11179 {.id = ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, .name = "asus-zenbook-ux31a"}, 11180 {.id = ALC269VB_FIXUP_ORDISSIMO_EVE2, .name = "ordissimo"}, 11181 {.id = ALC282_FIXUP_ASUS_TX300, .name = "asus-tx300"}, 11182 {.id = ALC283_FIXUP_INT_MIC, .name = "alc283-int-mic"}, 11183 {.id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, .name = "mono-speakers"}, 11184 {.id = ALC290_FIXUP_SUBWOOFER_HSJACK, .name = "alc290-subwoofer"}, 11185 {.id = ALC269_FIXUP_THINKPAD_ACPI, .name = "thinkpad"}, 11186 {.id = ALC269_FIXUP_LENOVO_XPAD_ACPI, .name = "lenovo-xpad-led"}, 11187 {.id = ALC269_FIXUP_DMIC_THINKPAD_ACPI, .name = "dmic-thinkpad"}, 11188 {.id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, .name = "alc255-acer"}, 11189 {.id = ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc255-asus"}, 11190 {.id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc255-dell1"}, 11191 {.id = ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "alc255-dell2"}, 11192 {.id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc293-dell1"}, 11193 {.id = ALC283_FIXUP_HEADSET_MIC, .name = "alc283-headset"}, 11194 {.id = ALC255_FIXUP_MIC_MUTE_LED, .name = "alc255-dell-mute"}, 11195 {.id = ALC282_FIXUP_ASPIRE_V5_PINS, .name = "aspire-v5"}, 11196 {.id = ALC269VB_FIXUP_ASPIRE_E1_COEF, .name = "aspire-e1-coef"}, 11197 {.id = ALC280_FIXUP_HP_GPIO4, .name = "hp-gpio4"}, 11198 {.id = ALC286_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"}, 11199 {.id = ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, .name = "hp-gpio2-hotkey"}, 11200 {.id = ALC280_FIXUP_HP_DOCK_PINS, .name = "hp-dock-pins"}, 11201 {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic"}, 11202 {.id = ALC280_FIXUP_HP_9480M, .name = "hp-9480m"}, 11203 {.id = ALC288_FIXUP_DELL_HEADSET_MODE, .name = "alc288-dell-headset"}, 11204 {.id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc288-dell1"}, 11205 {.id = ALC288_FIXUP_DELL_XPS_13, .name = "alc288-dell-xps13"}, 11206 {.id = ALC292_FIXUP_DELL_E7X, .name = "dell-e7x"}, 11207 {.id = ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, .name = "alc293-dell"}, 11208 {.id = ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc298-dell1"}, 11209 {.id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, .name = "alc298-dell-aio"}, 11210 {.id = ALC275_FIXUP_DELL_XPS, .name = "alc275-dell-xps"}, 11211 {.id = ALC293_FIXUP_LENOVO_SPK_NOISE, .name = "lenovo-spk-noise"}, 11212 {.id = ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, .name = "lenovo-hotkey"}, 11213 {.id = ALC255_FIXUP_DELL_SPK_NOISE, .name = "dell-spk-noise"}, 11214 {.id = ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc225-dell1"}, 11215 {.id = ALC295_FIXUP_DISABLE_DAC3, .name = "alc295-disable-dac3"}, 11216 {.id = ALC285_FIXUP_SPEAKER2_TO_DAC1, .name = "alc285-speaker2-to-dac1"}, 11217 {.id = ALC280_FIXUP_HP_HEADSET_MIC, .name = "alc280-hp-headset"}, 11218 {.id = ALC221_FIXUP_HP_FRONT_MIC, .name = "alc221-hp-mic"}, 11219 {.id = ALC298_FIXUP_SPK_VOLUME, .name = "alc298-spk-volume"}, 11220 {.id = ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, .name = "dell-inspiron-7559"}, 11221 {.id = ALC269_FIXUP_ATIV_BOOK_8, .name = "ativ-book"}, 11222 {.id = ALC221_FIXUP_HP_MIC_NO_PRESENCE, .name = "alc221-hp-mic"}, 11223 {.id = ALC256_FIXUP_ASUS_HEADSET_MODE, .name = "alc256-asus-headset"}, 11224 {.id = ALC256_FIXUP_ASUS_MIC, .name = "alc256-asus-mic"}, 11225 {.id = ALC256_FIXUP_ASUS_AIO_GPIO2, .name = "alc256-asus-aio"}, 11226 {.id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc233-asus"}, 11227 {.id = ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, .name = "alc233-eapd"}, 11228 {.id = ALC294_FIXUP_LENOVO_MIC_LOCATION, .name = "alc294-lenovo-mic"}, 11229 {.id = ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, .name = "alc225-wyse"}, 11230 {.id = ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, .name = "alc274-dell-aio"}, 11231 {.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"}, 11232 {.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"}, 11233 {.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"}, 11234 {.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"}, 11235 {.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"}, 11236 {.id = ALC256_FIXUP_CHROME_BOOK, .name = "alc-2024y-chromebook"}, 11237 {.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"}, 11238 {.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"}, 11239 {.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"}, 11240 {.id = ALC298_FIXUP_SAMSUNG_AMP, .name = "alc298-samsung-amp"}, 11241 {.id = ALC298_FIXUP_SAMSUNG_AMP_V2_2_AMPS, .name = "alc298-samsung-amp-v2-2-amps"}, 11242 {.id = ALC298_FIXUP_SAMSUNG_AMP_V2_4_AMPS, .name = "alc298-samsung-amp-v2-4-amps"}, 11243 {.id = ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc256-samsung-headphone"}, 11244 {.id = ALC255_FIXUP_XIAOMI_HEADSET_MIC, .name = "alc255-xiaomi-headset"}, 11245 {.id = ALC274_FIXUP_HP_MIC, .name = "alc274-hp-mic-detect"}, 11246 {.id = ALC245_FIXUP_HP_X360_AMP, .name = "alc245-hp-x360-amp"}, 11247 {.id = ALC295_FIXUP_HP_OMEN, .name = "alc295-hp-omen"}, 11248 {.id = ALC285_FIXUP_HP_SPECTRE_X360, .name = "alc285-hp-spectre-x360"}, 11249 {.id = ALC285_FIXUP_HP_SPECTRE_X360_EB1, .name = "alc285-hp-spectre-x360-eb1"}, 11250 {.id = ALC285_FIXUP_HP_ENVY_X360, .name = "alc285-hp-envy-x360"}, 11251 {.id = ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, .name = "alc287-ideapad-bass-spk-amp"}, 11252 {.id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN, .name = "alc287-yoga9-bass-spk-pin"}, 11253 {.id = ALC623_FIXUP_LENOVO_THINKSTATION_P340, .name = "alc623-lenovo-thinkstation-p340"}, 11254 {.id = ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, .name = "alc255-acer-headphone-and-mic"}, 11255 {.id = ALC285_FIXUP_HP_GPIO_AMP_INIT, .name = "alc285-hp-amp-init"}, 11256 {.id = ALC236_FIXUP_LENOVO_INV_DMIC, .name = "alc236-fixup-lenovo-inv-mic"}, 11257 {.id = ALC2XX_FIXUP_HEADSET_MIC, .name = "alc2xx-fixup-headset-mic"}, 11258 {} 11259 }; 11260 #define ALC225_STANDARD_PINS \ 11261 {0x21, 0x04211020} 11262 11263 #define ALC256_STANDARD_PINS \ 11264 {0x12, 0x90a60140}, \ 11265 {0x14, 0x90170110}, \ 11266 {0x21, 0x02211020} 11267 11268 #define ALC282_STANDARD_PINS \ 11269 {0x14, 0x90170110} 11270 11271 #define ALC290_STANDARD_PINS \ 11272 {0x12, 0x99a30130} 11273 11274 #define ALC292_STANDARD_PINS \ 11275 {0x14, 0x90170110}, \ 11276 {0x15, 0x0221401f} 11277 11278 #define ALC295_STANDARD_PINS \ 11279 {0x12, 0xb7a60130}, \ 11280 {0x14, 0x90170110}, \ 11281 {0x21, 0x04211020} 11282 11283 #define ALC298_STANDARD_PINS \ 11284 {0x12, 0x90a60130}, \ 11285 {0x21, 0x03211020} 11286 11287 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = { 11288 SND_HDA_PIN_QUIRK(0x10ec0221, 0x103c, "HP Workstation", ALC221_FIXUP_HP_HEADSET_MIC, 11289 {0x14, 0x01014020}, 11290 {0x17, 0x90170110}, 11291 {0x18, 0x02a11030}, 11292 {0x19, 0x0181303F}, 11293 {0x21, 0x0221102f}), 11294 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE, 11295 {0x12, 0x90a601c0}, 11296 {0x14, 0x90171120}, 11297 {0x21, 0x02211030}), 11298 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, 11299 {0x14, 0x90170110}, 11300 {0x1b, 0x90a70130}, 11301 {0x21, 0x03211020}), 11302 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, 11303 {0x1a, 0x90a70130}, 11304 {0x1b, 0x90170110}, 11305 {0x21, 0x03211020}), 11306 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 11307 ALC225_STANDARD_PINS, 11308 {0x12, 0xb7a60130}, 11309 {0x14, 0x901701a0}), 11310 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 11311 ALC225_STANDARD_PINS, 11312 {0x12, 0xb7a60130}, 11313 {0x14, 0x901701b0}), 11314 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 11315 ALC225_STANDARD_PINS, 11316 {0x12, 0xb7a60150}, 11317 {0x14, 0x901701a0}), 11318 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 11319 ALC225_STANDARD_PINS, 11320 {0x12, 0xb7a60150}, 11321 {0x14, 0x901701b0}), 11322 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 11323 ALC225_STANDARD_PINS, 11324 {0x12, 0xb7a60130}, 11325 {0x1b, 0x90170110}), 11326 SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 11327 {0x1b, 0x01111010}, 11328 {0x1e, 0x01451130}, 11329 {0x21, 0x02211020}), 11330 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, 11331 {0x12, 0x90a60140}, 11332 {0x14, 0x90170110}, 11333 {0x19, 0x02a11030}, 11334 {0x21, 0x02211020}), 11335 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION, 11336 {0x14, 0x90170110}, 11337 {0x19, 0x02a11030}, 11338 {0x1a, 0x02a11040}, 11339 {0x1b, 0x01014020}, 11340 {0x21, 0x0221101f}), 11341 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION, 11342 {0x14, 0x90170110}, 11343 {0x19, 0x02a11030}, 11344 {0x1a, 0x02a11040}, 11345 {0x1b, 0x01011020}, 11346 {0x21, 0x0221101f}), 11347 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION, 11348 {0x14, 0x90170110}, 11349 {0x19, 0x02a11020}, 11350 {0x1a, 0x02a11030}, 11351 {0x21, 0x0221101f}), 11352 SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC, 11353 {0x21, 0x02211010}), 11354 SND_HDA_PIN_QUIRK(0x10ec0236, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC, 11355 {0x14, 0x90170110}, 11356 {0x19, 0x02a11020}, 11357 {0x21, 0x02211030}), 11358 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, 11359 {0x14, 0x90170110}, 11360 {0x21, 0x02211020}), 11361 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11362 {0x14, 0x90170130}, 11363 {0x21, 0x02211040}), 11364 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11365 {0x12, 0x90a60140}, 11366 {0x14, 0x90170110}, 11367 {0x21, 0x02211020}), 11368 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11369 {0x12, 0x90a60160}, 11370 {0x14, 0x90170120}, 11371 {0x21, 0x02211030}), 11372 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11373 {0x14, 0x90170110}, 11374 {0x1b, 0x02011020}, 11375 {0x21, 0x0221101f}), 11376 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11377 {0x14, 0x90170110}, 11378 {0x1b, 0x01011020}, 11379 {0x21, 0x0221101f}), 11380 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11381 {0x14, 0x90170130}, 11382 {0x1b, 0x01014020}, 11383 {0x21, 0x0221103f}), 11384 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11385 {0x14, 0x90170130}, 11386 {0x1b, 0x01011020}, 11387 {0x21, 0x0221103f}), 11388 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11389 {0x14, 0x90170130}, 11390 {0x1b, 0x02011020}, 11391 {0x21, 0x0221103f}), 11392 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11393 {0x14, 0x90170150}, 11394 {0x1b, 0x02011020}, 11395 {0x21, 0x0221105f}), 11396 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11397 {0x14, 0x90170110}, 11398 {0x1b, 0x01014020}, 11399 {0x21, 0x0221101f}), 11400 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11401 {0x12, 0x90a60160}, 11402 {0x14, 0x90170120}, 11403 {0x17, 0x90170140}, 11404 {0x21, 0x0321102f}), 11405 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11406 {0x12, 0x90a60160}, 11407 {0x14, 0x90170130}, 11408 {0x21, 0x02211040}), 11409 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11410 {0x12, 0x90a60160}, 11411 {0x14, 0x90170140}, 11412 {0x21, 0x02211050}), 11413 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11414 {0x12, 0x90a60170}, 11415 {0x14, 0x90170120}, 11416 {0x21, 0x02211030}), 11417 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11418 {0x12, 0x90a60170}, 11419 {0x14, 0x90170130}, 11420 {0x21, 0x02211040}), 11421 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11422 {0x12, 0x90a60170}, 11423 {0x14, 0x90171130}, 11424 {0x21, 0x02211040}), 11425 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11426 {0x12, 0x90a60170}, 11427 {0x14, 0x90170140}, 11428 {0x21, 0x02211050}), 11429 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11430 {0x12, 0x90a60180}, 11431 {0x14, 0x90170130}, 11432 {0x21, 0x02211040}), 11433 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11434 {0x12, 0x90a60180}, 11435 {0x14, 0x90170120}, 11436 {0x21, 0x02211030}), 11437 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11438 {0x1b, 0x01011020}, 11439 {0x21, 0x02211010}), 11440 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC, 11441 {0x14, 0x90170110}, 11442 {0x1b, 0x90a70130}, 11443 {0x21, 0x04211020}), 11444 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC, 11445 {0x14, 0x90170110}, 11446 {0x1b, 0x90a70130}, 11447 {0x21, 0x03211020}), 11448 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE, 11449 {0x12, 0x90a60130}, 11450 {0x14, 0x90170110}, 11451 {0x21, 0x03211020}), 11452 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE, 11453 {0x12, 0x90a60130}, 11454 {0x14, 0x90170110}, 11455 {0x21, 0x04211020}), 11456 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE, 11457 {0x1a, 0x90a70130}, 11458 {0x1b, 0x90170110}, 11459 {0x21, 0x03211020}), 11460 SND_HDA_PIN_QUIRK(0x10ec0256, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC, 11461 {0x14, 0x90170110}, 11462 {0x19, 0x02a11020}, 11463 {0x21, 0x0221101f}), 11464 SND_HDA_PIN_QUIRK(0x10ec0274, 0x103c, "HP", ALC274_FIXUP_HP_HEADSET_MIC, 11465 {0x17, 0x90170110}, 11466 {0x19, 0x03a11030}, 11467 {0x21, 0x03211020}), 11468 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4, 11469 {0x12, 0x90a60130}, 11470 {0x14, 0x90170110}, 11471 {0x15, 0x0421101f}, 11472 {0x1a, 0x04a11020}), 11473 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED, 11474 {0x12, 0x90a60140}, 11475 {0x14, 0x90170110}, 11476 {0x15, 0x0421101f}, 11477 {0x18, 0x02811030}, 11478 {0x1a, 0x04a1103f}, 11479 {0x1b, 0x02011020}), 11480 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1, 11481 ALC282_STANDARD_PINS, 11482 {0x12, 0x99a30130}, 11483 {0x19, 0x03a11020}, 11484 {0x21, 0x0321101f}), 11485 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 11486 ALC282_STANDARD_PINS, 11487 {0x12, 0x99a30130}, 11488 {0x19, 0x03a11020}, 11489 {0x21, 0x03211040}), 11490 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 11491 ALC282_STANDARD_PINS, 11492 {0x12, 0x99a30130}, 11493 {0x19, 0x03a11030}, 11494 {0x21, 0x03211020}), 11495 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 11496 ALC282_STANDARD_PINS, 11497 {0x12, 0x99a30130}, 11498 {0x19, 0x04a11020}, 11499 {0x21, 0x0421101f}), 11500 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED, 11501 ALC282_STANDARD_PINS, 11502 {0x12, 0x90a60140}, 11503 {0x19, 0x04a11030}, 11504 {0x21, 0x04211020}), 11505 SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT, 11506 ALC282_STANDARD_PINS, 11507 {0x12, 0x90a609c0}, 11508 {0x18, 0x03a11830}, 11509 {0x19, 0x04a19831}, 11510 {0x1a, 0x0481303f}, 11511 {0x1b, 0x04211020}, 11512 {0x21, 0x0321101f}), 11513 SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT, 11514 ALC282_STANDARD_PINS, 11515 {0x12, 0x90a60940}, 11516 {0x18, 0x03a11830}, 11517 {0x19, 0x04a19831}, 11518 {0x1a, 0x0481303f}, 11519 {0x1b, 0x04211020}, 11520 {0x21, 0x0321101f}), 11521 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 11522 ALC282_STANDARD_PINS, 11523 {0x12, 0x90a60130}, 11524 {0x21, 0x0321101f}), 11525 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 11526 {0x12, 0x90a60160}, 11527 {0x14, 0x90170120}, 11528 {0x21, 0x02211030}), 11529 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 11530 ALC282_STANDARD_PINS, 11531 {0x12, 0x90a60130}, 11532 {0x19, 0x03a11020}, 11533 {0x21, 0x0321101f}), 11534 SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE, 11535 {0x12, 0x90a60130}, 11536 {0x14, 0x90170110}, 11537 {0x19, 0x04a11040}, 11538 {0x21, 0x04211020}), 11539 SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE, 11540 {0x14, 0x90170110}, 11541 {0x19, 0x04a11040}, 11542 {0x1d, 0x40600001}, 11543 {0x21, 0x04211020}), 11544 SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK, 11545 {0x14, 0x90170110}, 11546 {0x19, 0x04a11040}, 11547 {0x21, 0x04211020}), 11548 SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_HEADSET_JACK, 11549 {0x14, 0x90170110}, 11550 {0x17, 0x90170111}, 11551 {0x19, 0x03a11030}, 11552 {0x21, 0x03211020}), 11553 SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK, 11554 {0x17, 0x90170110}, 11555 {0x19, 0x03a11030}, 11556 {0x21, 0x03211020}), 11557 SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK, 11558 {0x17, 0x90170110}, /* 0x231f with RTK I2S AMP */ 11559 {0x19, 0x04a11040}, 11560 {0x21, 0x04211020}), 11561 SND_HDA_PIN_QUIRK(0x10ec0286, 0x1025, "Acer", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE, 11562 {0x12, 0x90a60130}, 11563 {0x17, 0x90170110}, 11564 {0x21, 0x02211020}), 11565 SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, 11566 {0x12, 0x90a60120}, 11567 {0x14, 0x90170110}, 11568 {0x21, 0x0321101f}), 11569 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 11570 ALC290_STANDARD_PINS, 11571 {0x15, 0x04211040}, 11572 {0x18, 0x90170112}, 11573 {0x1a, 0x04a11020}), 11574 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 11575 ALC290_STANDARD_PINS, 11576 {0x15, 0x04211040}, 11577 {0x18, 0x90170110}, 11578 {0x1a, 0x04a11020}), 11579 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 11580 ALC290_STANDARD_PINS, 11581 {0x15, 0x0421101f}, 11582 {0x1a, 0x04a11020}), 11583 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 11584 ALC290_STANDARD_PINS, 11585 {0x15, 0x04211020}, 11586 {0x1a, 0x04a11040}), 11587 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 11588 ALC290_STANDARD_PINS, 11589 {0x14, 0x90170110}, 11590 {0x15, 0x04211020}, 11591 {0x1a, 0x04a11040}), 11592 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 11593 ALC290_STANDARD_PINS, 11594 {0x14, 0x90170110}, 11595 {0x15, 0x04211020}, 11596 {0x1a, 0x04a11020}), 11597 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 11598 ALC290_STANDARD_PINS, 11599 {0x14, 0x90170110}, 11600 {0x15, 0x0421101f}, 11601 {0x1a, 0x04a11020}), 11602 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, 11603 ALC292_STANDARD_PINS, 11604 {0x12, 0x90a60140}, 11605 {0x16, 0x01014020}, 11606 {0x19, 0x01a19030}), 11607 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, 11608 ALC292_STANDARD_PINS, 11609 {0x12, 0x90a60140}, 11610 {0x16, 0x01014020}, 11611 {0x18, 0x02a19031}, 11612 {0x19, 0x01a1903e}), 11613 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, 11614 ALC292_STANDARD_PINS, 11615 {0x12, 0x90a60140}), 11616 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, 11617 ALC292_STANDARD_PINS, 11618 {0x13, 0x90a60140}, 11619 {0x16, 0x21014020}, 11620 {0x19, 0x21a19030}), 11621 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, 11622 ALC292_STANDARD_PINS, 11623 {0x13, 0x90a60140}), 11624 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_HPE, 11625 {0x17, 0x90170110}, 11626 {0x21, 0x04211020}), 11627 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC, 11628 {0x14, 0x90170110}, 11629 {0x1b, 0x90a70130}, 11630 {0x21, 0x04211020}), 11631 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK, 11632 {0x12, 0x90a60130}, 11633 {0x17, 0x90170110}, 11634 {0x21, 0x03211020}), 11635 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK, 11636 {0x12, 0x90a60130}, 11637 {0x17, 0x90170110}, 11638 {0x21, 0x04211020}), 11639 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK, 11640 {0x12, 0x90a60130}, 11641 {0x17, 0x90170110}, 11642 {0x21, 0x03211020}), 11643 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, 11644 {0x12, 0x90a60120}, 11645 {0x17, 0x90170110}, 11646 {0x21, 0x04211030}), 11647 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, 11648 {0x12, 0x90a60130}, 11649 {0x17, 0x90170110}, 11650 {0x21, 0x03211020}), 11651 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, 11652 {0x12, 0x90a60130}, 11653 {0x17, 0x90170110}, 11654 {0x21, 0x03211020}), 11655 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 11656 ALC298_STANDARD_PINS, 11657 {0x17, 0x90170110}), 11658 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 11659 ALC298_STANDARD_PINS, 11660 {0x17, 0x90170140}), 11661 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 11662 ALC298_STANDARD_PINS, 11663 {0x17, 0x90170150}), 11664 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME, 11665 {0x12, 0xb7a60140}, 11666 {0x13, 0xb7a60150}, 11667 {0x17, 0x90170110}, 11668 {0x1a, 0x03011020}, 11669 {0x21, 0x03211030}), 11670 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE, 11671 {0x12, 0xb7a60140}, 11672 {0x17, 0x90170110}, 11673 {0x1a, 0x03a11030}, 11674 {0x21, 0x03211020}), 11675 SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 11676 ALC225_STANDARD_PINS, 11677 {0x12, 0xb7a60130}, 11678 {0x17, 0x90170110}), 11679 SND_HDA_PIN_QUIRK(0x10ec0623, 0x17aa, "Lenovo", ALC283_FIXUP_HEADSET_MIC, 11680 {0x14, 0x01014010}, 11681 {0x17, 0x90170120}, 11682 {0x18, 0x02a11030}, 11683 {0x19, 0x02a1103f}, 11684 {0x21, 0x0221101f}), 11685 {} 11686 }; 11687 11688 /* This is the fallback pin_fixup_tbl for alc269 family, to make the tbl match 11689 * more machines, don't need to match all valid pins, just need to match 11690 * all the pins defined in the tbl. Just because of this reason, it is possible 11691 * that a single machine matches multiple tbls, so there is one limitation: 11692 * at most one tbl is allowed to define for the same vendor and same codec 11693 */ 11694 static const struct snd_hda_pin_quirk alc269_fallback_pin_fixup_tbl[] = { 11695 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1025, "Acer", ALC2XX_FIXUP_HEADSET_MIC, 11696 {0x19, 0x40000000}), 11697 SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 11698 {0x19, 0x40000000}, 11699 {0x1b, 0x40000000}), 11700 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET, 11701 {0x19, 0x40000000}, 11702 {0x1b, 0x40000000}), 11703 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 11704 {0x19, 0x40000000}, 11705 {0x1a, 0x40000000}), 11706 SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_LIMIT_INT_MIC_BOOST, 11707 {0x19, 0x40000000}, 11708 {0x1a, 0x40000000}), 11709 SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC269_FIXUP_DELL1_LIMIT_INT_MIC_BOOST, 11710 {0x19, 0x40000000}, 11711 {0x1a, 0x40000000}), 11712 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC2XX_FIXUP_HEADSET_MIC, 11713 {0x19, 0x40000000}), 11714 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1558, "Clevo", ALC2XX_FIXUP_HEADSET_MIC, 11715 {0x19, 0x40000000}), 11716 {} 11717 }; 11718 11719 static void alc269_fill_coef(struct hda_codec *codec) 11720 { 11721 struct alc_spec *spec = codec->spec; 11722 int val; 11723 11724 if (spec->codec_variant != ALC269_TYPE_ALC269VB) 11725 return; 11726 11727 if ((alc_get_coef0(codec) & 0x00ff) < 0x015) { 11728 alc_write_coef_idx(codec, 0xf, 0x960b); 11729 alc_write_coef_idx(codec, 0xe, 0x8817); 11730 } 11731 11732 if ((alc_get_coef0(codec) & 0x00ff) == 0x016) { 11733 alc_write_coef_idx(codec, 0xf, 0x960b); 11734 alc_write_coef_idx(codec, 0xe, 0x8814); 11735 } 11736 11737 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) { 11738 /* Power up output pin */ 11739 alc_update_coef_idx(codec, 0x04, 0, 1<<11); 11740 } 11741 11742 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) { 11743 val = alc_read_coef_idx(codec, 0xd); 11744 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) { 11745 /* Capless ramp up clock control */ 11746 alc_write_coef_idx(codec, 0xd, val | (1<<10)); 11747 } 11748 val = alc_read_coef_idx(codec, 0x17); 11749 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) { 11750 /* Class D power on reset */ 11751 alc_write_coef_idx(codec, 0x17, val | (1<<7)); 11752 } 11753 } 11754 11755 /* HP */ 11756 alc_update_coef_idx(codec, 0x4, 0, 1<<11); 11757 } 11758 11759 /* 11760 */ 11761 static int patch_alc269(struct hda_codec *codec) 11762 { 11763 struct alc_spec *spec; 11764 int err; 11765 11766 err = alc_alloc_spec(codec, 0x0b); 11767 if (err < 0) 11768 return err; 11769 11770 spec = codec->spec; 11771 spec->gen.shared_mic_vref_pin = 0x18; 11772 codec->power_save_node = 0; 11773 spec->en_3kpull_low = true; 11774 11775 codec->patch_ops.suspend = alc269_suspend; 11776 codec->patch_ops.resume = alc269_resume; 11777 spec->shutup = alc_default_shutup; 11778 spec->init_hook = alc_default_init; 11779 11780 switch (codec->core.vendor_id) { 11781 case 0x10ec0269: 11782 spec->codec_variant = ALC269_TYPE_ALC269VA; 11783 switch (alc_get_coef0(codec) & 0x00f0) { 11784 case 0x0010: 11785 if (codec->bus->pci && 11786 codec->bus->pci->subsystem_vendor == 0x1025 && 11787 spec->cdefine.platform_type == 1) 11788 err = alc_codec_rename(codec, "ALC271X"); 11789 spec->codec_variant = ALC269_TYPE_ALC269VB; 11790 break; 11791 case 0x0020: 11792 if (codec->bus->pci && 11793 codec->bus->pci->subsystem_vendor == 0x17aa && 11794 codec->bus->pci->subsystem_device == 0x21f3) 11795 err = alc_codec_rename(codec, "ALC3202"); 11796 spec->codec_variant = ALC269_TYPE_ALC269VC; 11797 break; 11798 case 0x0030: 11799 spec->codec_variant = ALC269_TYPE_ALC269VD; 11800 break; 11801 default: 11802 alc_fix_pll_init(codec, 0x20, 0x04, 15); 11803 } 11804 if (err < 0) 11805 goto error; 11806 spec->shutup = alc269_shutup; 11807 spec->init_hook = alc269_fill_coef; 11808 alc269_fill_coef(codec); 11809 break; 11810 11811 case 0x10ec0280: 11812 case 0x10ec0290: 11813 spec->codec_variant = ALC269_TYPE_ALC280; 11814 break; 11815 case 0x10ec0282: 11816 spec->codec_variant = ALC269_TYPE_ALC282; 11817 spec->shutup = alc282_shutup; 11818 spec->init_hook = alc282_init; 11819 break; 11820 case 0x10ec0233: 11821 case 0x10ec0283: 11822 spec->codec_variant = ALC269_TYPE_ALC283; 11823 spec->shutup = alc283_shutup; 11824 spec->init_hook = alc283_init; 11825 break; 11826 case 0x10ec0284: 11827 case 0x10ec0292: 11828 spec->codec_variant = ALC269_TYPE_ALC284; 11829 break; 11830 case 0x10ec0293: 11831 spec->codec_variant = ALC269_TYPE_ALC293; 11832 break; 11833 case 0x10ec0286: 11834 case 0x10ec0288: 11835 spec->codec_variant = ALC269_TYPE_ALC286; 11836 break; 11837 case 0x10ec0298: 11838 spec->codec_variant = ALC269_TYPE_ALC298; 11839 break; 11840 case 0x10ec0235: 11841 case 0x10ec0255: 11842 spec->codec_variant = ALC269_TYPE_ALC255; 11843 spec->shutup = alc256_shutup; 11844 spec->init_hook = alc256_init; 11845 break; 11846 case 0x10ec0230: 11847 case 0x10ec0236: 11848 case 0x10ec0256: 11849 case 0x19e58326: 11850 spec->codec_variant = ALC269_TYPE_ALC256; 11851 spec->shutup = alc256_shutup; 11852 spec->init_hook = alc256_init; 11853 spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */ 11854 if (codec->core.vendor_id == 0x10ec0236 && 11855 codec->bus->pci->vendor != PCI_VENDOR_ID_AMD) 11856 spec->en_3kpull_low = false; 11857 break; 11858 case 0x10ec0257: 11859 spec->codec_variant = ALC269_TYPE_ALC257; 11860 spec->shutup = alc256_shutup; 11861 spec->init_hook = alc256_init; 11862 spec->gen.mixer_nid = 0; 11863 spec->en_3kpull_low = false; 11864 break; 11865 case 0x10ec0215: 11866 case 0x10ec0245: 11867 case 0x10ec0285: 11868 case 0x10ec0289: 11869 if (alc_get_coef0(codec) & 0x0010) 11870 spec->codec_variant = ALC269_TYPE_ALC245; 11871 else 11872 spec->codec_variant = ALC269_TYPE_ALC215; 11873 spec->shutup = alc225_shutup; 11874 spec->init_hook = alc225_init; 11875 spec->gen.mixer_nid = 0; 11876 break; 11877 case 0x10ec0225: 11878 case 0x10ec0295: 11879 case 0x10ec0299: 11880 spec->codec_variant = ALC269_TYPE_ALC225; 11881 spec->shutup = alc225_shutup; 11882 spec->init_hook = alc225_init; 11883 spec->gen.mixer_nid = 0; /* no loopback on ALC225, ALC295 and ALC299 */ 11884 break; 11885 case 0x10ec0287: 11886 spec->codec_variant = ALC269_TYPE_ALC287; 11887 spec->shutup = alc225_shutup; 11888 spec->init_hook = alc225_init; 11889 spec->gen.mixer_nid = 0; /* no loopback on ALC287 */ 11890 break; 11891 case 0x10ec0234: 11892 case 0x10ec0274: 11893 case 0x10ec0294: 11894 spec->codec_variant = ALC269_TYPE_ALC294; 11895 spec->gen.mixer_nid = 0; /* ALC2x4 does not have any loopback mixer path */ 11896 alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3)); /* UAJ MIC Vref control by verb */ 11897 spec->init_hook = alc294_init; 11898 break; 11899 case 0x10ec0300: 11900 spec->codec_variant = ALC269_TYPE_ALC300; 11901 spec->gen.mixer_nid = 0; /* no loopback on ALC300 */ 11902 break; 11903 case 0x10ec0623: 11904 spec->codec_variant = ALC269_TYPE_ALC623; 11905 break; 11906 case 0x10ec0700: 11907 case 0x10ec0701: 11908 case 0x10ec0703: 11909 case 0x10ec0711: 11910 spec->codec_variant = ALC269_TYPE_ALC700; 11911 spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */ 11912 alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */ 11913 spec->init_hook = alc294_init; 11914 break; 11915 11916 } 11917 11918 if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) { 11919 spec->has_alc5505_dsp = 1; 11920 spec->init_hook = alc5505_dsp_init; 11921 } 11922 11923 alc_pre_init(codec); 11924 11925 snd_hda_pick_fixup(codec, alc269_fixup_models, 11926 alc269_fixup_tbl, alc269_fixups); 11927 /* FIXME: both TX300 and ROG Strix G17 have the same SSID, and 11928 * the quirk breaks the latter (bko#214101). 11929 * Clear the wrong entry. 11930 */ 11931 if (codec->fixup_id == ALC282_FIXUP_ASUS_TX300 && 11932 codec->core.vendor_id == 0x10ec0294) { 11933 codec_dbg(codec, "Clear wrong fixup for ASUS ROG Strix G17\n"); 11934 codec->fixup_id = HDA_FIXUP_ID_NOT_SET; 11935 } 11936 11937 snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups, true); 11938 snd_hda_pick_pin_fixup(codec, alc269_fallback_pin_fixup_tbl, alc269_fixups, false); 11939 snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl, 11940 alc269_fixups); 11941 11942 /* 11943 * Check whether ACPI describes companion amplifiers that require 11944 * component binding 11945 */ 11946 find_cirrus_companion_amps(codec); 11947 11948 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 11949 11950 alc_auto_parse_customize_define(codec); 11951 11952 if (has_cdefine_beep(codec)) 11953 spec->gen.beep_nid = 0x01; 11954 11955 /* automatic parse from the BIOS config */ 11956 err = alc269_parse_auto_config(codec); 11957 if (err < 0) 11958 goto error; 11959 11960 if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) { 11961 err = set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT); 11962 if (err < 0) 11963 goto error; 11964 } 11965 11966 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 11967 11968 return 0; 11969 11970 error: 11971 alc_free(codec); 11972 return err; 11973 } 11974 11975 /* 11976 * ALC861 11977 */ 11978 11979 static int alc861_parse_auto_config(struct hda_codec *codec) 11980 { 11981 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 }; 11982 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 }; 11983 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids); 11984 } 11985 11986 /* Pin config fixes */ 11987 enum { 11988 ALC861_FIXUP_FSC_AMILO_PI1505, 11989 ALC861_FIXUP_AMP_VREF_0F, 11990 ALC861_FIXUP_NO_JACK_DETECT, 11991 ALC861_FIXUP_ASUS_A6RP, 11992 ALC660_FIXUP_ASUS_W7J, 11993 }; 11994 11995 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */ 11996 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec, 11997 const struct hda_fixup *fix, int action) 11998 { 11999 struct alc_spec *spec = codec->spec; 12000 unsigned int val; 12001 12002 if (action != HDA_FIXUP_ACT_INIT) 12003 return; 12004 val = snd_hda_codec_get_pin_target(codec, 0x0f); 12005 if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))) 12006 val |= AC_PINCTL_IN_EN; 12007 val |= AC_PINCTL_VREF_50; 12008 snd_hda_set_pin_ctl(codec, 0x0f, val); 12009 spec->gen.keep_vref_in_automute = 1; 12010 } 12011 12012 /* suppress the jack-detection */ 12013 static void alc_fixup_no_jack_detect(struct hda_codec *codec, 12014 const struct hda_fixup *fix, int action) 12015 { 12016 if (action == HDA_FIXUP_ACT_PRE_PROBE) 12017 codec->no_jack_detect = 1; 12018 } 12019 12020 static const struct hda_fixup alc861_fixups[] = { 12021 [ALC861_FIXUP_FSC_AMILO_PI1505] = { 12022 .type = HDA_FIXUP_PINS, 12023 .v.pins = (const struct hda_pintbl[]) { 12024 { 0x0b, 0x0221101f }, /* HP */ 12025 { 0x0f, 0x90170310 }, /* speaker */ 12026 { } 12027 } 12028 }, 12029 [ALC861_FIXUP_AMP_VREF_0F] = { 12030 .type = HDA_FIXUP_FUNC, 12031 .v.func = alc861_fixup_asus_amp_vref_0f, 12032 }, 12033 [ALC861_FIXUP_NO_JACK_DETECT] = { 12034 .type = HDA_FIXUP_FUNC, 12035 .v.func = alc_fixup_no_jack_detect, 12036 }, 12037 [ALC861_FIXUP_ASUS_A6RP] = { 12038 .type = HDA_FIXUP_FUNC, 12039 .v.func = alc861_fixup_asus_amp_vref_0f, 12040 .chained = true, 12041 .chain_id = ALC861_FIXUP_NO_JACK_DETECT, 12042 }, 12043 [ALC660_FIXUP_ASUS_W7J] = { 12044 .type = HDA_FIXUP_VERBS, 12045 .v.verbs = (const struct hda_verb[]) { 12046 /* ASUS W7J needs a magic pin setup on unused NID 0x10 12047 * for enabling outputs 12048 */ 12049 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 12050 { } 12051 }, 12052 } 12053 }; 12054 12055 static const struct hda_quirk alc861_fixup_tbl[] = { 12056 SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J), 12057 SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J), 12058 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP), 12059 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F), 12060 SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT), 12061 SND_PCI_QUIRK_VENDOR(0x1584, "Haier/Uniwill", ALC861_FIXUP_AMP_VREF_0F), 12062 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505), 12063 {} 12064 }; 12065 12066 /* 12067 */ 12068 static int patch_alc861(struct hda_codec *codec) 12069 { 12070 struct alc_spec *spec; 12071 int err; 12072 12073 err = alc_alloc_spec(codec, 0x15); 12074 if (err < 0) 12075 return err; 12076 12077 spec = codec->spec; 12078 if (has_cdefine_beep(codec)) 12079 spec->gen.beep_nid = 0x23; 12080 12081 spec->power_hook = alc_power_eapd; 12082 12083 alc_pre_init(codec); 12084 12085 snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups); 12086 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 12087 12088 /* automatic parse from the BIOS config */ 12089 err = alc861_parse_auto_config(codec); 12090 if (err < 0) 12091 goto error; 12092 12093 if (!spec->gen.no_analog) { 12094 err = set_beep_amp(spec, 0x23, 0, HDA_OUTPUT); 12095 if (err < 0) 12096 goto error; 12097 } 12098 12099 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 12100 12101 return 0; 12102 12103 error: 12104 alc_free(codec); 12105 return err; 12106 } 12107 12108 /* 12109 * ALC861-VD support 12110 * 12111 * Based on ALC882 12112 * 12113 * In addition, an independent DAC 12114 */ 12115 static int alc861vd_parse_auto_config(struct hda_codec *codec) 12116 { 12117 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 }; 12118 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 12119 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids); 12120 } 12121 12122 enum { 12123 ALC660VD_FIX_ASUS_GPIO1, 12124 ALC861VD_FIX_DALLAS, 12125 }; 12126 12127 /* exclude VREF80 */ 12128 static void alc861vd_fixup_dallas(struct hda_codec *codec, 12129 const struct hda_fixup *fix, int action) 12130 { 12131 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 12132 snd_hda_override_pin_caps(codec, 0x18, 0x00000734); 12133 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c); 12134 } 12135 } 12136 12137 /* reset GPIO1 */ 12138 static void alc660vd_fixup_asus_gpio1(struct hda_codec *codec, 12139 const struct hda_fixup *fix, int action) 12140 { 12141 struct alc_spec *spec = codec->spec; 12142 12143 if (action == HDA_FIXUP_ACT_PRE_PROBE) 12144 spec->gpio_mask |= 0x02; 12145 alc_fixup_gpio(codec, action, 0x01); 12146 } 12147 12148 static const struct hda_fixup alc861vd_fixups[] = { 12149 [ALC660VD_FIX_ASUS_GPIO1] = { 12150 .type = HDA_FIXUP_FUNC, 12151 .v.func = alc660vd_fixup_asus_gpio1, 12152 }, 12153 [ALC861VD_FIX_DALLAS] = { 12154 .type = HDA_FIXUP_FUNC, 12155 .v.func = alc861vd_fixup_dallas, 12156 }, 12157 }; 12158 12159 static const struct hda_quirk alc861vd_fixup_tbl[] = { 12160 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS), 12161 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1), 12162 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS), 12163 {} 12164 }; 12165 12166 /* 12167 */ 12168 static int patch_alc861vd(struct hda_codec *codec) 12169 { 12170 struct alc_spec *spec; 12171 int err; 12172 12173 err = alc_alloc_spec(codec, 0x0b); 12174 if (err < 0) 12175 return err; 12176 12177 spec = codec->spec; 12178 if (has_cdefine_beep(codec)) 12179 spec->gen.beep_nid = 0x23; 12180 12181 spec->shutup = alc_eapd_shutup; 12182 12183 alc_pre_init(codec); 12184 12185 snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups); 12186 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 12187 12188 /* automatic parse from the BIOS config */ 12189 err = alc861vd_parse_auto_config(codec); 12190 if (err < 0) 12191 goto error; 12192 12193 if (!spec->gen.no_analog) { 12194 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 12195 if (err < 0) 12196 goto error; 12197 } 12198 12199 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 12200 12201 return 0; 12202 12203 error: 12204 alc_free(codec); 12205 return err; 12206 } 12207 12208 /* 12209 * ALC662 support 12210 * 12211 * ALC662 is almost identical with ALC880 but has cleaner and more flexible 12212 * configuration. Each pin widget can choose any input DACs and a mixer. 12213 * Each ADC is connected from a mixer of all inputs. This makes possible 12214 * 6-channel independent captures. 12215 * 12216 * In addition, an independent DAC for the multi-playback (not used in this 12217 * driver yet). 12218 */ 12219 12220 /* 12221 * BIOS auto configuration 12222 */ 12223 12224 static int alc662_parse_auto_config(struct hda_codec *codec) 12225 { 12226 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 }; 12227 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 }; 12228 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 12229 const hda_nid_t *ssids; 12230 12231 if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 || 12232 codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 || 12233 codec->core.vendor_id == 0x10ec0671) 12234 ssids = alc663_ssids; 12235 else 12236 ssids = alc662_ssids; 12237 return alc_parse_auto_config(codec, alc662_ignore, ssids); 12238 } 12239 12240 static void alc272_fixup_mario(struct hda_codec *codec, 12241 const struct hda_fixup *fix, int action) 12242 { 12243 if (action != HDA_FIXUP_ACT_PRE_PROBE) 12244 return; 12245 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT, 12246 (0x3b << AC_AMPCAP_OFFSET_SHIFT) | 12247 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) | 12248 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) | 12249 (0 << AC_AMPCAP_MUTE_SHIFT))) 12250 codec_warn(codec, "failed to override amp caps for NID 0x2\n"); 12251 } 12252 12253 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = { 12254 { .channels = 2, 12255 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } }, 12256 { .channels = 4, 12257 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, 12258 SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */ 12259 { } 12260 }; 12261 12262 /* override the 2.1 chmap */ 12263 static void alc_fixup_bass_chmap(struct hda_codec *codec, 12264 const struct hda_fixup *fix, int action) 12265 { 12266 if (action == HDA_FIXUP_ACT_BUILD) { 12267 struct alc_spec *spec = codec->spec; 12268 spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps; 12269 } 12270 } 12271 12272 /* avoid D3 for keeping GPIO up */ 12273 static unsigned int gpio_led_power_filter(struct hda_codec *codec, 12274 hda_nid_t nid, 12275 unsigned int power_state) 12276 { 12277 struct alc_spec *spec = codec->spec; 12278 if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_data) 12279 return AC_PWRST_D0; 12280 return power_state; 12281 } 12282 12283 static void alc662_fixup_led_gpio1(struct hda_codec *codec, 12284 const struct hda_fixup *fix, int action) 12285 { 12286 struct alc_spec *spec = codec->spec; 12287 12288 alc_fixup_hp_gpio_led(codec, action, 0x01, 0); 12289 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 12290 spec->mute_led_polarity = 1; 12291 codec->power_filter = gpio_led_power_filter; 12292 } 12293 } 12294 12295 static void alc662_usi_automute_hook(struct hda_codec *codec, 12296 struct hda_jack_callback *jack) 12297 { 12298 struct alc_spec *spec = codec->spec; 12299 int vref; 12300 msleep(200); 12301 snd_hda_gen_hp_automute(codec, jack); 12302 12303 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0; 12304 msleep(100); 12305 snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 12306 vref); 12307 } 12308 12309 static void alc662_fixup_usi_headset_mic(struct hda_codec *codec, 12310 const struct hda_fixup *fix, int action) 12311 { 12312 struct alc_spec *spec = codec->spec; 12313 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 12314 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 12315 spec->gen.hp_automute_hook = alc662_usi_automute_hook; 12316 } 12317 } 12318 12319 static void alc662_aspire_ethos_mute_speakers(struct hda_codec *codec, 12320 struct hda_jack_callback *cb) 12321 { 12322 /* surround speakers at 0x1b already get muted automatically when 12323 * headphones are plugged in, but we have to mute/unmute the remaining 12324 * channels manually: 12325 * 0x15 - front left/front right 12326 * 0x18 - front center/ LFE 12327 */ 12328 if (snd_hda_jack_detect_state(codec, 0x1b) == HDA_JACK_PRESENT) { 12329 snd_hda_set_pin_ctl_cache(codec, 0x15, 0); 12330 snd_hda_set_pin_ctl_cache(codec, 0x18, 0); 12331 } else { 12332 snd_hda_set_pin_ctl_cache(codec, 0x15, PIN_OUT); 12333 snd_hda_set_pin_ctl_cache(codec, 0x18, PIN_OUT); 12334 } 12335 } 12336 12337 static void alc662_fixup_aspire_ethos_hp(struct hda_codec *codec, 12338 const struct hda_fixup *fix, int action) 12339 { 12340 /* Pin 0x1b: shared headphones jack and surround speakers */ 12341 if (!is_jack_detectable(codec, 0x1b)) 12342 return; 12343 12344 switch (action) { 12345 case HDA_FIXUP_ACT_PRE_PROBE: 12346 snd_hda_jack_detect_enable_callback(codec, 0x1b, 12347 alc662_aspire_ethos_mute_speakers); 12348 /* subwoofer needs an extra GPIO setting to become audible */ 12349 alc_setup_gpio(codec, 0x02); 12350 break; 12351 case HDA_FIXUP_ACT_INIT: 12352 /* Make sure to start in a correct state, i.e. if 12353 * headphones have been plugged in before powering up the system 12354 */ 12355 alc662_aspire_ethos_mute_speakers(codec, NULL); 12356 break; 12357 } 12358 } 12359 12360 static void alc671_fixup_hp_headset_mic2(struct hda_codec *codec, 12361 const struct hda_fixup *fix, int action) 12362 { 12363 struct alc_spec *spec = codec->spec; 12364 12365 static const struct hda_pintbl pincfgs[] = { 12366 { 0x19, 0x02a11040 }, /* use as headset mic, with its own jack detect */ 12367 { 0x1b, 0x0181304f }, 12368 { } 12369 }; 12370 12371 switch (action) { 12372 case HDA_FIXUP_ACT_PRE_PROBE: 12373 spec->gen.mixer_nid = 0; 12374 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 12375 snd_hda_apply_pincfgs(codec, pincfgs); 12376 break; 12377 case HDA_FIXUP_ACT_INIT: 12378 alc_write_coef_idx(codec, 0x19, 0xa054); 12379 break; 12380 } 12381 } 12382 12383 static void alc897_hp_automute_hook(struct hda_codec *codec, 12384 struct hda_jack_callback *jack) 12385 { 12386 struct alc_spec *spec = codec->spec; 12387 int vref; 12388 12389 snd_hda_gen_hp_automute(codec, jack); 12390 vref = spec->gen.hp_jack_present ? (PIN_HP | AC_PINCTL_VREF_100) : PIN_HP; 12391 snd_hda_set_pin_ctl(codec, 0x1b, vref); 12392 } 12393 12394 static void alc897_fixup_lenovo_headset_mic(struct hda_codec *codec, 12395 const struct hda_fixup *fix, int action) 12396 { 12397 struct alc_spec *spec = codec->spec; 12398 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 12399 spec->gen.hp_automute_hook = alc897_hp_automute_hook; 12400 spec->no_shutup_pins = 1; 12401 } 12402 if (action == HDA_FIXUP_ACT_PROBE) { 12403 snd_hda_set_pin_ctl_cache(codec, 0x1a, PIN_IN | AC_PINCTL_VREF_100); 12404 } 12405 } 12406 12407 static void alc897_fixup_lenovo_headset_mode(struct hda_codec *codec, 12408 const struct hda_fixup *fix, int action) 12409 { 12410 struct alc_spec *spec = codec->spec; 12411 12412 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 12413 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 12414 spec->gen.hp_automute_hook = alc897_hp_automute_hook; 12415 } 12416 } 12417 12418 static const struct coef_fw alc668_coefs[] = { 12419 WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03, 0x0), 12420 WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06, 0x0), WRITE_COEF(0x07, 0x0f80), 12421 WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b, 0x0), 12422 WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f), 12423 WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001), 12424 WRITE_COEF(0x13, 0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940), 12425 WRITE_COEF(0x19, 0x0), WRITE_COEF(0x1a, 0x0), WRITE_COEF(0x1b, 0x0), 12426 WRITE_COEF(0x1c, 0x0), WRITE_COEF(0x1d, 0x0), WRITE_COEF(0x1e, 0x7418), 12427 WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468), 12428 WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418), 12429 WRITE_COEF(0x27, 0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00), 12430 WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000), 12431 WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac, 0x0), 12432 WRITE_COEF(0xad, 0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480), 12433 WRITE_COEF(0xb0, 0x0), WRITE_COEF(0xb1, 0x0), WRITE_COEF(0xb2, 0x0), 12434 WRITE_COEF(0xb3, 0x0), WRITE_COEF(0xb4, 0x0), WRITE_COEF(0xb5, 0x1040), 12435 WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697), 12436 WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab), 12437 WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02), 12438 WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6), 12439 {} 12440 }; 12441 12442 static void alc668_restore_default_value(struct hda_codec *codec) 12443 { 12444 alc_process_coef_fw(codec, alc668_coefs); 12445 } 12446 12447 enum { 12448 ALC662_FIXUP_ASPIRE, 12449 ALC662_FIXUP_LED_GPIO1, 12450 ALC662_FIXUP_IDEAPAD, 12451 ALC272_FIXUP_MARIO, 12452 ALC662_FIXUP_CZC_ET26, 12453 ALC662_FIXUP_CZC_P10T, 12454 ALC662_FIXUP_SKU_IGNORE, 12455 ALC662_FIXUP_HP_RP5800, 12456 ALC662_FIXUP_ASUS_MODE1, 12457 ALC662_FIXUP_ASUS_MODE2, 12458 ALC662_FIXUP_ASUS_MODE3, 12459 ALC662_FIXUP_ASUS_MODE4, 12460 ALC662_FIXUP_ASUS_MODE5, 12461 ALC662_FIXUP_ASUS_MODE6, 12462 ALC662_FIXUP_ASUS_MODE7, 12463 ALC662_FIXUP_ASUS_MODE8, 12464 ALC662_FIXUP_NO_JACK_DETECT, 12465 ALC662_FIXUP_ZOTAC_Z68, 12466 ALC662_FIXUP_INV_DMIC, 12467 ALC662_FIXUP_DELL_MIC_NO_PRESENCE, 12468 ALC668_FIXUP_DELL_MIC_NO_PRESENCE, 12469 ALC662_FIXUP_HEADSET_MODE, 12470 ALC668_FIXUP_HEADSET_MODE, 12471 ALC662_FIXUP_BASS_MODE4_CHMAP, 12472 ALC662_FIXUP_BASS_16, 12473 ALC662_FIXUP_BASS_1A, 12474 ALC662_FIXUP_BASS_CHMAP, 12475 ALC668_FIXUP_AUTO_MUTE, 12476 ALC668_FIXUP_DELL_DISABLE_AAMIX, 12477 ALC668_FIXUP_DELL_XPS13, 12478 ALC662_FIXUP_ASUS_Nx50, 12479 ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE, 12480 ALC668_FIXUP_ASUS_Nx51, 12481 ALC668_FIXUP_MIC_COEF, 12482 ALC668_FIXUP_ASUS_G751, 12483 ALC891_FIXUP_HEADSET_MODE, 12484 ALC891_FIXUP_DELL_MIC_NO_PRESENCE, 12485 ALC662_FIXUP_ACER_VERITON, 12486 ALC892_FIXUP_ASROCK_MOBO, 12487 ALC662_FIXUP_USI_FUNC, 12488 ALC662_FIXUP_USI_HEADSET_MODE, 12489 ALC662_FIXUP_LENOVO_MULTI_CODECS, 12490 ALC669_FIXUP_ACER_ASPIRE_ETHOS, 12491 ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET, 12492 ALC671_FIXUP_HP_HEADSET_MIC2, 12493 ALC662_FIXUP_ACER_X2660G_HEADSET_MODE, 12494 ALC662_FIXUP_ACER_NITRO_HEADSET_MODE, 12495 ALC668_FIXUP_ASUS_NO_HEADSET_MIC, 12496 ALC668_FIXUP_HEADSET_MIC, 12497 ALC668_FIXUP_MIC_DET_COEF, 12498 ALC897_FIXUP_LENOVO_HEADSET_MIC, 12499 ALC897_FIXUP_HEADSET_MIC_PIN, 12500 ALC897_FIXUP_HP_HSMIC_VERB, 12501 ALC897_FIXUP_LENOVO_HEADSET_MODE, 12502 ALC897_FIXUP_HEADSET_MIC_PIN2, 12503 ALC897_FIXUP_UNIS_H3C_X500S, 12504 ALC897_FIXUP_HEADSET_MIC_PIN3, 12505 }; 12506 12507 static const struct hda_fixup alc662_fixups[] = { 12508 [ALC662_FIXUP_ASPIRE] = { 12509 .type = HDA_FIXUP_PINS, 12510 .v.pins = (const struct hda_pintbl[]) { 12511 { 0x15, 0x99130112 }, /* subwoofer */ 12512 { } 12513 } 12514 }, 12515 [ALC662_FIXUP_LED_GPIO1] = { 12516 .type = HDA_FIXUP_FUNC, 12517 .v.func = alc662_fixup_led_gpio1, 12518 }, 12519 [ALC662_FIXUP_IDEAPAD] = { 12520 .type = HDA_FIXUP_PINS, 12521 .v.pins = (const struct hda_pintbl[]) { 12522 { 0x17, 0x99130112 }, /* subwoofer */ 12523 { } 12524 }, 12525 .chained = true, 12526 .chain_id = ALC662_FIXUP_LED_GPIO1, 12527 }, 12528 [ALC272_FIXUP_MARIO] = { 12529 .type = HDA_FIXUP_FUNC, 12530 .v.func = alc272_fixup_mario, 12531 }, 12532 [ALC662_FIXUP_CZC_ET26] = { 12533 .type = HDA_FIXUP_PINS, 12534 .v.pins = (const struct hda_pintbl[]) { 12535 {0x12, 0x403cc000}, 12536 {0x14, 0x90170110}, /* speaker */ 12537 {0x15, 0x411111f0}, 12538 {0x16, 0x411111f0}, 12539 {0x18, 0x01a19030}, /* mic */ 12540 {0x19, 0x90a7013f}, /* int-mic */ 12541 {0x1a, 0x01014020}, 12542 {0x1b, 0x0121401f}, 12543 {0x1c, 0x411111f0}, 12544 {0x1d, 0x411111f0}, 12545 {0x1e, 0x40478e35}, 12546 {} 12547 }, 12548 .chained = true, 12549 .chain_id = ALC662_FIXUP_SKU_IGNORE 12550 }, 12551 [ALC662_FIXUP_CZC_P10T] = { 12552 .type = HDA_FIXUP_VERBS, 12553 .v.verbs = (const struct hda_verb[]) { 12554 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0}, 12555 {} 12556 } 12557 }, 12558 [ALC662_FIXUP_SKU_IGNORE] = { 12559 .type = HDA_FIXUP_FUNC, 12560 .v.func = alc_fixup_sku_ignore, 12561 }, 12562 [ALC662_FIXUP_HP_RP5800] = { 12563 .type = HDA_FIXUP_PINS, 12564 .v.pins = (const struct hda_pintbl[]) { 12565 { 0x14, 0x0221201f }, /* HP out */ 12566 { } 12567 }, 12568 .chained = true, 12569 .chain_id = ALC662_FIXUP_SKU_IGNORE 12570 }, 12571 [ALC662_FIXUP_ASUS_MODE1] = { 12572 .type = HDA_FIXUP_PINS, 12573 .v.pins = (const struct hda_pintbl[]) { 12574 { 0x14, 0x99130110 }, /* speaker */ 12575 { 0x18, 0x01a19c20 }, /* mic */ 12576 { 0x19, 0x99a3092f }, /* int-mic */ 12577 { 0x21, 0x0121401f }, /* HP out */ 12578 { } 12579 }, 12580 .chained = true, 12581 .chain_id = ALC662_FIXUP_SKU_IGNORE 12582 }, 12583 [ALC662_FIXUP_ASUS_MODE2] = { 12584 .type = HDA_FIXUP_PINS, 12585 .v.pins = (const struct hda_pintbl[]) { 12586 { 0x14, 0x99130110 }, /* speaker */ 12587 { 0x18, 0x01a19820 }, /* mic */ 12588 { 0x19, 0x99a3092f }, /* int-mic */ 12589 { 0x1b, 0x0121401f }, /* HP out */ 12590 { } 12591 }, 12592 .chained = true, 12593 .chain_id = ALC662_FIXUP_SKU_IGNORE 12594 }, 12595 [ALC662_FIXUP_ASUS_MODE3] = { 12596 .type = HDA_FIXUP_PINS, 12597 .v.pins = (const struct hda_pintbl[]) { 12598 { 0x14, 0x99130110 }, /* speaker */ 12599 { 0x15, 0x0121441f }, /* HP */ 12600 { 0x18, 0x01a19840 }, /* mic */ 12601 { 0x19, 0x99a3094f }, /* int-mic */ 12602 { 0x21, 0x01211420 }, /* HP2 */ 12603 { } 12604 }, 12605 .chained = true, 12606 .chain_id = ALC662_FIXUP_SKU_IGNORE 12607 }, 12608 [ALC662_FIXUP_ASUS_MODE4] = { 12609 .type = HDA_FIXUP_PINS, 12610 .v.pins = (const struct hda_pintbl[]) { 12611 { 0x14, 0x99130110 }, /* speaker */ 12612 { 0x16, 0x99130111 }, /* speaker */ 12613 { 0x18, 0x01a19840 }, /* mic */ 12614 { 0x19, 0x99a3094f }, /* int-mic */ 12615 { 0x21, 0x0121441f }, /* HP */ 12616 { } 12617 }, 12618 .chained = true, 12619 .chain_id = ALC662_FIXUP_SKU_IGNORE 12620 }, 12621 [ALC662_FIXUP_ASUS_MODE5] = { 12622 .type = HDA_FIXUP_PINS, 12623 .v.pins = (const struct hda_pintbl[]) { 12624 { 0x14, 0x99130110 }, /* speaker */ 12625 { 0x15, 0x0121441f }, /* HP */ 12626 { 0x16, 0x99130111 }, /* speaker */ 12627 { 0x18, 0x01a19840 }, /* mic */ 12628 { 0x19, 0x99a3094f }, /* int-mic */ 12629 { } 12630 }, 12631 .chained = true, 12632 .chain_id = ALC662_FIXUP_SKU_IGNORE 12633 }, 12634 [ALC662_FIXUP_ASUS_MODE6] = { 12635 .type = HDA_FIXUP_PINS, 12636 .v.pins = (const struct hda_pintbl[]) { 12637 { 0x14, 0x99130110 }, /* speaker */ 12638 { 0x15, 0x01211420 }, /* HP2 */ 12639 { 0x18, 0x01a19840 }, /* mic */ 12640 { 0x19, 0x99a3094f }, /* int-mic */ 12641 { 0x1b, 0x0121441f }, /* HP */ 12642 { } 12643 }, 12644 .chained = true, 12645 .chain_id = ALC662_FIXUP_SKU_IGNORE 12646 }, 12647 [ALC662_FIXUP_ASUS_MODE7] = { 12648 .type = HDA_FIXUP_PINS, 12649 .v.pins = (const struct hda_pintbl[]) { 12650 { 0x14, 0x99130110 }, /* speaker */ 12651 { 0x17, 0x99130111 }, /* speaker */ 12652 { 0x18, 0x01a19840 }, /* mic */ 12653 { 0x19, 0x99a3094f }, /* int-mic */ 12654 { 0x1b, 0x01214020 }, /* HP */ 12655 { 0x21, 0x0121401f }, /* HP */ 12656 { } 12657 }, 12658 .chained = true, 12659 .chain_id = ALC662_FIXUP_SKU_IGNORE 12660 }, 12661 [ALC662_FIXUP_ASUS_MODE8] = { 12662 .type = HDA_FIXUP_PINS, 12663 .v.pins = (const struct hda_pintbl[]) { 12664 { 0x14, 0x99130110 }, /* speaker */ 12665 { 0x12, 0x99a30970 }, /* int-mic */ 12666 { 0x15, 0x01214020 }, /* HP */ 12667 { 0x17, 0x99130111 }, /* speaker */ 12668 { 0x18, 0x01a19840 }, /* mic */ 12669 { 0x21, 0x0121401f }, /* HP */ 12670 { } 12671 }, 12672 .chained = true, 12673 .chain_id = ALC662_FIXUP_SKU_IGNORE 12674 }, 12675 [ALC662_FIXUP_NO_JACK_DETECT] = { 12676 .type = HDA_FIXUP_FUNC, 12677 .v.func = alc_fixup_no_jack_detect, 12678 }, 12679 [ALC662_FIXUP_ZOTAC_Z68] = { 12680 .type = HDA_FIXUP_PINS, 12681 .v.pins = (const struct hda_pintbl[]) { 12682 { 0x1b, 0x02214020 }, /* Front HP */ 12683 { } 12684 } 12685 }, 12686 [ALC662_FIXUP_INV_DMIC] = { 12687 .type = HDA_FIXUP_FUNC, 12688 .v.func = alc_fixup_inv_dmic, 12689 }, 12690 [ALC668_FIXUP_DELL_XPS13] = { 12691 .type = HDA_FIXUP_FUNC, 12692 .v.func = alc_fixup_dell_xps13, 12693 .chained = true, 12694 .chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX 12695 }, 12696 [ALC668_FIXUP_DELL_DISABLE_AAMIX] = { 12697 .type = HDA_FIXUP_FUNC, 12698 .v.func = alc_fixup_disable_aamix, 12699 .chained = true, 12700 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE 12701 }, 12702 [ALC668_FIXUP_AUTO_MUTE] = { 12703 .type = HDA_FIXUP_FUNC, 12704 .v.func = alc_fixup_auto_mute_via_amp, 12705 .chained = true, 12706 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE 12707 }, 12708 [ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = { 12709 .type = HDA_FIXUP_PINS, 12710 .v.pins = (const struct hda_pintbl[]) { 12711 { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */ 12712 /* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */ 12713 { } 12714 }, 12715 .chained = true, 12716 .chain_id = ALC662_FIXUP_HEADSET_MODE 12717 }, 12718 [ALC662_FIXUP_HEADSET_MODE] = { 12719 .type = HDA_FIXUP_FUNC, 12720 .v.func = alc_fixup_headset_mode_alc662, 12721 }, 12722 [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = { 12723 .type = HDA_FIXUP_PINS, 12724 .v.pins = (const struct hda_pintbl[]) { 12725 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */ 12726 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */ 12727 { } 12728 }, 12729 .chained = true, 12730 .chain_id = ALC668_FIXUP_HEADSET_MODE 12731 }, 12732 [ALC668_FIXUP_HEADSET_MODE] = { 12733 .type = HDA_FIXUP_FUNC, 12734 .v.func = alc_fixup_headset_mode_alc668, 12735 }, 12736 [ALC662_FIXUP_BASS_MODE4_CHMAP] = { 12737 .type = HDA_FIXUP_FUNC, 12738 .v.func = alc_fixup_bass_chmap, 12739 .chained = true, 12740 .chain_id = ALC662_FIXUP_ASUS_MODE4 12741 }, 12742 [ALC662_FIXUP_BASS_16] = { 12743 .type = HDA_FIXUP_PINS, 12744 .v.pins = (const struct hda_pintbl[]) { 12745 {0x16, 0x80106111}, /* bass speaker */ 12746 {} 12747 }, 12748 .chained = true, 12749 .chain_id = ALC662_FIXUP_BASS_CHMAP, 12750 }, 12751 [ALC662_FIXUP_BASS_1A] = { 12752 .type = HDA_FIXUP_PINS, 12753 .v.pins = (const struct hda_pintbl[]) { 12754 {0x1a, 0x80106111}, /* bass speaker */ 12755 {} 12756 }, 12757 .chained = true, 12758 .chain_id = ALC662_FIXUP_BASS_CHMAP, 12759 }, 12760 [ALC662_FIXUP_BASS_CHMAP] = { 12761 .type = HDA_FIXUP_FUNC, 12762 .v.func = alc_fixup_bass_chmap, 12763 }, 12764 [ALC662_FIXUP_ASUS_Nx50] = { 12765 .type = HDA_FIXUP_FUNC, 12766 .v.func = alc_fixup_auto_mute_via_amp, 12767 .chained = true, 12768 .chain_id = ALC662_FIXUP_BASS_1A 12769 }, 12770 [ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = { 12771 .type = HDA_FIXUP_FUNC, 12772 .v.func = alc_fixup_headset_mode_alc668, 12773 .chain_id = ALC662_FIXUP_BASS_CHMAP 12774 }, 12775 [ALC668_FIXUP_ASUS_Nx51] = { 12776 .type = HDA_FIXUP_PINS, 12777 .v.pins = (const struct hda_pintbl[]) { 12778 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */ 12779 { 0x1a, 0x90170151 }, /* bass speaker */ 12780 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */ 12781 {} 12782 }, 12783 .chained = true, 12784 .chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE, 12785 }, 12786 [ALC668_FIXUP_MIC_COEF] = { 12787 .type = HDA_FIXUP_VERBS, 12788 .v.verbs = (const struct hda_verb[]) { 12789 { 0x20, AC_VERB_SET_COEF_INDEX, 0xc3 }, 12790 { 0x20, AC_VERB_SET_PROC_COEF, 0x4000 }, 12791 {} 12792 }, 12793 }, 12794 [ALC668_FIXUP_ASUS_G751] = { 12795 .type = HDA_FIXUP_PINS, 12796 .v.pins = (const struct hda_pintbl[]) { 12797 { 0x16, 0x0421101f }, /* HP */ 12798 {} 12799 }, 12800 .chained = true, 12801 .chain_id = ALC668_FIXUP_MIC_COEF 12802 }, 12803 [ALC891_FIXUP_HEADSET_MODE] = { 12804 .type = HDA_FIXUP_FUNC, 12805 .v.func = alc_fixup_headset_mode, 12806 }, 12807 [ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = { 12808 .type = HDA_FIXUP_PINS, 12809 .v.pins = (const struct hda_pintbl[]) { 12810 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */ 12811 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */ 12812 { } 12813 }, 12814 .chained = true, 12815 .chain_id = ALC891_FIXUP_HEADSET_MODE 12816 }, 12817 [ALC662_FIXUP_ACER_VERITON] = { 12818 .type = HDA_FIXUP_PINS, 12819 .v.pins = (const struct hda_pintbl[]) { 12820 { 0x15, 0x50170120 }, /* no internal speaker */ 12821 { } 12822 } 12823 }, 12824 [ALC892_FIXUP_ASROCK_MOBO] = { 12825 .type = HDA_FIXUP_PINS, 12826 .v.pins = (const struct hda_pintbl[]) { 12827 { 0x15, 0x40f000f0 }, /* disabled */ 12828 { 0x16, 0x40f000f0 }, /* disabled */ 12829 { } 12830 } 12831 }, 12832 [ALC662_FIXUP_USI_FUNC] = { 12833 .type = HDA_FIXUP_FUNC, 12834 .v.func = alc662_fixup_usi_headset_mic, 12835 }, 12836 [ALC662_FIXUP_USI_HEADSET_MODE] = { 12837 .type = HDA_FIXUP_PINS, 12838 .v.pins = (const struct hda_pintbl[]) { 12839 { 0x19, 0x02a1913c }, /* use as headset mic, without its own jack detect */ 12840 { 0x18, 0x01a1903d }, 12841 { } 12842 }, 12843 .chained = true, 12844 .chain_id = ALC662_FIXUP_USI_FUNC 12845 }, 12846 [ALC662_FIXUP_LENOVO_MULTI_CODECS] = { 12847 .type = HDA_FIXUP_FUNC, 12848 .v.func = alc233_alc662_fixup_lenovo_dual_codecs, 12849 }, 12850 [ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET] = { 12851 .type = HDA_FIXUP_FUNC, 12852 .v.func = alc662_fixup_aspire_ethos_hp, 12853 }, 12854 [ALC669_FIXUP_ACER_ASPIRE_ETHOS] = { 12855 .type = HDA_FIXUP_PINS, 12856 .v.pins = (const struct hda_pintbl[]) { 12857 { 0x15, 0x92130110 }, /* front speakers */ 12858 { 0x18, 0x99130111 }, /* center/subwoofer */ 12859 { 0x1b, 0x11130012 }, /* surround plus jack for HP */ 12860 { } 12861 }, 12862 .chained = true, 12863 .chain_id = ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET 12864 }, 12865 [ALC671_FIXUP_HP_HEADSET_MIC2] = { 12866 .type = HDA_FIXUP_FUNC, 12867 .v.func = alc671_fixup_hp_headset_mic2, 12868 }, 12869 [ALC662_FIXUP_ACER_X2660G_HEADSET_MODE] = { 12870 .type = HDA_FIXUP_PINS, 12871 .v.pins = (const struct hda_pintbl[]) { 12872 { 0x1a, 0x02a1113c }, /* use as headset mic, without its own jack detect */ 12873 { } 12874 }, 12875 .chained = true, 12876 .chain_id = ALC662_FIXUP_USI_FUNC 12877 }, 12878 [ALC662_FIXUP_ACER_NITRO_HEADSET_MODE] = { 12879 .type = HDA_FIXUP_PINS, 12880 .v.pins = (const struct hda_pintbl[]) { 12881 { 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */ 12882 { 0x1b, 0x0221144f }, 12883 { } 12884 }, 12885 .chained = true, 12886 .chain_id = ALC662_FIXUP_USI_FUNC 12887 }, 12888 [ALC668_FIXUP_ASUS_NO_HEADSET_MIC] = { 12889 .type = HDA_FIXUP_PINS, 12890 .v.pins = (const struct hda_pintbl[]) { 12891 { 0x1b, 0x04a1112c }, 12892 { } 12893 }, 12894 .chained = true, 12895 .chain_id = ALC668_FIXUP_HEADSET_MIC 12896 }, 12897 [ALC668_FIXUP_HEADSET_MIC] = { 12898 .type = HDA_FIXUP_FUNC, 12899 .v.func = alc269_fixup_headset_mic, 12900 .chained = true, 12901 .chain_id = ALC668_FIXUP_MIC_DET_COEF 12902 }, 12903 [ALC668_FIXUP_MIC_DET_COEF] = { 12904 .type = HDA_FIXUP_VERBS, 12905 .v.verbs = (const struct hda_verb[]) { 12906 { 0x20, AC_VERB_SET_COEF_INDEX, 0x15 }, 12907 { 0x20, AC_VERB_SET_PROC_COEF, 0x0d60 }, 12908 {} 12909 }, 12910 }, 12911 [ALC897_FIXUP_LENOVO_HEADSET_MIC] = { 12912 .type = HDA_FIXUP_FUNC, 12913 .v.func = alc897_fixup_lenovo_headset_mic, 12914 }, 12915 [ALC897_FIXUP_HEADSET_MIC_PIN] = { 12916 .type = HDA_FIXUP_PINS, 12917 .v.pins = (const struct hda_pintbl[]) { 12918 { 0x1a, 0x03a11050 }, 12919 { } 12920 }, 12921 .chained = true, 12922 .chain_id = ALC897_FIXUP_LENOVO_HEADSET_MIC 12923 }, 12924 [ALC897_FIXUP_HP_HSMIC_VERB] = { 12925 .type = HDA_FIXUP_PINS, 12926 .v.pins = (const struct hda_pintbl[]) { 12927 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 12928 { } 12929 }, 12930 }, 12931 [ALC897_FIXUP_LENOVO_HEADSET_MODE] = { 12932 .type = HDA_FIXUP_FUNC, 12933 .v.func = alc897_fixup_lenovo_headset_mode, 12934 }, 12935 [ALC897_FIXUP_HEADSET_MIC_PIN2] = { 12936 .type = HDA_FIXUP_PINS, 12937 .v.pins = (const struct hda_pintbl[]) { 12938 { 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */ 12939 { } 12940 }, 12941 .chained = true, 12942 .chain_id = ALC897_FIXUP_LENOVO_HEADSET_MODE 12943 }, 12944 [ALC897_FIXUP_UNIS_H3C_X500S] = { 12945 .type = HDA_FIXUP_VERBS, 12946 .v.verbs = (const struct hda_verb[]) { 12947 { 0x14, AC_VERB_SET_EAPD_BTLENABLE, 0 }, 12948 {} 12949 }, 12950 }, 12951 [ALC897_FIXUP_HEADSET_MIC_PIN3] = { 12952 .type = HDA_FIXUP_PINS, 12953 .v.pins = (const struct hda_pintbl[]) { 12954 { 0x19, 0x03a11050 }, /* use as headset mic */ 12955 { } 12956 }, 12957 }, 12958 }; 12959 12960 static const struct hda_quirk alc662_fixup_tbl[] = { 12961 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2), 12962 SND_PCI_QUIRK(0x1019, 0x9859, "JP-IK LEAP W502", ALC897_FIXUP_HEADSET_MIC_PIN3), 12963 SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC), 12964 SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC), 12965 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE), 12966 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE), 12967 SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC), 12968 SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC), 12969 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE), 12970 SND_PCI_QUIRK(0x1025, 0x0566, "Acer Aspire Ethos 8951G", ALC669_FIXUP_ACER_ASPIRE_ETHOS), 12971 SND_PCI_QUIRK(0x1025, 0x123c, "Acer Nitro N50-600", ALC662_FIXUP_ACER_NITRO_HEADSET_MODE), 12972 SND_PCI_QUIRK(0x1025, 0x124e, "Acer 2660G", ALC662_FIXUP_ACER_X2660G_HEADSET_MODE), 12973 SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 12974 SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 12975 SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13), 12976 SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13), 12977 SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13), 12978 SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 12979 SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 12980 SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 12981 SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 12982 SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 12983 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800), 12984 SND_PCI_QUIRK(0x103c, 0x870c, "HP", ALC897_FIXUP_HP_HSMIC_VERB), 12985 SND_PCI_QUIRK(0x103c, 0x8719, "HP", ALC897_FIXUP_HP_HSMIC_VERB), 12986 SND_PCI_QUIRK(0x103c, 0x872b, "HP", ALC897_FIXUP_HP_HSMIC_VERB), 12987 SND_PCI_QUIRK(0x103c, 0x873e, "HP", ALC671_FIXUP_HP_HEADSET_MIC2), 12988 SND_PCI_QUIRK(0x103c, 0x8768, "HP Slim Desktop S01", ALC671_FIXUP_HP_HEADSET_MIC2), 12989 SND_PCI_QUIRK(0x103c, 0x877e, "HP 288 Pro G6", ALC671_FIXUP_HP_HEADSET_MIC2), 12990 SND_PCI_QUIRK(0x103c, 0x885f, "HP 288 Pro G8", ALC671_FIXUP_HP_HEADSET_MIC2), 12991 SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE), 12992 SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50), 12993 SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50), 12994 SND_PCI_QUIRK(0x1043, 0x12ff, "ASUS G751", ALC668_FIXUP_ASUS_G751), 12995 SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A), 12996 SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP), 12997 SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16), 12998 SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51), 12999 SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51), 13000 SND_PCI_QUIRK(0x1043, 0x185d, "ASUS G551JW", ALC668_FIXUP_ASUS_NO_HEADSET_MIC), 13001 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8), 13002 SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16), 13003 SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP), 13004 SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT), 13005 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2), 13006 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD), 13007 SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE), 13008 SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS), 13009 SND_PCI_QUIRK(0x17aa, 0x1057, "Lenovo P360", ALC897_FIXUP_HEADSET_MIC_PIN), 13010 SND_PCI_QUIRK(0x17aa, 0x1064, "Lenovo P3 Tower", ALC897_FIXUP_HEADSET_MIC_PIN), 13011 SND_PCI_QUIRK(0x17aa, 0x32ca, "Lenovo ThinkCentre M80", ALC897_FIXUP_HEADSET_MIC_PIN), 13012 SND_PCI_QUIRK(0x17aa, 0x32cb, "Lenovo ThinkCentre M70", ALC897_FIXUP_HEADSET_MIC_PIN), 13013 SND_PCI_QUIRK(0x17aa, 0x32cf, "Lenovo ThinkCentre M950", ALC897_FIXUP_HEADSET_MIC_PIN), 13014 SND_PCI_QUIRK(0x17aa, 0x32f7, "Lenovo ThinkCentre M90", ALC897_FIXUP_HEADSET_MIC_PIN), 13015 SND_PCI_QUIRK(0x17aa, 0x3321, "Lenovo ThinkCentre M70 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN), 13016 SND_PCI_QUIRK(0x17aa, 0x331b, "Lenovo ThinkCentre M90 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN), 13017 SND_PCI_QUIRK(0x17aa, 0x3364, "Lenovo ThinkCentre M90 Gen5", ALC897_FIXUP_HEADSET_MIC_PIN), 13018 SND_PCI_QUIRK(0x17aa, 0x3742, "Lenovo TianYi510Pro-14IOB", ALC897_FIXUP_HEADSET_MIC_PIN2), 13019 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD), 13020 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD), 13021 SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO), 13022 SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68), 13023 SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON), 13024 SND_PCI_QUIRK(0x1b35, 0x1234, "CZC ET26", ALC662_FIXUP_CZC_ET26), 13025 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T), 13026 SND_PCI_QUIRK(0x1c6c, 0x1239, "Compaq N14JP6-V2", ALC897_FIXUP_HP_HSMIC_VERB), 13027 13028 #if 0 13029 /* Below is a quirk table taken from the old code. 13030 * Basically the device should work as is without the fixup table. 13031 * If BIOS doesn't give a proper info, enable the corresponding 13032 * fixup entry. 13033 */ 13034 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1), 13035 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3), 13036 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1), 13037 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3), 13038 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 13039 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 13040 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 13041 SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1), 13042 SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1), 13043 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 13044 SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7), 13045 SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7), 13046 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8), 13047 SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3), 13048 SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1), 13049 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 13050 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2), 13051 SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1), 13052 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 13053 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6), 13054 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6), 13055 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 13056 SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1), 13057 SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3), 13058 SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2), 13059 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 13060 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5), 13061 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6), 13062 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 13063 SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1), 13064 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 13065 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 13066 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3), 13067 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3), 13068 SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1), 13069 SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1), 13070 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1), 13071 SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1), 13072 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1), 13073 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 13074 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2), 13075 SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1), 13076 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 13077 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3), 13078 SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1), 13079 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1), 13080 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1), 13081 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2), 13082 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 13083 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4), 13084 #endif 13085 {} 13086 }; 13087 13088 static const struct hda_model_fixup alc662_fixup_models[] = { 13089 {.id = ALC662_FIXUP_ASPIRE, .name = "aspire"}, 13090 {.id = ALC662_FIXUP_IDEAPAD, .name = "ideapad"}, 13091 {.id = ALC272_FIXUP_MARIO, .name = "mario"}, 13092 {.id = ALC662_FIXUP_HP_RP5800, .name = "hp-rp5800"}, 13093 {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"}, 13094 {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"}, 13095 {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"}, 13096 {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"}, 13097 {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"}, 13098 {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"}, 13099 {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"}, 13100 {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"}, 13101 {.id = ALC662_FIXUP_ZOTAC_Z68, .name = "zotac-z68"}, 13102 {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"}, 13103 {.id = ALC662_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc662-headset-multi"}, 13104 {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"}, 13105 {.id = ALC662_FIXUP_HEADSET_MODE, .name = "alc662-headset"}, 13106 {.id = ALC668_FIXUP_HEADSET_MODE, .name = "alc668-headset"}, 13107 {.id = ALC662_FIXUP_BASS_16, .name = "bass16"}, 13108 {.id = ALC662_FIXUP_BASS_1A, .name = "bass1a"}, 13109 {.id = ALC668_FIXUP_AUTO_MUTE, .name = "automute"}, 13110 {.id = ALC668_FIXUP_DELL_XPS13, .name = "dell-xps13"}, 13111 {.id = ALC662_FIXUP_ASUS_Nx50, .name = "asus-nx50"}, 13112 {.id = ALC668_FIXUP_ASUS_Nx51, .name = "asus-nx51"}, 13113 {.id = ALC668_FIXUP_ASUS_G751, .name = "asus-g751"}, 13114 {.id = ALC891_FIXUP_HEADSET_MODE, .name = "alc891-headset"}, 13115 {.id = ALC891_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc891-headset-multi"}, 13116 {.id = ALC662_FIXUP_ACER_VERITON, .name = "acer-veriton"}, 13117 {.id = ALC892_FIXUP_ASROCK_MOBO, .name = "asrock-mobo"}, 13118 {.id = ALC662_FIXUP_USI_HEADSET_MODE, .name = "usi-headset"}, 13119 {.id = ALC662_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"}, 13120 {.id = ALC669_FIXUP_ACER_ASPIRE_ETHOS, .name = "aspire-ethos"}, 13121 {.id = ALC897_FIXUP_UNIS_H3C_X500S, .name = "unis-h3c-x500s"}, 13122 {} 13123 }; 13124 13125 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = { 13126 SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE, 13127 {0x17, 0x02211010}, 13128 {0x18, 0x01a19030}, 13129 {0x1a, 0x01813040}, 13130 {0x21, 0x01014020}), 13131 SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE, 13132 {0x16, 0x01813030}, 13133 {0x17, 0x02211010}, 13134 {0x18, 0x01a19040}, 13135 {0x21, 0x01014020}), 13136 SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE, 13137 {0x14, 0x01014010}, 13138 {0x18, 0x01a19020}, 13139 {0x1a, 0x0181302f}, 13140 {0x1b, 0x0221401f}), 13141 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE, 13142 {0x12, 0x99a30130}, 13143 {0x14, 0x90170110}, 13144 {0x15, 0x0321101f}, 13145 {0x16, 0x03011020}), 13146 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE, 13147 {0x12, 0x99a30140}, 13148 {0x14, 0x90170110}, 13149 {0x15, 0x0321101f}, 13150 {0x16, 0x03011020}), 13151 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE, 13152 {0x12, 0x99a30150}, 13153 {0x14, 0x90170110}, 13154 {0x15, 0x0321101f}, 13155 {0x16, 0x03011020}), 13156 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE, 13157 {0x14, 0x90170110}, 13158 {0x15, 0x0321101f}, 13159 {0x16, 0x03011020}), 13160 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE, 13161 {0x12, 0x90a60130}, 13162 {0x14, 0x90170110}, 13163 {0x15, 0x0321101f}), 13164 SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2, 13165 {0x14, 0x01014010}, 13166 {0x17, 0x90170150}, 13167 {0x19, 0x02a11060}, 13168 {0x1b, 0x01813030}, 13169 {0x21, 0x02211020}), 13170 SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2, 13171 {0x14, 0x01014010}, 13172 {0x18, 0x01a19040}, 13173 {0x1b, 0x01813030}, 13174 {0x21, 0x02211020}), 13175 SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2, 13176 {0x14, 0x01014020}, 13177 {0x17, 0x90170110}, 13178 {0x18, 0x01a19050}, 13179 {0x1b, 0x01813040}, 13180 {0x21, 0x02211030}), 13181 {} 13182 }; 13183 13184 /* 13185 */ 13186 static int patch_alc662(struct hda_codec *codec) 13187 { 13188 struct alc_spec *spec; 13189 int err; 13190 13191 err = alc_alloc_spec(codec, 0x0b); 13192 if (err < 0) 13193 return err; 13194 13195 spec = codec->spec; 13196 13197 spec->shutup = alc_eapd_shutup; 13198 13199 /* handle multiple HPs as is */ 13200 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 13201 13202 alc_fix_pll_init(codec, 0x20, 0x04, 15); 13203 13204 switch (codec->core.vendor_id) { 13205 case 0x10ec0668: 13206 spec->init_hook = alc668_restore_default_value; 13207 break; 13208 } 13209 13210 alc_pre_init(codec); 13211 13212 snd_hda_pick_fixup(codec, alc662_fixup_models, 13213 alc662_fixup_tbl, alc662_fixups); 13214 snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups, true); 13215 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 13216 13217 alc_auto_parse_customize_define(codec); 13218 13219 if (has_cdefine_beep(codec)) 13220 spec->gen.beep_nid = 0x01; 13221 13222 if ((alc_get_coef0(codec) & (1 << 14)) && 13223 codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 && 13224 spec->cdefine.platform_type == 1) { 13225 err = alc_codec_rename(codec, "ALC272X"); 13226 if (err < 0) 13227 goto error; 13228 } 13229 13230 /* automatic parse from the BIOS config */ 13231 err = alc662_parse_auto_config(codec); 13232 if (err < 0) 13233 goto error; 13234 13235 if (!spec->gen.no_analog && spec->gen.beep_nid) { 13236 switch (codec->core.vendor_id) { 13237 case 0x10ec0662: 13238 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 13239 break; 13240 case 0x10ec0272: 13241 case 0x10ec0663: 13242 case 0x10ec0665: 13243 case 0x10ec0668: 13244 err = set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT); 13245 break; 13246 case 0x10ec0273: 13247 err = set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT); 13248 break; 13249 } 13250 if (err < 0) 13251 goto error; 13252 } 13253 13254 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 13255 13256 return 0; 13257 13258 error: 13259 alc_free(codec); 13260 return err; 13261 } 13262 13263 /* 13264 * ALC680 support 13265 */ 13266 13267 static int alc680_parse_auto_config(struct hda_codec *codec) 13268 { 13269 return alc_parse_auto_config(codec, NULL, NULL); 13270 } 13271 13272 /* 13273 */ 13274 static int patch_alc680(struct hda_codec *codec) 13275 { 13276 int err; 13277 13278 /* ALC680 has no aa-loopback mixer */ 13279 err = alc_alloc_spec(codec, 0); 13280 if (err < 0) 13281 return err; 13282 13283 /* automatic parse from the BIOS config */ 13284 err = alc680_parse_auto_config(codec); 13285 if (err < 0) { 13286 alc_free(codec); 13287 return err; 13288 } 13289 13290 return 0; 13291 } 13292 13293 /* 13294 * patch entries 13295 */ 13296 static const struct hda_device_id snd_hda_id_realtek[] = { 13297 HDA_CODEC_ENTRY(0x10ec0215, "ALC215", patch_alc269), 13298 HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269), 13299 HDA_CODEC_ENTRY(0x10ec0222, "ALC222", patch_alc269), 13300 HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269), 13301 HDA_CODEC_ENTRY(0x10ec0230, "ALC236", patch_alc269), 13302 HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269), 13303 HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269), 13304 HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269), 13305 HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269), 13306 HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269), 13307 HDA_CODEC_ENTRY(0x10ec0245, "ALC245", patch_alc269), 13308 HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269), 13309 HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269), 13310 HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269), 13311 HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260), 13312 HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262), 13313 HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268), 13314 HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268), 13315 HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269), 13316 HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269), 13317 HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662), 13318 HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269), 13319 HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269), 13320 HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269), 13321 HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269), 13322 HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269), 13323 HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269), 13324 HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269), 13325 HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269), 13326 HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269), 13327 HDA_CODEC_ENTRY(0x10ec0287, "ALC287", patch_alc269), 13328 HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269), 13329 HDA_CODEC_ENTRY(0x10ec0289, "ALC289", patch_alc269), 13330 HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269), 13331 HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269), 13332 HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269), 13333 HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269), 13334 HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269), 13335 HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269), 13336 HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269), 13337 HDA_CODEC_ENTRY(0x10ec0300, "ALC300", patch_alc269), 13338 HDA_CODEC_ENTRY(0x10ec0623, "ALC623", patch_alc269), 13339 HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861), 13340 HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd), 13341 HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861), 13342 HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd), 13343 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882), 13344 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662), 13345 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662), 13346 HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662), 13347 HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662), 13348 HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662), 13349 HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662), 13350 HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662), 13351 HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662), 13352 HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680), 13353 HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269), 13354 HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269), 13355 HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269), 13356 HDA_CODEC_ENTRY(0x10ec0711, "ALC711", patch_alc269), 13357 HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662), 13358 HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880), 13359 HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882), 13360 HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882), 13361 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882), 13362 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882), 13363 HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882), 13364 HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882), 13365 HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882), 13366 HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882), 13367 HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882), 13368 HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662), 13369 HDA_CODEC_ENTRY(0x10ec0897, "ALC897", patch_alc662), 13370 HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882), 13371 HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882), 13372 HDA_CODEC_ENTRY(0x10ec0b00, "ALCS1200A", patch_alc882), 13373 HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882), 13374 HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882), 13375 HDA_CODEC_ENTRY(0x19e58326, "HW8326", patch_alc269), 13376 {} /* terminator */ 13377 }; 13378 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek); 13379 13380 MODULE_LICENSE("GPL"); 13381 MODULE_DESCRIPTION("Realtek HD-audio codec"); 13382 MODULE_IMPORT_NS("SND_HDA_SCODEC_COMPONENT"); 13383 13384 static struct hda_codec_driver realtek_driver = { 13385 .id = snd_hda_id_realtek, 13386 }; 13387 13388 module_hda_codec_driver(realtek_driver); 13389