1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Universal Interface for Intel High Definition Audio Codec 4 * 5 * HD audio interface patch for Realtek ALC codecs 6 * 7 * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw> 8 * PeiSen Hou <pshou@realtek.com.tw> 9 * Takashi Iwai <tiwai@suse.de> 10 * Jonathan Woithe <jwoithe@just42.net> 11 */ 12 13 #include <linux/init.h> 14 #include <linux/delay.h> 15 #include <linux/slab.h> 16 #include <linux/pci.h> 17 #include <linux/dmi.h> 18 #include <linux/module.h> 19 #include <linux/input.h> 20 #include <linux/leds.h> 21 #include <sound/core.h> 22 #include <sound/jack.h> 23 #include <sound/hda_codec.h> 24 #include "hda_local.h" 25 #include "hda_auto_parser.h" 26 #include "hda_jack.h" 27 #include "hda_generic.h" 28 #include "hda_component.h" 29 30 /* keep halting ALC5505 DSP, for power saving */ 31 #define HALT_REALTEK_ALC5505 32 33 /* extra amp-initialization sequence types */ 34 enum { 35 ALC_INIT_UNDEFINED, 36 ALC_INIT_NONE, 37 ALC_INIT_DEFAULT, 38 }; 39 40 enum { 41 ALC_HEADSET_MODE_UNKNOWN, 42 ALC_HEADSET_MODE_UNPLUGGED, 43 ALC_HEADSET_MODE_HEADSET, 44 ALC_HEADSET_MODE_MIC, 45 ALC_HEADSET_MODE_HEADPHONE, 46 }; 47 48 enum { 49 ALC_HEADSET_TYPE_UNKNOWN, 50 ALC_HEADSET_TYPE_CTIA, 51 ALC_HEADSET_TYPE_OMTP, 52 }; 53 54 enum { 55 ALC_KEY_MICMUTE_INDEX, 56 }; 57 58 struct alc_customize_define { 59 unsigned int sku_cfg; 60 unsigned char port_connectivity; 61 unsigned char check_sum; 62 unsigned char customization; 63 unsigned char external_amp; 64 unsigned int enable_pcbeep:1; 65 unsigned int platform_type:1; 66 unsigned int swap:1; 67 unsigned int override:1; 68 unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */ 69 }; 70 71 struct alc_coef_led { 72 unsigned int idx; 73 unsigned int mask; 74 unsigned int on; 75 unsigned int off; 76 }; 77 78 struct alc_spec { 79 struct hda_gen_spec gen; /* must be at head */ 80 81 /* codec parameterization */ 82 struct alc_customize_define cdefine; 83 unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */ 84 85 /* GPIO bits */ 86 unsigned int gpio_mask; 87 unsigned int gpio_dir; 88 unsigned int gpio_data; 89 bool gpio_write_delay; /* add a delay before writing gpio_data */ 90 91 /* mute LED for HP laptops, see vref_mute_led_set() */ 92 int mute_led_polarity; 93 int micmute_led_polarity; 94 hda_nid_t mute_led_nid; 95 hda_nid_t cap_mute_led_nid; 96 97 unsigned int gpio_mute_led_mask; 98 unsigned int gpio_mic_led_mask; 99 struct alc_coef_led mute_led_coef; 100 struct alc_coef_led mic_led_coef; 101 102 hda_nid_t headset_mic_pin; 103 hda_nid_t headphone_mic_pin; 104 int current_headset_mode; 105 int current_headset_type; 106 107 /* hooks */ 108 void (*init_hook)(struct hda_codec *codec); 109 #ifdef CONFIG_PM 110 void (*power_hook)(struct hda_codec *codec); 111 #endif 112 void (*shutup)(struct hda_codec *codec); 113 114 int init_amp; 115 int codec_variant; /* flag for other variants */ 116 unsigned int has_alc5505_dsp:1; 117 unsigned int no_depop_delay:1; 118 unsigned int done_hp_init:1; 119 unsigned int no_shutup_pins:1; 120 unsigned int ultra_low_power:1; 121 unsigned int has_hs_key:1; 122 unsigned int no_internal_mic_pin:1; 123 124 /* for PLL fix */ 125 hda_nid_t pll_nid; 126 unsigned int pll_coef_idx, pll_coef_bit; 127 unsigned int coef0; 128 struct input_dev *kb_dev; 129 u8 alc_mute_keycode_map[1]; 130 131 /* component binding */ 132 struct component_match *match; 133 struct hda_component comps[HDA_MAX_COMPONENTS]; 134 }; 135 136 /* 137 * COEF access helper functions 138 */ 139 140 static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid, 141 unsigned int coef_idx) 142 { 143 unsigned int val; 144 145 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx); 146 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0); 147 return val; 148 } 149 150 #define alc_read_coef_idx(codec, coef_idx) \ 151 alc_read_coefex_idx(codec, 0x20, coef_idx) 152 153 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid, 154 unsigned int coef_idx, unsigned int coef_val) 155 { 156 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx); 157 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val); 158 } 159 160 #define alc_write_coef_idx(codec, coef_idx, coef_val) \ 161 alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val) 162 163 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid, 164 unsigned int coef_idx, unsigned int mask, 165 unsigned int bits_set) 166 { 167 unsigned int val = alc_read_coefex_idx(codec, nid, coef_idx); 168 169 if (val != -1) 170 alc_write_coefex_idx(codec, nid, coef_idx, 171 (val & ~mask) | bits_set); 172 } 173 174 #define alc_update_coef_idx(codec, coef_idx, mask, bits_set) \ 175 alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set) 176 177 /* a special bypass for COEF 0; read the cached value at the second time */ 178 static unsigned int alc_get_coef0(struct hda_codec *codec) 179 { 180 struct alc_spec *spec = codec->spec; 181 182 if (!spec->coef0) 183 spec->coef0 = alc_read_coef_idx(codec, 0); 184 return spec->coef0; 185 } 186 187 /* coef writes/updates batch */ 188 struct coef_fw { 189 unsigned char nid; 190 unsigned char idx; 191 unsigned short mask; 192 unsigned short val; 193 }; 194 195 #define UPDATE_COEFEX(_nid, _idx, _mask, _val) \ 196 { .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) } 197 #define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val) 198 #define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val) 199 #define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val) 200 201 static void alc_process_coef_fw(struct hda_codec *codec, 202 const struct coef_fw *fw) 203 { 204 for (; fw->nid; fw++) { 205 if (fw->mask == (unsigned short)-1) 206 alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val); 207 else 208 alc_update_coefex_idx(codec, fw->nid, fw->idx, 209 fw->mask, fw->val); 210 } 211 } 212 213 /* 214 * GPIO setup tables, used in initialization 215 */ 216 217 /* Enable GPIO mask and set output */ 218 static void alc_setup_gpio(struct hda_codec *codec, unsigned int mask) 219 { 220 struct alc_spec *spec = codec->spec; 221 222 spec->gpio_mask |= mask; 223 spec->gpio_dir |= mask; 224 spec->gpio_data |= mask; 225 } 226 227 static void alc_write_gpio_data(struct hda_codec *codec) 228 { 229 struct alc_spec *spec = codec->spec; 230 231 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 232 spec->gpio_data); 233 } 234 235 static void alc_update_gpio_data(struct hda_codec *codec, unsigned int mask, 236 bool on) 237 { 238 struct alc_spec *spec = codec->spec; 239 unsigned int oldval = spec->gpio_data; 240 241 if (on) 242 spec->gpio_data |= mask; 243 else 244 spec->gpio_data &= ~mask; 245 if (oldval != spec->gpio_data) 246 alc_write_gpio_data(codec); 247 } 248 249 static void alc_write_gpio(struct hda_codec *codec) 250 { 251 struct alc_spec *spec = codec->spec; 252 253 if (!spec->gpio_mask) 254 return; 255 256 snd_hda_codec_write(codec, codec->core.afg, 0, 257 AC_VERB_SET_GPIO_MASK, spec->gpio_mask); 258 snd_hda_codec_write(codec, codec->core.afg, 0, 259 AC_VERB_SET_GPIO_DIRECTION, spec->gpio_dir); 260 if (spec->gpio_write_delay) 261 msleep(1); 262 alc_write_gpio_data(codec); 263 } 264 265 static void alc_fixup_gpio(struct hda_codec *codec, int action, 266 unsigned int mask) 267 { 268 if (action == HDA_FIXUP_ACT_PRE_PROBE) 269 alc_setup_gpio(codec, mask); 270 } 271 272 static void alc_fixup_gpio1(struct hda_codec *codec, 273 const struct hda_fixup *fix, int action) 274 { 275 alc_fixup_gpio(codec, action, 0x01); 276 } 277 278 static void alc_fixup_gpio2(struct hda_codec *codec, 279 const struct hda_fixup *fix, int action) 280 { 281 alc_fixup_gpio(codec, action, 0x02); 282 } 283 284 static void alc_fixup_gpio3(struct hda_codec *codec, 285 const struct hda_fixup *fix, int action) 286 { 287 alc_fixup_gpio(codec, action, 0x03); 288 } 289 290 static void alc_fixup_gpio4(struct hda_codec *codec, 291 const struct hda_fixup *fix, int action) 292 { 293 alc_fixup_gpio(codec, action, 0x04); 294 } 295 296 static void alc_fixup_micmute_led(struct hda_codec *codec, 297 const struct hda_fixup *fix, int action) 298 { 299 if (action == HDA_FIXUP_ACT_PRE_PROBE) 300 snd_hda_gen_add_micmute_led_cdev(codec, NULL); 301 } 302 303 /* 304 * Fix hardware PLL issue 305 * On some codecs, the analog PLL gating control must be off while 306 * the default value is 1. 307 */ 308 static void alc_fix_pll(struct hda_codec *codec) 309 { 310 struct alc_spec *spec = codec->spec; 311 312 if (spec->pll_nid) 313 alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx, 314 1 << spec->pll_coef_bit, 0); 315 } 316 317 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid, 318 unsigned int coef_idx, unsigned int coef_bit) 319 { 320 struct alc_spec *spec = codec->spec; 321 spec->pll_nid = nid; 322 spec->pll_coef_idx = coef_idx; 323 spec->pll_coef_bit = coef_bit; 324 alc_fix_pll(codec); 325 } 326 327 /* update the master volume per volume-knob's unsol event */ 328 static void alc_update_knob_master(struct hda_codec *codec, 329 struct hda_jack_callback *jack) 330 { 331 unsigned int val; 332 struct snd_kcontrol *kctl; 333 struct snd_ctl_elem_value *uctl; 334 335 kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume"); 336 if (!kctl) 337 return; 338 uctl = kzalloc(sizeof(*uctl), GFP_KERNEL); 339 if (!uctl) 340 return; 341 val = snd_hda_codec_read(codec, jack->nid, 0, 342 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0); 343 val &= HDA_AMP_VOLMASK; 344 uctl->value.integer.value[0] = val; 345 uctl->value.integer.value[1] = val; 346 kctl->put(kctl, uctl); 347 kfree(uctl); 348 } 349 350 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res) 351 { 352 /* For some reason, the res given from ALC880 is broken. 353 Here we adjust it properly. */ 354 snd_hda_jack_unsol_event(codec, res >> 2); 355 } 356 357 /* Change EAPD to verb control */ 358 static void alc_fill_eapd_coef(struct hda_codec *codec) 359 { 360 int coef; 361 362 coef = alc_get_coef0(codec); 363 364 switch (codec->core.vendor_id) { 365 case 0x10ec0262: 366 alc_update_coef_idx(codec, 0x7, 0, 1<<5); 367 break; 368 case 0x10ec0267: 369 case 0x10ec0268: 370 alc_update_coef_idx(codec, 0x7, 0, 1<<13); 371 break; 372 case 0x10ec0269: 373 if ((coef & 0x00f0) == 0x0010) 374 alc_update_coef_idx(codec, 0xd, 0, 1<<14); 375 if ((coef & 0x00f0) == 0x0020) 376 alc_update_coef_idx(codec, 0x4, 1<<15, 0); 377 if ((coef & 0x00f0) == 0x0030) 378 alc_update_coef_idx(codec, 0x10, 1<<9, 0); 379 break; 380 case 0x10ec0280: 381 case 0x10ec0284: 382 case 0x10ec0290: 383 case 0x10ec0292: 384 alc_update_coef_idx(codec, 0x4, 1<<15, 0); 385 break; 386 case 0x10ec0225: 387 case 0x10ec0295: 388 case 0x10ec0299: 389 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000); 390 fallthrough; 391 case 0x10ec0215: 392 case 0x10ec0230: 393 case 0x10ec0233: 394 case 0x10ec0235: 395 case 0x10ec0236: 396 case 0x10ec0245: 397 case 0x10ec0255: 398 case 0x10ec0256: 399 case 0x10ec0257: 400 case 0x10ec0282: 401 case 0x10ec0283: 402 case 0x10ec0286: 403 case 0x10ec0288: 404 case 0x10ec0285: 405 case 0x10ec0298: 406 case 0x10ec0289: 407 case 0x10ec0300: 408 alc_update_coef_idx(codec, 0x10, 1<<9, 0); 409 break; 410 case 0x10ec0275: 411 alc_update_coef_idx(codec, 0xe, 0, 1<<0); 412 break; 413 case 0x10ec0287: 414 alc_update_coef_idx(codec, 0x10, 1<<9, 0); 415 alc_write_coef_idx(codec, 0x8, 0x4ab7); 416 break; 417 case 0x10ec0293: 418 alc_update_coef_idx(codec, 0xa, 1<<13, 0); 419 break; 420 case 0x10ec0234: 421 case 0x10ec0274: 422 case 0x10ec0294: 423 case 0x10ec0700: 424 case 0x10ec0701: 425 case 0x10ec0703: 426 case 0x10ec0711: 427 alc_update_coef_idx(codec, 0x10, 1<<15, 0); 428 break; 429 case 0x10ec0662: 430 if ((coef & 0x00f0) == 0x0030) 431 alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */ 432 break; 433 case 0x10ec0272: 434 case 0x10ec0273: 435 case 0x10ec0663: 436 case 0x10ec0665: 437 case 0x10ec0670: 438 case 0x10ec0671: 439 case 0x10ec0672: 440 alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */ 441 break; 442 case 0x10ec0222: 443 case 0x10ec0623: 444 alc_update_coef_idx(codec, 0x19, 1<<13, 0); 445 break; 446 case 0x10ec0668: 447 alc_update_coef_idx(codec, 0x7, 3<<13, 0); 448 break; 449 case 0x10ec0867: 450 alc_update_coef_idx(codec, 0x4, 1<<10, 0); 451 break; 452 case 0x10ec0888: 453 if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030) 454 alc_update_coef_idx(codec, 0x7, 1<<5, 0); 455 break; 456 case 0x10ec0892: 457 case 0x10ec0897: 458 alc_update_coef_idx(codec, 0x7, 1<<5, 0); 459 break; 460 case 0x10ec0899: 461 case 0x10ec0900: 462 case 0x10ec0b00: 463 case 0x10ec1168: 464 case 0x10ec1220: 465 alc_update_coef_idx(codec, 0x7, 1<<1, 0); 466 break; 467 } 468 } 469 470 /* additional initialization for ALC888 variants */ 471 static void alc888_coef_init(struct hda_codec *codec) 472 { 473 switch (alc_get_coef0(codec) & 0x00f0) { 474 /* alc888-VA */ 475 case 0x00: 476 /* alc888-VB */ 477 case 0x10: 478 alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */ 479 break; 480 } 481 } 482 483 /* turn on/off EAPD control (only if available) */ 484 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on) 485 { 486 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN) 487 return; 488 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD) 489 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE, 490 on ? 2 : 0); 491 } 492 493 /* turn on/off EAPD controls of the codec */ 494 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on) 495 { 496 /* We currently only handle front, HP */ 497 static const hda_nid_t pins[] = { 498 0x0f, 0x10, 0x14, 0x15, 0x17, 0 499 }; 500 const hda_nid_t *p; 501 for (p = pins; *p; p++) 502 set_eapd(codec, *p, on); 503 } 504 505 static int find_ext_mic_pin(struct hda_codec *codec); 506 507 static void alc_headset_mic_no_shutup(struct hda_codec *codec) 508 { 509 const struct hda_pincfg *pin; 510 int mic_pin = find_ext_mic_pin(codec); 511 int i; 512 513 /* don't shut up pins when unloading the driver; otherwise it breaks 514 * the default pin setup at the next load of the driver 515 */ 516 if (codec->bus->shutdown) 517 return; 518 519 snd_array_for_each(&codec->init_pins, i, pin) { 520 /* use read here for syncing after issuing each verb */ 521 if (pin->nid != mic_pin) 522 snd_hda_codec_read(codec, pin->nid, 0, 523 AC_VERB_SET_PIN_WIDGET_CONTROL, 0); 524 } 525 526 codec->pins_shutup = 1; 527 } 528 529 static void alc_shutup_pins(struct hda_codec *codec) 530 { 531 struct alc_spec *spec = codec->spec; 532 533 switch (codec->core.vendor_id) { 534 case 0x10ec0236: 535 case 0x10ec0256: 536 case 0x10ec0283: 537 case 0x10ec0286: 538 case 0x10ec0288: 539 case 0x10ec0298: 540 alc_headset_mic_no_shutup(codec); 541 break; 542 default: 543 if (!spec->no_shutup_pins) 544 snd_hda_shutup_pins(codec); 545 break; 546 } 547 } 548 549 /* generic shutup callback; 550 * just turning off EAPD and a little pause for avoiding pop-noise 551 */ 552 static void alc_eapd_shutup(struct hda_codec *codec) 553 { 554 struct alc_spec *spec = codec->spec; 555 556 alc_auto_setup_eapd(codec, false); 557 if (!spec->no_depop_delay) 558 msleep(200); 559 alc_shutup_pins(codec); 560 } 561 562 /* generic EAPD initialization */ 563 static void alc_auto_init_amp(struct hda_codec *codec, int type) 564 { 565 alc_auto_setup_eapd(codec, true); 566 alc_write_gpio(codec); 567 switch (type) { 568 case ALC_INIT_DEFAULT: 569 switch (codec->core.vendor_id) { 570 case 0x10ec0260: 571 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010); 572 break; 573 case 0x10ec0880: 574 case 0x10ec0882: 575 case 0x10ec0883: 576 case 0x10ec0885: 577 alc_update_coef_idx(codec, 7, 0, 0x2030); 578 break; 579 case 0x10ec0888: 580 alc888_coef_init(codec); 581 break; 582 } 583 break; 584 } 585 } 586 587 /* get a primary headphone pin if available */ 588 static hda_nid_t alc_get_hp_pin(struct alc_spec *spec) 589 { 590 if (spec->gen.autocfg.hp_pins[0]) 591 return spec->gen.autocfg.hp_pins[0]; 592 if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT) 593 return spec->gen.autocfg.line_out_pins[0]; 594 return 0; 595 } 596 597 /* 598 * Realtek SSID verification 599 */ 600 601 /* Could be any non-zero and even value. When used as fixup, tells 602 * the driver to ignore any present sku defines. 603 */ 604 #define ALC_FIXUP_SKU_IGNORE (2) 605 606 static void alc_fixup_sku_ignore(struct hda_codec *codec, 607 const struct hda_fixup *fix, int action) 608 { 609 struct alc_spec *spec = codec->spec; 610 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 611 spec->cdefine.fixup = 1; 612 spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE; 613 } 614 } 615 616 static void alc_fixup_no_depop_delay(struct hda_codec *codec, 617 const struct hda_fixup *fix, int action) 618 { 619 struct alc_spec *spec = codec->spec; 620 621 if (action == HDA_FIXUP_ACT_PROBE) { 622 spec->no_depop_delay = 1; 623 codec->depop_delay = 0; 624 } 625 } 626 627 static int alc_auto_parse_customize_define(struct hda_codec *codec) 628 { 629 unsigned int ass, tmp, i; 630 unsigned nid = 0; 631 struct alc_spec *spec = codec->spec; 632 633 spec->cdefine.enable_pcbeep = 1; /* assume always enabled */ 634 635 if (spec->cdefine.fixup) { 636 ass = spec->cdefine.sku_cfg; 637 if (ass == ALC_FIXUP_SKU_IGNORE) 638 return -1; 639 goto do_sku; 640 } 641 642 if (!codec->bus->pci) 643 return -1; 644 ass = codec->core.subsystem_id & 0xffff; 645 if (ass != codec->bus->pci->subsystem_device && (ass & 1)) 646 goto do_sku; 647 648 nid = 0x1d; 649 if (codec->core.vendor_id == 0x10ec0260) 650 nid = 0x17; 651 ass = snd_hda_codec_get_pincfg(codec, nid); 652 653 if (!(ass & 1)) { 654 codec_info(codec, "%s: SKU not ready 0x%08x\n", 655 codec->core.chip_name, ass); 656 return -1; 657 } 658 659 /* check sum */ 660 tmp = 0; 661 for (i = 1; i < 16; i++) { 662 if ((ass >> i) & 1) 663 tmp++; 664 } 665 if (((ass >> 16) & 0xf) != tmp) 666 return -1; 667 668 spec->cdefine.port_connectivity = ass >> 30; 669 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20; 670 spec->cdefine.check_sum = (ass >> 16) & 0xf; 671 spec->cdefine.customization = ass >> 8; 672 do_sku: 673 spec->cdefine.sku_cfg = ass; 674 spec->cdefine.external_amp = (ass & 0x38) >> 3; 675 spec->cdefine.platform_type = (ass & 0x4) >> 2; 676 spec->cdefine.swap = (ass & 0x2) >> 1; 677 spec->cdefine.override = ass & 0x1; 678 679 codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n", 680 nid, spec->cdefine.sku_cfg); 681 codec_dbg(codec, "SKU: port_connectivity=0x%x\n", 682 spec->cdefine.port_connectivity); 683 codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep); 684 codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum); 685 codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization); 686 codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp); 687 codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type); 688 codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap); 689 codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override); 690 691 return 0; 692 } 693 694 /* return the position of NID in the list, or -1 if not found */ 695 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums) 696 { 697 int i; 698 for (i = 0; i < nums; i++) 699 if (list[i] == nid) 700 return i; 701 return -1; 702 } 703 /* return true if the given NID is found in the list */ 704 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums) 705 { 706 return find_idx_in_nid_list(nid, list, nums) >= 0; 707 } 708 709 /* check subsystem ID and set up device-specific initialization; 710 * return 1 if initialized, 0 if invalid SSID 711 */ 712 /* 32-bit subsystem ID for BIOS loading in HD Audio codec. 713 * 31 ~ 16 : Manufacture ID 714 * 15 ~ 8 : SKU ID 715 * 7 ~ 0 : Assembly ID 716 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36 717 */ 718 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports) 719 { 720 unsigned int ass, tmp, i; 721 unsigned nid; 722 struct alc_spec *spec = codec->spec; 723 724 if (spec->cdefine.fixup) { 725 ass = spec->cdefine.sku_cfg; 726 if (ass == ALC_FIXUP_SKU_IGNORE) 727 return 0; 728 goto do_sku; 729 } 730 731 ass = codec->core.subsystem_id & 0xffff; 732 if (codec->bus->pci && 733 ass != codec->bus->pci->subsystem_device && (ass & 1)) 734 goto do_sku; 735 736 /* invalid SSID, check the special NID pin defcfg instead */ 737 /* 738 * 31~30 : port connectivity 739 * 29~21 : reserve 740 * 20 : PCBEEP input 741 * 19~16 : Check sum (15:1) 742 * 15~1 : Custom 743 * 0 : override 744 */ 745 nid = 0x1d; 746 if (codec->core.vendor_id == 0x10ec0260) 747 nid = 0x17; 748 ass = snd_hda_codec_get_pincfg(codec, nid); 749 codec_dbg(codec, 750 "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n", 751 ass, nid); 752 if (!(ass & 1)) 753 return 0; 754 if ((ass >> 30) != 1) /* no physical connection */ 755 return 0; 756 757 /* check sum */ 758 tmp = 0; 759 for (i = 1; i < 16; i++) { 760 if ((ass >> i) & 1) 761 tmp++; 762 } 763 if (((ass >> 16) & 0xf) != tmp) 764 return 0; 765 do_sku: 766 codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n", 767 ass & 0xffff, codec->core.vendor_id); 768 /* 769 * 0 : override 770 * 1 : Swap Jack 771 * 2 : 0 --> Desktop, 1 --> Laptop 772 * 3~5 : External Amplifier control 773 * 7~6 : Reserved 774 */ 775 tmp = (ass & 0x38) >> 3; /* external Amp control */ 776 if (spec->init_amp == ALC_INIT_UNDEFINED) { 777 switch (tmp) { 778 case 1: 779 alc_setup_gpio(codec, 0x01); 780 break; 781 case 3: 782 alc_setup_gpio(codec, 0x02); 783 break; 784 case 7: 785 alc_setup_gpio(codec, 0x03); 786 break; 787 case 5: 788 default: 789 spec->init_amp = ALC_INIT_DEFAULT; 790 break; 791 } 792 } 793 794 /* is laptop or Desktop and enable the function "Mute internal speaker 795 * when the external headphone out jack is plugged" 796 */ 797 if (!(ass & 0x8000)) 798 return 1; 799 /* 800 * 10~8 : Jack location 801 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered 802 * 14~13: Resvered 803 * 15 : 1 --> enable the function "Mute internal speaker 804 * when the external headphone out jack is plugged" 805 */ 806 if (!alc_get_hp_pin(spec)) { 807 hda_nid_t nid; 808 tmp = (ass >> 11) & 0x3; /* HP to chassis */ 809 nid = ports[tmp]; 810 if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins, 811 spec->gen.autocfg.line_outs)) 812 return 1; 813 spec->gen.autocfg.hp_pins[0] = nid; 814 } 815 return 1; 816 } 817 818 /* Check the validity of ALC subsystem-id 819 * ports contains an array of 4 pin NIDs for port-A, E, D and I */ 820 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports) 821 { 822 if (!alc_subsystem_id(codec, ports)) { 823 struct alc_spec *spec = codec->spec; 824 if (spec->init_amp == ALC_INIT_UNDEFINED) { 825 codec_dbg(codec, 826 "realtek: Enable default setup for auto mode as fallback\n"); 827 spec->init_amp = ALC_INIT_DEFAULT; 828 } 829 } 830 } 831 832 /* 833 */ 834 835 static void alc_fixup_inv_dmic(struct hda_codec *codec, 836 const struct hda_fixup *fix, int action) 837 { 838 struct alc_spec *spec = codec->spec; 839 840 spec->gen.inv_dmic_split = 1; 841 } 842 843 844 static int alc_build_controls(struct hda_codec *codec) 845 { 846 int err; 847 848 err = snd_hda_gen_build_controls(codec); 849 if (err < 0) 850 return err; 851 852 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD); 853 return 0; 854 } 855 856 857 /* 858 * Common callbacks 859 */ 860 861 static void alc_pre_init(struct hda_codec *codec) 862 { 863 alc_fill_eapd_coef(codec); 864 } 865 866 #define is_s3_resume(codec) \ 867 ((codec)->core.dev.power.power_state.event == PM_EVENT_RESUME) 868 #define is_s4_resume(codec) \ 869 ((codec)->core.dev.power.power_state.event == PM_EVENT_RESTORE) 870 871 static int alc_init(struct hda_codec *codec) 872 { 873 struct alc_spec *spec = codec->spec; 874 875 /* hibernation resume needs the full chip initialization */ 876 if (is_s4_resume(codec)) 877 alc_pre_init(codec); 878 879 if (spec->init_hook) 880 spec->init_hook(codec); 881 882 spec->gen.skip_verbs = 1; /* applied in below */ 883 snd_hda_gen_init(codec); 884 alc_fix_pll(codec); 885 alc_auto_init_amp(codec, spec->init_amp); 886 snd_hda_apply_verbs(codec); /* apply verbs here after own init */ 887 888 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT); 889 890 return 0; 891 } 892 893 static inline void alc_shutup(struct hda_codec *codec) 894 { 895 struct alc_spec *spec = codec->spec; 896 897 if (!snd_hda_get_bool_hint(codec, "shutup")) 898 return; /* disabled explicitly by hints */ 899 900 if (spec && spec->shutup) 901 spec->shutup(codec); 902 else 903 alc_shutup_pins(codec); 904 } 905 906 #define alc_free snd_hda_gen_free 907 908 #ifdef CONFIG_PM 909 static void alc_power_eapd(struct hda_codec *codec) 910 { 911 alc_auto_setup_eapd(codec, false); 912 } 913 914 static int alc_suspend(struct hda_codec *codec) 915 { 916 struct alc_spec *spec = codec->spec; 917 alc_shutup(codec); 918 if (spec && spec->power_hook) 919 spec->power_hook(codec); 920 return 0; 921 } 922 #endif 923 924 #ifdef CONFIG_PM 925 static int alc_resume(struct hda_codec *codec) 926 { 927 struct alc_spec *spec = codec->spec; 928 929 if (!spec->no_depop_delay) 930 msleep(150); /* to avoid pop noise */ 931 codec->patch_ops.init(codec); 932 snd_hda_regmap_sync(codec); 933 hda_call_check_power_status(codec, 0x01); 934 return 0; 935 } 936 #endif 937 938 /* 939 */ 940 static const struct hda_codec_ops alc_patch_ops = { 941 .build_controls = alc_build_controls, 942 .build_pcms = snd_hda_gen_build_pcms, 943 .init = alc_init, 944 .free = alc_free, 945 .unsol_event = snd_hda_jack_unsol_event, 946 #ifdef CONFIG_PM 947 .resume = alc_resume, 948 .suspend = alc_suspend, 949 .check_power_status = snd_hda_gen_check_power_status, 950 #endif 951 }; 952 953 954 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name) 955 956 /* 957 * Rename codecs appropriately from COEF value or subvendor id 958 */ 959 struct alc_codec_rename_table { 960 unsigned int vendor_id; 961 unsigned short coef_mask; 962 unsigned short coef_bits; 963 const char *name; 964 }; 965 966 struct alc_codec_rename_pci_table { 967 unsigned int codec_vendor_id; 968 unsigned short pci_subvendor; 969 unsigned short pci_subdevice; 970 const char *name; 971 }; 972 973 static const struct alc_codec_rename_table rename_tbl[] = { 974 { 0x10ec0221, 0xf00f, 0x1003, "ALC231" }, 975 { 0x10ec0269, 0xfff0, 0x3010, "ALC277" }, 976 { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" }, 977 { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" }, 978 { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" }, 979 { 0x10ec0269, 0xffff, 0xa023, "ALC259" }, 980 { 0x10ec0269, 0xffff, 0x6023, "ALC281X" }, 981 { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" }, 982 { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" }, 983 { 0x10ec0662, 0xffff, 0x4020, "ALC656" }, 984 { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" }, 985 { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" }, 986 { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" }, 987 { 0x10ec0899, 0x2000, 0x2000, "ALC899" }, 988 { 0x10ec0892, 0xffff, 0x8020, "ALC661" }, 989 { 0x10ec0892, 0xffff, 0x8011, "ALC661" }, 990 { 0x10ec0892, 0xffff, 0x4011, "ALC656" }, 991 { } /* terminator */ 992 }; 993 994 static const struct alc_codec_rename_pci_table rename_pci_tbl[] = { 995 { 0x10ec0280, 0x1028, 0, "ALC3220" }, 996 { 0x10ec0282, 0x1028, 0, "ALC3221" }, 997 { 0x10ec0283, 0x1028, 0, "ALC3223" }, 998 { 0x10ec0288, 0x1028, 0, "ALC3263" }, 999 { 0x10ec0292, 0x1028, 0, "ALC3226" }, 1000 { 0x10ec0293, 0x1028, 0, "ALC3235" }, 1001 { 0x10ec0255, 0x1028, 0, "ALC3234" }, 1002 { 0x10ec0668, 0x1028, 0, "ALC3661" }, 1003 { 0x10ec0275, 0x1028, 0, "ALC3260" }, 1004 { 0x10ec0899, 0x1028, 0, "ALC3861" }, 1005 { 0x10ec0298, 0x1028, 0, "ALC3266" }, 1006 { 0x10ec0236, 0x1028, 0, "ALC3204" }, 1007 { 0x10ec0256, 0x1028, 0, "ALC3246" }, 1008 { 0x10ec0225, 0x1028, 0, "ALC3253" }, 1009 { 0x10ec0295, 0x1028, 0, "ALC3254" }, 1010 { 0x10ec0299, 0x1028, 0, "ALC3271" }, 1011 { 0x10ec0670, 0x1025, 0, "ALC669X" }, 1012 { 0x10ec0676, 0x1025, 0, "ALC679X" }, 1013 { 0x10ec0282, 0x1043, 0, "ALC3229" }, 1014 { 0x10ec0233, 0x1043, 0, "ALC3236" }, 1015 { 0x10ec0280, 0x103c, 0, "ALC3228" }, 1016 { 0x10ec0282, 0x103c, 0, "ALC3227" }, 1017 { 0x10ec0286, 0x103c, 0, "ALC3242" }, 1018 { 0x10ec0290, 0x103c, 0, "ALC3241" }, 1019 { 0x10ec0668, 0x103c, 0, "ALC3662" }, 1020 { 0x10ec0283, 0x17aa, 0, "ALC3239" }, 1021 { 0x10ec0292, 0x17aa, 0, "ALC3232" }, 1022 { } /* terminator */ 1023 }; 1024 1025 static int alc_codec_rename_from_preset(struct hda_codec *codec) 1026 { 1027 const struct alc_codec_rename_table *p; 1028 const struct alc_codec_rename_pci_table *q; 1029 1030 for (p = rename_tbl; p->vendor_id; p++) { 1031 if (p->vendor_id != codec->core.vendor_id) 1032 continue; 1033 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits) 1034 return alc_codec_rename(codec, p->name); 1035 } 1036 1037 if (!codec->bus->pci) 1038 return 0; 1039 for (q = rename_pci_tbl; q->codec_vendor_id; q++) { 1040 if (q->codec_vendor_id != codec->core.vendor_id) 1041 continue; 1042 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor) 1043 continue; 1044 if (!q->pci_subdevice || 1045 q->pci_subdevice == codec->bus->pci->subsystem_device) 1046 return alc_codec_rename(codec, q->name); 1047 } 1048 1049 return 0; 1050 } 1051 1052 1053 /* 1054 * Digital-beep handlers 1055 */ 1056 #ifdef CONFIG_SND_HDA_INPUT_BEEP 1057 1058 /* additional beep mixers; private_value will be overwritten */ 1059 static const struct snd_kcontrol_new alc_beep_mixer[] = { 1060 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT), 1061 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT), 1062 }; 1063 1064 /* set up and create beep controls */ 1065 static int set_beep_amp(struct alc_spec *spec, hda_nid_t nid, 1066 int idx, int dir) 1067 { 1068 struct snd_kcontrol_new *knew; 1069 unsigned int beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir); 1070 int i; 1071 1072 for (i = 0; i < ARRAY_SIZE(alc_beep_mixer); i++) { 1073 knew = snd_hda_gen_add_kctl(&spec->gen, NULL, 1074 &alc_beep_mixer[i]); 1075 if (!knew) 1076 return -ENOMEM; 1077 knew->private_value = beep_amp; 1078 } 1079 return 0; 1080 } 1081 1082 static const struct snd_pci_quirk beep_allow_list[] = { 1083 SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1), 1084 SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1), 1085 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1), 1086 SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1), 1087 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1), 1088 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1), 1089 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1), 1090 SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1), 1091 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1), 1092 /* denylist -- no beep available */ 1093 SND_PCI_QUIRK(0x17aa, 0x309e, "Lenovo ThinkCentre M73", 0), 1094 SND_PCI_QUIRK(0x17aa, 0x30a3, "Lenovo ThinkCentre M93", 0), 1095 {} 1096 }; 1097 1098 static inline int has_cdefine_beep(struct hda_codec *codec) 1099 { 1100 struct alc_spec *spec = codec->spec; 1101 const struct snd_pci_quirk *q; 1102 q = snd_pci_quirk_lookup(codec->bus->pci, beep_allow_list); 1103 if (q) 1104 return q->value; 1105 return spec->cdefine.enable_pcbeep; 1106 } 1107 #else 1108 #define set_beep_amp(spec, nid, idx, dir) 0 1109 #define has_cdefine_beep(codec) 0 1110 #endif 1111 1112 /* parse the BIOS configuration and set up the alc_spec */ 1113 /* return 1 if successful, 0 if the proper config is not found, 1114 * or a negative error code 1115 */ 1116 static int alc_parse_auto_config(struct hda_codec *codec, 1117 const hda_nid_t *ignore_nids, 1118 const hda_nid_t *ssid_nids) 1119 { 1120 struct alc_spec *spec = codec->spec; 1121 struct auto_pin_cfg *cfg = &spec->gen.autocfg; 1122 int err; 1123 1124 err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids, 1125 spec->parse_flags); 1126 if (err < 0) 1127 return err; 1128 1129 if (ssid_nids) 1130 alc_ssid_check(codec, ssid_nids); 1131 1132 err = snd_hda_gen_parse_auto_config(codec, cfg); 1133 if (err < 0) 1134 return err; 1135 1136 return 1; 1137 } 1138 1139 /* common preparation job for alc_spec */ 1140 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid) 1141 { 1142 struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL); 1143 int err; 1144 1145 if (!spec) 1146 return -ENOMEM; 1147 codec->spec = spec; 1148 snd_hda_gen_spec_init(&spec->gen); 1149 spec->gen.mixer_nid = mixer_nid; 1150 spec->gen.own_eapd_ctl = 1; 1151 codec->single_adc_amp = 1; 1152 /* FIXME: do we need this for all Realtek codec models? */ 1153 codec->spdif_status_reset = 1; 1154 codec->forced_resume = 1; 1155 codec->patch_ops = alc_patch_ops; 1156 1157 err = alc_codec_rename_from_preset(codec); 1158 if (err < 0) { 1159 kfree(spec); 1160 return err; 1161 } 1162 return 0; 1163 } 1164 1165 static int alc880_parse_auto_config(struct hda_codec *codec) 1166 { 1167 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 }; 1168 static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 1169 return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids); 1170 } 1171 1172 /* 1173 * ALC880 fix-ups 1174 */ 1175 enum { 1176 ALC880_FIXUP_GPIO1, 1177 ALC880_FIXUP_GPIO2, 1178 ALC880_FIXUP_MEDION_RIM, 1179 ALC880_FIXUP_LG, 1180 ALC880_FIXUP_LG_LW25, 1181 ALC880_FIXUP_W810, 1182 ALC880_FIXUP_EAPD_COEF, 1183 ALC880_FIXUP_TCL_S700, 1184 ALC880_FIXUP_VOL_KNOB, 1185 ALC880_FIXUP_FUJITSU, 1186 ALC880_FIXUP_F1734, 1187 ALC880_FIXUP_UNIWILL, 1188 ALC880_FIXUP_UNIWILL_DIG, 1189 ALC880_FIXUP_Z71V, 1190 ALC880_FIXUP_ASUS_W5A, 1191 ALC880_FIXUP_3ST_BASE, 1192 ALC880_FIXUP_3ST, 1193 ALC880_FIXUP_3ST_DIG, 1194 ALC880_FIXUP_5ST_BASE, 1195 ALC880_FIXUP_5ST, 1196 ALC880_FIXUP_5ST_DIG, 1197 ALC880_FIXUP_6ST_BASE, 1198 ALC880_FIXUP_6ST, 1199 ALC880_FIXUP_6ST_DIG, 1200 ALC880_FIXUP_6ST_AUTOMUTE, 1201 }; 1202 1203 /* enable the volume-knob widget support on NID 0x21 */ 1204 static void alc880_fixup_vol_knob(struct hda_codec *codec, 1205 const struct hda_fixup *fix, int action) 1206 { 1207 if (action == HDA_FIXUP_ACT_PROBE) 1208 snd_hda_jack_detect_enable_callback(codec, 0x21, 1209 alc_update_knob_master); 1210 } 1211 1212 static const struct hda_fixup alc880_fixups[] = { 1213 [ALC880_FIXUP_GPIO1] = { 1214 .type = HDA_FIXUP_FUNC, 1215 .v.func = alc_fixup_gpio1, 1216 }, 1217 [ALC880_FIXUP_GPIO2] = { 1218 .type = HDA_FIXUP_FUNC, 1219 .v.func = alc_fixup_gpio2, 1220 }, 1221 [ALC880_FIXUP_MEDION_RIM] = { 1222 .type = HDA_FIXUP_VERBS, 1223 .v.verbs = (const struct hda_verb[]) { 1224 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 1225 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 }, 1226 { } 1227 }, 1228 .chained = true, 1229 .chain_id = ALC880_FIXUP_GPIO2, 1230 }, 1231 [ALC880_FIXUP_LG] = { 1232 .type = HDA_FIXUP_PINS, 1233 .v.pins = (const struct hda_pintbl[]) { 1234 /* disable bogus unused pins */ 1235 { 0x16, 0x411111f0 }, 1236 { 0x18, 0x411111f0 }, 1237 { 0x1a, 0x411111f0 }, 1238 { } 1239 } 1240 }, 1241 [ALC880_FIXUP_LG_LW25] = { 1242 .type = HDA_FIXUP_PINS, 1243 .v.pins = (const struct hda_pintbl[]) { 1244 { 0x1a, 0x0181344f }, /* line-in */ 1245 { 0x1b, 0x0321403f }, /* headphone */ 1246 { } 1247 } 1248 }, 1249 [ALC880_FIXUP_W810] = { 1250 .type = HDA_FIXUP_PINS, 1251 .v.pins = (const struct hda_pintbl[]) { 1252 /* disable bogus unused pins */ 1253 { 0x17, 0x411111f0 }, 1254 { } 1255 }, 1256 .chained = true, 1257 .chain_id = ALC880_FIXUP_GPIO2, 1258 }, 1259 [ALC880_FIXUP_EAPD_COEF] = { 1260 .type = HDA_FIXUP_VERBS, 1261 .v.verbs = (const struct hda_verb[]) { 1262 /* change to EAPD mode */ 1263 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 1264 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 }, 1265 {} 1266 }, 1267 }, 1268 [ALC880_FIXUP_TCL_S700] = { 1269 .type = HDA_FIXUP_VERBS, 1270 .v.verbs = (const struct hda_verb[]) { 1271 /* change to EAPD mode */ 1272 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 1273 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 }, 1274 {} 1275 }, 1276 .chained = true, 1277 .chain_id = ALC880_FIXUP_GPIO2, 1278 }, 1279 [ALC880_FIXUP_VOL_KNOB] = { 1280 .type = HDA_FIXUP_FUNC, 1281 .v.func = alc880_fixup_vol_knob, 1282 }, 1283 [ALC880_FIXUP_FUJITSU] = { 1284 /* override all pins as BIOS on old Amilo is broken */ 1285 .type = HDA_FIXUP_PINS, 1286 .v.pins = (const struct hda_pintbl[]) { 1287 { 0x14, 0x0121401f }, /* HP */ 1288 { 0x15, 0x99030120 }, /* speaker */ 1289 { 0x16, 0x99030130 }, /* bass speaker */ 1290 { 0x17, 0x411111f0 }, /* N/A */ 1291 { 0x18, 0x411111f0 }, /* N/A */ 1292 { 0x19, 0x01a19950 }, /* mic-in */ 1293 { 0x1a, 0x411111f0 }, /* N/A */ 1294 { 0x1b, 0x411111f0 }, /* N/A */ 1295 { 0x1c, 0x411111f0 }, /* N/A */ 1296 { 0x1d, 0x411111f0 }, /* N/A */ 1297 { 0x1e, 0x01454140 }, /* SPDIF out */ 1298 { } 1299 }, 1300 .chained = true, 1301 .chain_id = ALC880_FIXUP_VOL_KNOB, 1302 }, 1303 [ALC880_FIXUP_F1734] = { 1304 /* almost compatible with FUJITSU, but no bass and SPDIF */ 1305 .type = HDA_FIXUP_PINS, 1306 .v.pins = (const struct hda_pintbl[]) { 1307 { 0x14, 0x0121401f }, /* HP */ 1308 { 0x15, 0x99030120 }, /* speaker */ 1309 { 0x16, 0x411111f0 }, /* N/A */ 1310 { 0x17, 0x411111f0 }, /* N/A */ 1311 { 0x18, 0x411111f0 }, /* N/A */ 1312 { 0x19, 0x01a19950 }, /* mic-in */ 1313 { 0x1a, 0x411111f0 }, /* N/A */ 1314 { 0x1b, 0x411111f0 }, /* N/A */ 1315 { 0x1c, 0x411111f0 }, /* N/A */ 1316 { 0x1d, 0x411111f0 }, /* N/A */ 1317 { 0x1e, 0x411111f0 }, /* N/A */ 1318 { } 1319 }, 1320 .chained = true, 1321 .chain_id = ALC880_FIXUP_VOL_KNOB, 1322 }, 1323 [ALC880_FIXUP_UNIWILL] = { 1324 /* need to fix HP and speaker pins to be parsed correctly */ 1325 .type = HDA_FIXUP_PINS, 1326 .v.pins = (const struct hda_pintbl[]) { 1327 { 0x14, 0x0121411f }, /* HP */ 1328 { 0x15, 0x99030120 }, /* speaker */ 1329 { 0x16, 0x99030130 }, /* bass speaker */ 1330 { } 1331 }, 1332 }, 1333 [ALC880_FIXUP_UNIWILL_DIG] = { 1334 .type = HDA_FIXUP_PINS, 1335 .v.pins = (const struct hda_pintbl[]) { 1336 /* disable bogus unused pins */ 1337 { 0x17, 0x411111f0 }, 1338 { 0x19, 0x411111f0 }, 1339 { 0x1b, 0x411111f0 }, 1340 { 0x1f, 0x411111f0 }, 1341 { } 1342 } 1343 }, 1344 [ALC880_FIXUP_Z71V] = { 1345 .type = HDA_FIXUP_PINS, 1346 .v.pins = (const struct hda_pintbl[]) { 1347 /* set up the whole pins as BIOS is utterly broken */ 1348 { 0x14, 0x99030120 }, /* speaker */ 1349 { 0x15, 0x0121411f }, /* HP */ 1350 { 0x16, 0x411111f0 }, /* N/A */ 1351 { 0x17, 0x411111f0 }, /* N/A */ 1352 { 0x18, 0x01a19950 }, /* mic-in */ 1353 { 0x19, 0x411111f0 }, /* N/A */ 1354 { 0x1a, 0x01813031 }, /* line-in */ 1355 { 0x1b, 0x411111f0 }, /* N/A */ 1356 { 0x1c, 0x411111f0 }, /* N/A */ 1357 { 0x1d, 0x411111f0 }, /* N/A */ 1358 { 0x1e, 0x0144111e }, /* SPDIF */ 1359 { } 1360 } 1361 }, 1362 [ALC880_FIXUP_ASUS_W5A] = { 1363 .type = HDA_FIXUP_PINS, 1364 .v.pins = (const struct hda_pintbl[]) { 1365 /* set up the whole pins as BIOS is utterly broken */ 1366 { 0x14, 0x0121411f }, /* HP */ 1367 { 0x15, 0x411111f0 }, /* N/A */ 1368 { 0x16, 0x411111f0 }, /* N/A */ 1369 { 0x17, 0x411111f0 }, /* N/A */ 1370 { 0x18, 0x90a60160 }, /* mic */ 1371 { 0x19, 0x411111f0 }, /* N/A */ 1372 { 0x1a, 0x411111f0 }, /* N/A */ 1373 { 0x1b, 0x411111f0 }, /* N/A */ 1374 { 0x1c, 0x411111f0 }, /* N/A */ 1375 { 0x1d, 0x411111f0 }, /* N/A */ 1376 { 0x1e, 0xb743111e }, /* SPDIF out */ 1377 { } 1378 }, 1379 .chained = true, 1380 .chain_id = ALC880_FIXUP_GPIO1, 1381 }, 1382 [ALC880_FIXUP_3ST_BASE] = { 1383 .type = HDA_FIXUP_PINS, 1384 .v.pins = (const struct hda_pintbl[]) { 1385 { 0x14, 0x01014010 }, /* line-out */ 1386 { 0x15, 0x411111f0 }, /* N/A */ 1387 { 0x16, 0x411111f0 }, /* N/A */ 1388 { 0x17, 0x411111f0 }, /* N/A */ 1389 { 0x18, 0x01a19c30 }, /* mic-in */ 1390 { 0x19, 0x0121411f }, /* HP */ 1391 { 0x1a, 0x01813031 }, /* line-in */ 1392 { 0x1b, 0x02a19c40 }, /* front-mic */ 1393 { 0x1c, 0x411111f0 }, /* N/A */ 1394 { 0x1d, 0x411111f0 }, /* N/A */ 1395 /* 0x1e is filled in below */ 1396 { 0x1f, 0x411111f0 }, /* N/A */ 1397 { } 1398 } 1399 }, 1400 [ALC880_FIXUP_3ST] = { 1401 .type = HDA_FIXUP_PINS, 1402 .v.pins = (const struct hda_pintbl[]) { 1403 { 0x1e, 0x411111f0 }, /* N/A */ 1404 { } 1405 }, 1406 .chained = true, 1407 .chain_id = ALC880_FIXUP_3ST_BASE, 1408 }, 1409 [ALC880_FIXUP_3ST_DIG] = { 1410 .type = HDA_FIXUP_PINS, 1411 .v.pins = (const struct hda_pintbl[]) { 1412 { 0x1e, 0x0144111e }, /* SPDIF */ 1413 { } 1414 }, 1415 .chained = true, 1416 .chain_id = ALC880_FIXUP_3ST_BASE, 1417 }, 1418 [ALC880_FIXUP_5ST_BASE] = { 1419 .type = HDA_FIXUP_PINS, 1420 .v.pins = (const struct hda_pintbl[]) { 1421 { 0x14, 0x01014010 }, /* front */ 1422 { 0x15, 0x411111f0 }, /* N/A */ 1423 { 0x16, 0x01011411 }, /* CLFE */ 1424 { 0x17, 0x01016412 }, /* surr */ 1425 { 0x18, 0x01a19c30 }, /* mic-in */ 1426 { 0x19, 0x0121411f }, /* HP */ 1427 { 0x1a, 0x01813031 }, /* line-in */ 1428 { 0x1b, 0x02a19c40 }, /* front-mic */ 1429 { 0x1c, 0x411111f0 }, /* N/A */ 1430 { 0x1d, 0x411111f0 }, /* N/A */ 1431 /* 0x1e is filled in below */ 1432 { 0x1f, 0x411111f0 }, /* N/A */ 1433 { } 1434 } 1435 }, 1436 [ALC880_FIXUP_5ST] = { 1437 .type = HDA_FIXUP_PINS, 1438 .v.pins = (const struct hda_pintbl[]) { 1439 { 0x1e, 0x411111f0 }, /* N/A */ 1440 { } 1441 }, 1442 .chained = true, 1443 .chain_id = ALC880_FIXUP_5ST_BASE, 1444 }, 1445 [ALC880_FIXUP_5ST_DIG] = { 1446 .type = HDA_FIXUP_PINS, 1447 .v.pins = (const struct hda_pintbl[]) { 1448 { 0x1e, 0x0144111e }, /* SPDIF */ 1449 { } 1450 }, 1451 .chained = true, 1452 .chain_id = ALC880_FIXUP_5ST_BASE, 1453 }, 1454 [ALC880_FIXUP_6ST_BASE] = { 1455 .type = HDA_FIXUP_PINS, 1456 .v.pins = (const struct hda_pintbl[]) { 1457 { 0x14, 0x01014010 }, /* front */ 1458 { 0x15, 0x01016412 }, /* surr */ 1459 { 0x16, 0x01011411 }, /* CLFE */ 1460 { 0x17, 0x01012414 }, /* side */ 1461 { 0x18, 0x01a19c30 }, /* mic-in */ 1462 { 0x19, 0x02a19c40 }, /* front-mic */ 1463 { 0x1a, 0x01813031 }, /* line-in */ 1464 { 0x1b, 0x0121411f }, /* HP */ 1465 { 0x1c, 0x411111f0 }, /* N/A */ 1466 { 0x1d, 0x411111f0 }, /* N/A */ 1467 /* 0x1e is filled in below */ 1468 { 0x1f, 0x411111f0 }, /* N/A */ 1469 { } 1470 } 1471 }, 1472 [ALC880_FIXUP_6ST] = { 1473 .type = HDA_FIXUP_PINS, 1474 .v.pins = (const struct hda_pintbl[]) { 1475 { 0x1e, 0x411111f0 }, /* N/A */ 1476 { } 1477 }, 1478 .chained = true, 1479 .chain_id = ALC880_FIXUP_6ST_BASE, 1480 }, 1481 [ALC880_FIXUP_6ST_DIG] = { 1482 .type = HDA_FIXUP_PINS, 1483 .v.pins = (const struct hda_pintbl[]) { 1484 { 0x1e, 0x0144111e }, /* SPDIF */ 1485 { } 1486 }, 1487 .chained = true, 1488 .chain_id = ALC880_FIXUP_6ST_BASE, 1489 }, 1490 [ALC880_FIXUP_6ST_AUTOMUTE] = { 1491 .type = HDA_FIXUP_PINS, 1492 .v.pins = (const struct hda_pintbl[]) { 1493 { 0x1b, 0x0121401f }, /* HP with jack detect */ 1494 { } 1495 }, 1496 .chained_before = true, 1497 .chain_id = ALC880_FIXUP_6ST_BASE, 1498 }, 1499 }; 1500 1501 static const struct snd_pci_quirk alc880_fixup_tbl[] = { 1502 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810), 1503 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A), 1504 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V), 1505 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1), 1506 SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE), 1507 SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2), 1508 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF), 1509 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG), 1510 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734), 1511 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL), 1512 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB), 1513 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810), 1514 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM), 1515 SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE), 1516 SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU), 1517 SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU), 1518 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734), 1519 SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU), 1520 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG), 1521 SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG), 1522 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG), 1523 SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25), 1524 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700), 1525 1526 /* Below is the copied entries from alc880_quirks.c. 1527 * It's not quite sure whether BIOS sets the correct pin-config table 1528 * on these machines, thus they are kept to be compatible with 1529 * the old static quirks. Once when it's confirmed to work without 1530 * these overrides, it'd be better to remove. 1531 */ 1532 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG), 1533 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST), 1534 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG), 1535 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG), 1536 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG), 1537 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG), 1538 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG), 1539 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST), 1540 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG), 1541 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST), 1542 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST), 1543 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST), 1544 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST), 1545 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST), 1546 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG), 1547 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG), 1548 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG), 1549 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG), 1550 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG), 1551 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG), 1552 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG), 1553 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */ 1554 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG), 1555 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1556 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1557 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1558 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG), 1559 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1560 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG), 1561 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG), 1562 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1563 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1564 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1565 /* default Intel */ 1566 SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST), 1567 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG), 1568 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG), 1569 {} 1570 }; 1571 1572 static const struct hda_model_fixup alc880_fixup_models[] = { 1573 {.id = ALC880_FIXUP_3ST, .name = "3stack"}, 1574 {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"}, 1575 {.id = ALC880_FIXUP_5ST, .name = "5stack"}, 1576 {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"}, 1577 {.id = ALC880_FIXUP_6ST, .name = "6stack"}, 1578 {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"}, 1579 {.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"}, 1580 {} 1581 }; 1582 1583 1584 /* 1585 * OK, here we have finally the patch for ALC880 1586 */ 1587 static int patch_alc880(struct hda_codec *codec) 1588 { 1589 struct alc_spec *spec; 1590 int err; 1591 1592 err = alc_alloc_spec(codec, 0x0b); 1593 if (err < 0) 1594 return err; 1595 1596 spec = codec->spec; 1597 spec->gen.need_dac_fix = 1; 1598 spec->gen.beep_nid = 0x01; 1599 1600 codec->patch_ops.unsol_event = alc880_unsol_event; 1601 1602 alc_pre_init(codec); 1603 1604 snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl, 1605 alc880_fixups); 1606 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 1607 1608 /* automatic parse from the BIOS config */ 1609 err = alc880_parse_auto_config(codec); 1610 if (err < 0) 1611 goto error; 1612 1613 if (!spec->gen.no_analog) { 1614 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 1615 if (err < 0) 1616 goto error; 1617 } 1618 1619 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 1620 1621 return 0; 1622 1623 error: 1624 alc_free(codec); 1625 return err; 1626 } 1627 1628 1629 /* 1630 * ALC260 support 1631 */ 1632 static int alc260_parse_auto_config(struct hda_codec *codec) 1633 { 1634 static const hda_nid_t alc260_ignore[] = { 0x17, 0 }; 1635 static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 }; 1636 return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids); 1637 } 1638 1639 /* 1640 * Pin config fixes 1641 */ 1642 enum { 1643 ALC260_FIXUP_HP_DC5750, 1644 ALC260_FIXUP_HP_PIN_0F, 1645 ALC260_FIXUP_COEF, 1646 ALC260_FIXUP_GPIO1, 1647 ALC260_FIXUP_GPIO1_TOGGLE, 1648 ALC260_FIXUP_REPLACER, 1649 ALC260_FIXUP_HP_B1900, 1650 ALC260_FIXUP_KN1, 1651 ALC260_FIXUP_FSC_S7020, 1652 ALC260_FIXUP_FSC_S7020_JWSE, 1653 ALC260_FIXUP_VAIO_PINS, 1654 }; 1655 1656 static void alc260_gpio1_automute(struct hda_codec *codec) 1657 { 1658 struct alc_spec *spec = codec->spec; 1659 1660 alc_update_gpio_data(codec, 0x01, spec->gen.hp_jack_present); 1661 } 1662 1663 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec, 1664 const struct hda_fixup *fix, int action) 1665 { 1666 struct alc_spec *spec = codec->spec; 1667 if (action == HDA_FIXUP_ACT_PROBE) { 1668 /* although the machine has only one output pin, we need to 1669 * toggle GPIO1 according to the jack state 1670 */ 1671 spec->gen.automute_hook = alc260_gpio1_automute; 1672 spec->gen.detect_hp = 1; 1673 spec->gen.automute_speaker = 1; 1674 spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */ 1675 snd_hda_jack_detect_enable_callback(codec, 0x0f, 1676 snd_hda_gen_hp_automute); 1677 alc_setup_gpio(codec, 0x01); 1678 } 1679 } 1680 1681 static void alc260_fixup_kn1(struct hda_codec *codec, 1682 const struct hda_fixup *fix, int action) 1683 { 1684 struct alc_spec *spec = codec->spec; 1685 static const struct hda_pintbl pincfgs[] = { 1686 { 0x0f, 0x02214000 }, /* HP/speaker */ 1687 { 0x12, 0x90a60160 }, /* int mic */ 1688 { 0x13, 0x02a19000 }, /* ext mic */ 1689 { 0x18, 0x01446000 }, /* SPDIF out */ 1690 /* disable bogus I/O pins */ 1691 { 0x10, 0x411111f0 }, 1692 { 0x11, 0x411111f0 }, 1693 { 0x14, 0x411111f0 }, 1694 { 0x15, 0x411111f0 }, 1695 { 0x16, 0x411111f0 }, 1696 { 0x17, 0x411111f0 }, 1697 { 0x19, 0x411111f0 }, 1698 { } 1699 }; 1700 1701 switch (action) { 1702 case HDA_FIXUP_ACT_PRE_PROBE: 1703 snd_hda_apply_pincfgs(codec, pincfgs); 1704 spec->init_amp = ALC_INIT_NONE; 1705 break; 1706 } 1707 } 1708 1709 static void alc260_fixup_fsc_s7020(struct hda_codec *codec, 1710 const struct hda_fixup *fix, int action) 1711 { 1712 struct alc_spec *spec = codec->spec; 1713 if (action == HDA_FIXUP_ACT_PRE_PROBE) 1714 spec->init_amp = ALC_INIT_NONE; 1715 } 1716 1717 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec, 1718 const struct hda_fixup *fix, int action) 1719 { 1720 struct alc_spec *spec = codec->spec; 1721 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1722 spec->gen.add_jack_modes = 1; 1723 spec->gen.hp_mic = 1; 1724 } 1725 } 1726 1727 static const struct hda_fixup alc260_fixups[] = { 1728 [ALC260_FIXUP_HP_DC5750] = { 1729 .type = HDA_FIXUP_PINS, 1730 .v.pins = (const struct hda_pintbl[]) { 1731 { 0x11, 0x90130110 }, /* speaker */ 1732 { } 1733 } 1734 }, 1735 [ALC260_FIXUP_HP_PIN_0F] = { 1736 .type = HDA_FIXUP_PINS, 1737 .v.pins = (const struct hda_pintbl[]) { 1738 { 0x0f, 0x01214000 }, /* HP */ 1739 { } 1740 } 1741 }, 1742 [ALC260_FIXUP_COEF] = { 1743 .type = HDA_FIXUP_VERBS, 1744 .v.verbs = (const struct hda_verb[]) { 1745 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 }, 1746 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3040 }, 1747 { } 1748 }, 1749 }, 1750 [ALC260_FIXUP_GPIO1] = { 1751 .type = HDA_FIXUP_FUNC, 1752 .v.func = alc_fixup_gpio1, 1753 }, 1754 [ALC260_FIXUP_GPIO1_TOGGLE] = { 1755 .type = HDA_FIXUP_FUNC, 1756 .v.func = alc260_fixup_gpio1_toggle, 1757 .chained = true, 1758 .chain_id = ALC260_FIXUP_HP_PIN_0F, 1759 }, 1760 [ALC260_FIXUP_REPLACER] = { 1761 .type = HDA_FIXUP_VERBS, 1762 .v.verbs = (const struct hda_verb[]) { 1763 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 }, 1764 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3050 }, 1765 { } 1766 }, 1767 .chained = true, 1768 .chain_id = ALC260_FIXUP_GPIO1_TOGGLE, 1769 }, 1770 [ALC260_FIXUP_HP_B1900] = { 1771 .type = HDA_FIXUP_FUNC, 1772 .v.func = alc260_fixup_gpio1_toggle, 1773 .chained = true, 1774 .chain_id = ALC260_FIXUP_COEF, 1775 }, 1776 [ALC260_FIXUP_KN1] = { 1777 .type = HDA_FIXUP_FUNC, 1778 .v.func = alc260_fixup_kn1, 1779 }, 1780 [ALC260_FIXUP_FSC_S7020] = { 1781 .type = HDA_FIXUP_FUNC, 1782 .v.func = alc260_fixup_fsc_s7020, 1783 }, 1784 [ALC260_FIXUP_FSC_S7020_JWSE] = { 1785 .type = HDA_FIXUP_FUNC, 1786 .v.func = alc260_fixup_fsc_s7020_jwse, 1787 .chained = true, 1788 .chain_id = ALC260_FIXUP_FSC_S7020, 1789 }, 1790 [ALC260_FIXUP_VAIO_PINS] = { 1791 .type = HDA_FIXUP_PINS, 1792 .v.pins = (const struct hda_pintbl[]) { 1793 /* Pin configs are missing completely on some VAIOs */ 1794 { 0x0f, 0x01211020 }, 1795 { 0x10, 0x0001003f }, 1796 { 0x11, 0x411111f0 }, 1797 { 0x12, 0x01a15930 }, 1798 { 0x13, 0x411111f0 }, 1799 { 0x14, 0x411111f0 }, 1800 { 0x15, 0x411111f0 }, 1801 { 0x16, 0x411111f0 }, 1802 { 0x17, 0x411111f0 }, 1803 { 0x18, 0x411111f0 }, 1804 { 0x19, 0x411111f0 }, 1805 { } 1806 } 1807 }, 1808 }; 1809 1810 static const struct snd_pci_quirk alc260_fixup_tbl[] = { 1811 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1), 1812 SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF), 1813 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1), 1814 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750), 1815 SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900), 1816 SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS), 1817 SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F), 1818 SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020), 1819 SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1), 1820 SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1), 1821 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER), 1822 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF), 1823 {} 1824 }; 1825 1826 static const struct hda_model_fixup alc260_fixup_models[] = { 1827 {.id = ALC260_FIXUP_GPIO1, .name = "gpio1"}, 1828 {.id = ALC260_FIXUP_COEF, .name = "coef"}, 1829 {.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"}, 1830 {.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"}, 1831 {} 1832 }; 1833 1834 /* 1835 */ 1836 static int patch_alc260(struct hda_codec *codec) 1837 { 1838 struct alc_spec *spec; 1839 int err; 1840 1841 err = alc_alloc_spec(codec, 0x07); 1842 if (err < 0) 1843 return err; 1844 1845 spec = codec->spec; 1846 /* as quite a few machines require HP amp for speaker outputs, 1847 * it's easier to enable it unconditionally; even if it's unneeded, 1848 * it's almost harmless. 1849 */ 1850 spec->gen.prefer_hp_amp = 1; 1851 spec->gen.beep_nid = 0x01; 1852 1853 spec->shutup = alc_eapd_shutup; 1854 1855 alc_pre_init(codec); 1856 1857 snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl, 1858 alc260_fixups); 1859 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 1860 1861 /* automatic parse from the BIOS config */ 1862 err = alc260_parse_auto_config(codec); 1863 if (err < 0) 1864 goto error; 1865 1866 if (!spec->gen.no_analog) { 1867 err = set_beep_amp(spec, 0x07, 0x05, HDA_INPUT); 1868 if (err < 0) 1869 goto error; 1870 } 1871 1872 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 1873 1874 return 0; 1875 1876 error: 1877 alc_free(codec); 1878 return err; 1879 } 1880 1881 1882 /* 1883 * ALC882/883/885/888/889 support 1884 * 1885 * ALC882 is almost identical with ALC880 but has cleaner and more flexible 1886 * configuration. Each pin widget can choose any input DACs and a mixer. 1887 * Each ADC is connected from a mixer of all inputs. This makes possible 1888 * 6-channel independent captures. 1889 * 1890 * In addition, an independent DAC for the multi-playback (not used in this 1891 * driver yet). 1892 */ 1893 1894 /* 1895 * Pin config fixes 1896 */ 1897 enum { 1898 ALC882_FIXUP_ABIT_AW9D_MAX, 1899 ALC882_FIXUP_LENOVO_Y530, 1900 ALC882_FIXUP_PB_M5210, 1901 ALC882_FIXUP_ACER_ASPIRE_7736, 1902 ALC882_FIXUP_ASUS_W90V, 1903 ALC889_FIXUP_CD, 1904 ALC889_FIXUP_FRONT_HP_NO_PRESENCE, 1905 ALC889_FIXUP_VAIO_TT, 1906 ALC888_FIXUP_EEE1601, 1907 ALC886_FIXUP_EAPD, 1908 ALC882_FIXUP_EAPD, 1909 ALC883_FIXUP_EAPD, 1910 ALC883_FIXUP_ACER_EAPD, 1911 ALC882_FIXUP_GPIO1, 1912 ALC882_FIXUP_GPIO2, 1913 ALC882_FIXUP_GPIO3, 1914 ALC889_FIXUP_COEF, 1915 ALC882_FIXUP_ASUS_W2JC, 1916 ALC882_FIXUP_ACER_ASPIRE_4930G, 1917 ALC882_FIXUP_ACER_ASPIRE_8930G, 1918 ALC882_FIXUP_ASPIRE_8930G_VERBS, 1919 ALC885_FIXUP_MACPRO_GPIO, 1920 ALC889_FIXUP_DAC_ROUTE, 1921 ALC889_FIXUP_MBP_VREF, 1922 ALC889_FIXUP_IMAC91_VREF, 1923 ALC889_FIXUP_MBA11_VREF, 1924 ALC889_FIXUP_MBA21_VREF, 1925 ALC889_FIXUP_MP11_VREF, 1926 ALC889_FIXUP_MP41_VREF, 1927 ALC882_FIXUP_INV_DMIC, 1928 ALC882_FIXUP_NO_PRIMARY_HP, 1929 ALC887_FIXUP_ASUS_BASS, 1930 ALC887_FIXUP_BASS_CHMAP, 1931 ALC1220_FIXUP_GB_DUAL_CODECS, 1932 ALC1220_FIXUP_GB_X570, 1933 ALC1220_FIXUP_CLEVO_P950, 1934 ALC1220_FIXUP_CLEVO_PB51ED, 1935 ALC1220_FIXUP_CLEVO_PB51ED_PINS, 1936 ALC887_FIXUP_ASUS_AUDIO, 1937 ALC887_FIXUP_ASUS_HMIC, 1938 }; 1939 1940 static void alc889_fixup_coef(struct hda_codec *codec, 1941 const struct hda_fixup *fix, int action) 1942 { 1943 if (action != HDA_FIXUP_ACT_INIT) 1944 return; 1945 alc_update_coef_idx(codec, 7, 0, 0x2030); 1946 } 1947 1948 /* set up GPIO at initialization */ 1949 static void alc885_fixup_macpro_gpio(struct hda_codec *codec, 1950 const struct hda_fixup *fix, int action) 1951 { 1952 struct alc_spec *spec = codec->spec; 1953 1954 spec->gpio_write_delay = true; 1955 alc_fixup_gpio3(codec, fix, action); 1956 } 1957 1958 /* Fix the connection of some pins for ALC889: 1959 * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't 1960 * work correctly (bko#42740) 1961 */ 1962 static void alc889_fixup_dac_route(struct hda_codec *codec, 1963 const struct hda_fixup *fix, int action) 1964 { 1965 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1966 /* fake the connections during parsing the tree */ 1967 static const hda_nid_t conn1[] = { 0x0c, 0x0d }; 1968 static const hda_nid_t conn2[] = { 0x0e, 0x0f }; 1969 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1); 1970 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1); 1971 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn2), conn2); 1972 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn2), conn2); 1973 } else if (action == HDA_FIXUP_ACT_PROBE) { 1974 /* restore the connections */ 1975 static const hda_nid_t conn[] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 }; 1976 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn); 1977 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn), conn); 1978 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn), conn); 1979 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn), conn); 1980 } 1981 } 1982 1983 /* Set VREF on HP pin */ 1984 static void alc889_fixup_mbp_vref(struct hda_codec *codec, 1985 const struct hda_fixup *fix, int action) 1986 { 1987 static const hda_nid_t nids[] = { 0x14, 0x15, 0x19 }; 1988 struct alc_spec *spec = codec->spec; 1989 int i; 1990 1991 if (action != HDA_FIXUP_ACT_INIT) 1992 return; 1993 for (i = 0; i < ARRAY_SIZE(nids); i++) { 1994 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]); 1995 if (get_defcfg_device(val) != AC_JACK_HP_OUT) 1996 continue; 1997 val = snd_hda_codec_get_pin_target(codec, nids[i]); 1998 val |= AC_PINCTL_VREF_80; 1999 snd_hda_set_pin_ctl(codec, nids[i], val); 2000 spec->gen.keep_vref_in_automute = 1; 2001 break; 2002 } 2003 } 2004 2005 static void alc889_fixup_mac_pins(struct hda_codec *codec, 2006 const hda_nid_t *nids, int num_nids) 2007 { 2008 struct alc_spec *spec = codec->spec; 2009 int i; 2010 2011 for (i = 0; i < num_nids; i++) { 2012 unsigned int val; 2013 val = snd_hda_codec_get_pin_target(codec, nids[i]); 2014 val |= AC_PINCTL_VREF_50; 2015 snd_hda_set_pin_ctl(codec, nids[i], val); 2016 } 2017 spec->gen.keep_vref_in_automute = 1; 2018 } 2019 2020 /* Set VREF on speaker pins on imac91 */ 2021 static void alc889_fixup_imac91_vref(struct hda_codec *codec, 2022 const struct hda_fixup *fix, int action) 2023 { 2024 static const hda_nid_t nids[] = { 0x18, 0x1a }; 2025 2026 if (action == HDA_FIXUP_ACT_INIT) 2027 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids)); 2028 } 2029 2030 /* Set VREF on speaker pins on mba11 */ 2031 static void alc889_fixup_mba11_vref(struct hda_codec *codec, 2032 const struct hda_fixup *fix, int action) 2033 { 2034 static const hda_nid_t nids[] = { 0x18 }; 2035 2036 if (action == HDA_FIXUP_ACT_INIT) 2037 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids)); 2038 } 2039 2040 /* Set VREF on speaker pins on mba21 */ 2041 static void alc889_fixup_mba21_vref(struct hda_codec *codec, 2042 const struct hda_fixup *fix, int action) 2043 { 2044 static const hda_nid_t nids[] = { 0x18, 0x19 }; 2045 2046 if (action == HDA_FIXUP_ACT_INIT) 2047 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids)); 2048 } 2049 2050 /* Don't take HP output as primary 2051 * Strangely, the speaker output doesn't work on Vaio Z and some Vaio 2052 * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05 2053 */ 2054 static void alc882_fixup_no_primary_hp(struct hda_codec *codec, 2055 const struct hda_fixup *fix, int action) 2056 { 2057 struct alc_spec *spec = codec->spec; 2058 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 2059 spec->gen.no_primary_hp = 1; 2060 spec->gen.no_multi_io = 1; 2061 } 2062 } 2063 2064 static void alc_fixup_bass_chmap(struct hda_codec *codec, 2065 const struct hda_fixup *fix, int action); 2066 2067 /* For dual-codec configuration, we need to disable some features to avoid 2068 * conflicts of kctls and PCM streams 2069 */ 2070 static void alc_fixup_dual_codecs(struct hda_codec *codec, 2071 const struct hda_fixup *fix, int action) 2072 { 2073 struct alc_spec *spec = codec->spec; 2074 2075 if (action != HDA_FIXUP_ACT_PRE_PROBE) 2076 return; 2077 /* disable vmaster */ 2078 spec->gen.suppress_vmaster = 1; 2079 /* auto-mute and auto-mic switch don't work with multiple codecs */ 2080 spec->gen.suppress_auto_mute = 1; 2081 spec->gen.suppress_auto_mic = 1; 2082 /* disable aamix as well */ 2083 spec->gen.mixer_nid = 0; 2084 /* add location prefix to avoid conflicts */ 2085 codec->force_pin_prefix = 1; 2086 } 2087 2088 static void rename_ctl(struct hda_codec *codec, const char *oldname, 2089 const char *newname) 2090 { 2091 struct snd_kcontrol *kctl; 2092 2093 kctl = snd_hda_find_mixer_ctl(codec, oldname); 2094 if (kctl) 2095 strcpy(kctl->id.name, newname); 2096 } 2097 2098 static void alc1220_fixup_gb_dual_codecs(struct hda_codec *codec, 2099 const struct hda_fixup *fix, 2100 int action) 2101 { 2102 alc_fixup_dual_codecs(codec, fix, action); 2103 switch (action) { 2104 case HDA_FIXUP_ACT_PRE_PROBE: 2105 /* override card longname to provide a unique UCM profile */ 2106 strcpy(codec->card->longname, "HDAudio-Gigabyte-ALC1220DualCodecs"); 2107 break; 2108 case HDA_FIXUP_ACT_BUILD: 2109 /* rename Capture controls depending on the codec */ 2110 rename_ctl(codec, "Capture Volume", 2111 codec->addr == 0 ? 2112 "Rear-Panel Capture Volume" : 2113 "Front-Panel Capture Volume"); 2114 rename_ctl(codec, "Capture Switch", 2115 codec->addr == 0 ? 2116 "Rear-Panel Capture Switch" : 2117 "Front-Panel Capture Switch"); 2118 break; 2119 } 2120 } 2121 2122 static void alc1220_fixup_gb_x570(struct hda_codec *codec, 2123 const struct hda_fixup *fix, 2124 int action) 2125 { 2126 static const hda_nid_t conn1[] = { 0x0c }; 2127 static const struct coef_fw gb_x570_coefs[] = { 2128 WRITE_COEF(0x1a, 0x01c1), 2129 WRITE_COEF(0x1b, 0x0202), 2130 WRITE_COEF(0x43, 0x3005), 2131 {} 2132 }; 2133 2134 switch (action) { 2135 case HDA_FIXUP_ACT_PRE_PROBE: 2136 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1); 2137 snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1); 2138 break; 2139 case HDA_FIXUP_ACT_INIT: 2140 alc_process_coef_fw(codec, gb_x570_coefs); 2141 break; 2142 } 2143 } 2144 2145 static void alc1220_fixup_clevo_p950(struct hda_codec *codec, 2146 const struct hda_fixup *fix, 2147 int action) 2148 { 2149 static const hda_nid_t conn1[] = { 0x0c }; 2150 2151 if (action != HDA_FIXUP_ACT_PRE_PROBE) 2152 return; 2153 2154 alc_update_coef_idx(codec, 0x7, 0, 0x3c3); 2155 /* We therefore want to make sure 0x14 (front headphone) and 2156 * 0x1b (speakers) use the stereo DAC 0x02 2157 */ 2158 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1); 2159 snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1); 2160 } 2161 2162 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec, 2163 const struct hda_fixup *fix, int action); 2164 2165 static void alc1220_fixup_clevo_pb51ed(struct hda_codec *codec, 2166 const struct hda_fixup *fix, 2167 int action) 2168 { 2169 alc1220_fixup_clevo_p950(codec, fix, action); 2170 alc_fixup_headset_mode_no_hp_mic(codec, fix, action); 2171 } 2172 2173 static void alc887_asus_hp_automute_hook(struct hda_codec *codec, 2174 struct hda_jack_callback *jack) 2175 { 2176 struct alc_spec *spec = codec->spec; 2177 unsigned int vref; 2178 2179 snd_hda_gen_hp_automute(codec, jack); 2180 2181 if (spec->gen.hp_jack_present) 2182 vref = AC_PINCTL_VREF_80; 2183 else 2184 vref = AC_PINCTL_VREF_HIZ; 2185 snd_hda_set_pin_ctl(codec, 0x19, PIN_HP | vref); 2186 } 2187 2188 static void alc887_fixup_asus_jack(struct hda_codec *codec, 2189 const struct hda_fixup *fix, int action) 2190 { 2191 struct alc_spec *spec = codec->spec; 2192 if (action != HDA_FIXUP_ACT_PROBE) 2193 return; 2194 snd_hda_set_pin_ctl_cache(codec, 0x1b, PIN_HP); 2195 spec->gen.hp_automute_hook = alc887_asus_hp_automute_hook; 2196 } 2197 2198 static const struct hda_fixup alc882_fixups[] = { 2199 [ALC882_FIXUP_ABIT_AW9D_MAX] = { 2200 .type = HDA_FIXUP_PINS, 2201 .v.pins = (const struct hda_pintbl[]) { 2202 { 0x15, 0x01080104 }, /* side */ 2203 { 0x16, 0x01011012 }, /* rear */ 2204 { 0x17, 0x01016011 }, /* clfe */ 2205 { } 2206 } 2207 }, 2208 [ALC882_FIXUP_LENOVO_Y530] = { 2209 .type = HDA_FIXUP_PINS, 2210 .v.pins = (const struct hda_pintbl[]) { 2211 { 0x15, 0x99130112 }, /* rear int speakers */ 2212 { 0x16, 0x99130111 }, /* subwoofer */ 2213 { } 2214 } 2215 }, 2216 [ALC882_FIXUP_PB_M5210] = { 2217 .type = HDA_FIXUP_PINCTLS, 2218 .v.pins = (const struct hda_pintbl[]) { 2219 { 0x19, PIN_VREF50 }, 2220 {} 2221 } 2222 }, 2223 [ALC882_FIXUP_ACER_ASPIRE_7736] = { 2224 .type = HDA_FIXUP_FUNC, 2225 .v.func = alc_fixup_sku_ignore, 2226 }, 2227 [ALC882_FIXUP_ASUS_W90V] = { 2228 .type = HDA_FIXUP_PINS, 2229 .v.pins = (const struct hda_pintbl[]) { 2230 { 0x16, 0x99130110 }, /* fix sequence for CLFE */ 2231 { } 2232 } 2233 }, 2234 [ALC889_FIXUP_CD] = { 2235 .type = HDA_FIXUP_PINS, 2236 .v.pins = (const struct hda_pintbl[]) { 2237 { 0x1c, 0x993301f0 }, /* CD */ 2238 { } 2239 } 2240 }, 2241 [ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = { 2242 .type = HDA_FIXUP_PINS, 2243 .v.pins = (const struct hda_pintbl[]) { 2244 { 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */ 2245 { } 2246 }, 2247 .chained = true, 2248 .chain_id = ALC889_FIXUP_CD, 2249 }, 2250 [ALC889_FIXUP_VAIO_TT] = { 2251 .type = HDA_FIXUP_PINS, 2252 .v.pins = (const struct hda_pintbl[]) { 2253 { 0x17, 0x90170111 }, /* hidden surround speaker */ 2254 { } 2255 } 2256 }, 2257 [ALC888_FIXUP_EEE1601] = { 2258 .type = HDA_FIXUP_VERBS, 2259 .v.verbs = (const struct hda_verb[]) { 2260 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b }, 2261 { 0x20, AC_VERB_SET_PROC_COEF, 0x0838 }, 2262 { } 2263 } 2264 }, 2265 [ALC886_FIXUP_EAPD] = { 2266 .type = HDA_FIXUP_VERBS, 2267 .v.verbs = (const struct hda_verb[]) { 2268 /* change to EAPD mode */ 2269 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2270 { 0x20, AC_VERB_SET_PROC_COEF, 0x0068 }, 2271 { } 2272 } 2273 }, 2274 [ALC882_FIXUP_EAPD] = { 2275 .type = HDA_FIXUP_VERBS, 2276 .v.verbs = (const struct hda_verb[]) { 2277 /* change to EAPD mode */ 2278 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2279 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 }, 2280 { } 2281 } 2282 }, 2283 [ALC883_FIXUP_EAPD] = { 2284 .type = HDA_FIXUP_VERBS, 2285 .v.verbs = (const struct hda_verb[]) { 2286 /* change to EAPD mode */ 2287 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2288 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 }, 2289 { } 2290 } 2291 }, 2292 [ALC883_FIXUP_ACER_EAPD] = { 2293 .type = HDA_FIXUP_VERBS, 2294 .v.verbs = (const struct hda_verb[]) { 2295 /* eanable EAPD on Acer laptops */ 2296 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2297 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 }, 2298 { } 2299 } 2300 }, 2301 [ALC882_FIXUP_GPIO1] = { 2302 .type = HDA_FIXUP_FUNC, 2303 .v.func = alc_fixup_gpio1, 2304 }, 2305 [ALC882_FIXUP_GPIO2] = { 2306 .type = HDA_FIXUP_FUNC, 2307 .v.func = alc_fixup_gpio2, 2308 }, 2309 [ALC882_FIXUP_GPIO3] = { 2310 .type = HDA_FIXUP_FUNC, 2311 .v.func = alc_fixup_gpio3, 2312 }, 2313 [ALC882_FIXUP_ASUS_W2JC] = { 2314 .type = HDA_FIXUP_FUNC, 2315 .v.func = alc_fixup_gpio1, 2316 .chained = true, 2317 .chain_id = ALC882_FIXUP_EAPD, 2318 }, 2319 [ALC889_FIXUP_COEF] = { 2320 .type = HDA_FIXUP_FUNC, 2321 .v.func = alc889_fixup_coef, 2322 }, 2323 [ALC882_FIXUP_ACER_ASPIRE_4930G] = { 2324 .type = HDA_FIXUP_PINS, 2325 .v.pins = (const struct hda_pintbl[]) { 2326 { 0x16, 0x99130111 }, /* CLFE speaker */ 2327 { 0x17, 0x99130112 }, /* surround speaker */ 2328 { } 2329 }, 2330 .chained = true, 2331 .chain_id = ALC882_FIXUP_GPIO1, 2332 }, 2333 [ALC882_FIXUP_ACER_ASPIRE_8930G] = { 2334 .type = HDA_FIXUP_PINS, 2335 .v.pins = (const struct hda_pintbl[]) { 2336 { 0x16, 0x99130111 }, /* CLFE speaker */ 2337 { 0x1b, 0x99130112 }, /* surround speaker */ 2338 { } 2339 }, 2340 .chained = true, 2341 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS, 2342 }, 2343 [ALC882_FIXUP_ASPIRE_8930G_VERBS] = { 2344 /* additional init verbs for Acer Aspire 8930G */ 2345 .type = HDA_FIXUP_VERBS, 2346 .v.verbs = (const struct hda_verb[]) { 2347 /* Enable all DACs */ 2348 /* DAC DISABLE/MUTE 1? */ 2349 /* setting bits 1-5 disables DAC nids 0x02-0x06 2350 * apparently. Init=0x38 */ 2351 { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 }, 2352 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 }, 2353 /* DAC DISABLE/MUTE 2? */ 2354 /* some bit here disables the other DACs. 2355 * Init=0x4900 */ 2356 { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 }, 2357 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 }, 2358 /* DMIC fix 2359 * This laptop has a stereo digital microphone. 2360 * The mics are only 1cm apart which makes the stereo 2361 * useless. However, either the mic or the ALC889 2362 * makes the signal become a difference/sum signal 2363 * instead of standard stereo, which is annoying. 2364 * So instead we flip this bit which makes the 2365 * codec replicate the sum signal to both channels, 2366 * turning it into a normal mono mic. 2367 */ 2368 /* DMIC_CONTROL? Init value = 0x0001 */ 2369 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b }, 2370 { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 }, 2371 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2372 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 }, 2373 { } 2374 }, 2375 .chained = true, 2376 .chain_id = ALC882_FIXUP_GPIO1, 2377 }, 2378 [ALC885_FIXUP_MACPRO_GPIO] = { 2379 .type = HDA_FIXUP_FUNC, 2380 .v.func = alc885_fixup_macpro_gpio, 2381 }, 2382 [ALC889_FIXUP_DAC_ROUTE] = { 2383 .type = HDA_FIXUP_FUNC, 2384 .v.func = alc889_fixup_dac_route, 2385 }, 2386 [ALC889_FIXUP_MBP_VREF] = { 2387 .type = HDA_FIXUP_FUNC, 2388 .v.func = alc889_fixup_mbp_vref, 2389 .chained = true, 2390 .chain_id = ALC882_FIXUP_GPIO1, 2391 }, 2392 [ALC889_FIXUP_IMAC91_VREF] = { 2393 .type = HDA_FIXUP_FUNC, 2394 .v.func = alc889_fixup_imac91_vref, 2395 .chained = true, 2396 .chain_id = ALC882_FIXUP_GPIO1, 2397 }, 2398 [ALC889_FIXUP_MBA11_VREF] = { 2399 .type = HDA_FIXUP_FUNC, 2400 .v.func = alc889_fixup_mba11_vref, 2401 .chained = true, 2402 .chain_id = ALC889_FIXUP_MBP_VREF, 2403 }, 2404 [ALC889_FIXUP_MBA21_VREF] = { 2405 .type = HDA_FIXUP_FUNC, 2406 .v.func = alc889_fixup_mba21_vref, 2407 .chained = true, 2408 .chain_id = ALC889_FIXUP_MBP_VREF, 2409 }, 2410 [ALC889_FIXUP_MP11_VREF] = { 2411 .type = HDA_FIXUP_FUNC, 2412 .v.func = alc889_fixup_mba11_vref, 2413 .chained = true, 2414 .chain_id = ALC885_FIXUP_MACPRO_GPIO, 2415 }, 2416 [ALC889_FIXUP_MP41_VREF] = { 2417 .type = HDA_FIXUP_FUNC, 2418 .v.func = alc889_fixup_mbp_vref, 2419 .chained = true, 2420 .chain_id = ALC885_FIXUP_MACPRO_GPIO, 2421 }, 2422 [ALC882_FIXUP_INV_DMIC] = { 2423 .type = HDA_FIXUP_FUNC, 2424 .v.func = alc_fixup_inv_dmic, 2425 }, 2426 [ALC882_FIXUP_NO_PRIMARY_HP] = { 2427 .type = HDA_FIXUP_FUNC, 2428 .v.func = alc882_fixup_no_primary_hp, 2429 }, 2430 [ALC887_FIXUP_ASUS_BASS] = { 2431 .type = HDA_FIXUP_PINS, 2432 .v.pins = (const struct hda_pintbl[]) { 2433 {0x16, 0x99130130}, /* bass speaker */ 2434 {} 2435 }, 2436 .chained = true, 2437 .chain_id = ALC887_FIXUP_BASS_CHMAP, 2438 }, 2439 [ALC887_FIXUP_BASS_CHMAP] = { 2440 .type = HDA_FIXUP_FUNC, 2441 .v.func = alc_fixup_bass_chmap, 2442 }, 2443 [ALC1220_FIXUP_GB_DUAL_CODECS] = { 2444 .type = HDA_FIXUP_FUNC, 2445 .v.func = alc1220_fixup_gb_dual_codecs, 2446 }, 2447 [ALC1220_FIXUP_GB_X570] = { 2448 .type = HDA_FIXUP_FUNC, 2449 .v.func = alc1220_fixup_gb_x570, 2450 }, 2451 [ALC1220_FIXUP_CLEVO_P950] = { 2452 .type = HDA_FIXUP_FUNC, 2453 .v.func = alc1220_fixup_clevo_p950, 2454 }, 2455 [ALC1220_FIXUP_CLEVO_PB51ED] = { 2456 .type = HDA_FIXUP_FUNC, 2457 .v.func = alc1220_fixup_clevo_pb51ed, 2458 }, 2459 [ALC1220_FIXUP_CLEVO_PB51ED_PINS] = { 2460 .type = HDA_FIXUP_PINS, 2461 .v.pins = (const struct hda_pintbl[]) { 2462 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 2463 {} 2464 }, 2465 .chained = true, 2466 .chain_id = ALC1220_FIXUP_CLEVO_PB51ED, 2467 }, 2468 [ALC887_FIXUP_ASUS_AUDIO] = { 2469 .type = HDA_FIXUP_PINS, 2470 .v.pins = (const struct hda_pintbl[]) { 2471 { 0x15, 0x02a14150 }, /* use as headset mic, without its own jack detect */ 2472 { 0x19, 0x22219420 }, 2473 {} 2474 }, 2475 }, 2476 [ALC887_FIXUP_ASUS_HMIC] = { 2477 .type = HDA_FIXUP_FUNC, 2478 .v.func = alc887_fixup_asus_jack, 2479 .chained = true, 2480 .chain_id = ALC887_FIXUP_ASUS_AUDIO, 2481 }, 2482 }; 2483 2484 static const struct snd_pci_quirk alc882_fixup_tbl[] = { 2485 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD), 2486 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD), 2487 SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD), 2488 SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD), 2489 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD), 2490 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD), 2491 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD), 2492 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G", 2493 ALC882_FIXUP_ACER_ASPIRE_4930G), 2494 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G", 2495 ALC882_FIXUP_ACER_ASPIRE_4930G), 2496 SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G", 2497 ALC882_FIXUP_ACER_ASPIRE_8930G), 2498 SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G", 2499 ALC882_FIXUP_ACER_ASPIRE_8930G), 2500 SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G", 2501 ALC882_FIXUP_ACER_ASPIRE_4930G), 2502 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210), 2503 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G", 2504 ALC882_FIXUP_ACER_ASPIRE_4930G), 2505 SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G", 2506 ALC882_FIXUP_ACER_ASPIRE_4930G), 2507 SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G", 2508 ALC882_FIXUP_ACER_ASPIRE_4930G), 2509 SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE), 2510 SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G), 2511 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736), 2512 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD), 2513 SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V), 2514 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC), 2515 SND_PCI_QUIRK(0x1043, 0x2390, "Asus D700SA", ALC887_FIXUP_ASUS_HMIC), 2516 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601), 2517 SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS), 2518 SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3), 2519 SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP), 2520 SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP), 2521 SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT), 2522 SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP), 2523 SND_PCI_QUIRK(0x104d, 0x9060, "Sony Vaio VPCL14M1R", ALC882_FIXUP_NO_PRIMARY_HP), 2524 2525 /* All Apple entries are in codec SSIDs */ 2526 SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF), 2527 SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF), 2528 SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF), 2529 SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF), 2530 SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO), 2531 SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO), 2532 SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF), 2533 SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF), 2534 SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD), 2535 SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF), 2536 SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF), 2537 SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF), 2538 SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF), 2539 SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO), 2540 SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF), 2541 SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF), 2542 SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF), 2543 SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF), 2544 SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF), 2545 SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF), 2546 SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF), 2547 SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF), 2548 2549 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD), 2550 SND_PCI_QUIRK(0x13fe, 0x1009, "Advantech MIT-W101", ALC886_FIXUP_EAPD), 2551 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE), 2552 SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS), 2553 SND_PCI_QUIRK(0x1458, 0xa0cd, "Gigabyte X570 Aorus Master", ALC1220_FIXUP_GB_X570), 2554 SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_CLEVO_P950), 2555 SND_PCI_QUIRK(0x1462, 0x11f7, "MSI-GE63", ALC1220_FIXUP_CLEVO_P950), 2556 SND_PCI_QUIRK(0x1462, 0x1228, "MSI-GP63", ALC1220_FIXUP_CLEVO_P950), 2557 SND_PCI_QUIRK(0x1462, 0x1229, "MSI-GP73", ALC1220_FIXUP_CLEVO_P950), 2558 SND_PCI_QUIRK(0x1462, 0x1275, "MSI-GL63", ALC1220_FIXUP_CLEVO_P950), 2559 SND_PCI_QUIRK(0x1462, 0x1276, "MSI-GL73", ALC1220_FIXUP_CLEVO_P950), 2560 SND_PCI_QUIRK(0x1462, 0x1293, "MSI-GP65", ALC1220_FIXUP_CLEVO_P950), 2561 SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD), 2562 SND_PCI_QUIRK(0x1462, 0xcc34, "MSI Godlike X570", ALC1220_FIXUP_GB_DUAL_CODECS), 2563 SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS), 2564 SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3), 2565 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX), 2566 SND_PCI_QUIRK(0x1558, 0x50d3, "Clevo PC50[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2567 SND_PCI_QUIRK(0x1558, 0x65d1, "Clevo PB51[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2568 SND_PCI_QUIRK(0x1558, 0x65d2, "Clevo PB51R[CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2569 SND_PCI_QUIRK(0x1558, 0x65e1, "Clevo PB51[ED][DF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2570 SND_PCI_QUIRK(0x1558, 0x65e5, "Clevo PC50D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2571 SND_PCI_QUIRK(0x1558, 0x65f1, "Clevo PC50HS", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2572 SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2573 SND_PCI_QUIRK(0x1558, 0x67e1, "Clevo PB71[DE][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2574 SND_PCI_QUIRK(0x1558, 0x67e5, "Clevo PC70D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2575 SND_PCI_QUIRK(0x1558, 0x67f1, "Clevo PC70H[PRS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2576 SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2577 SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170SM", ALC1220_FIXUP_CLEVO_PB51ED_PINS), 2578 SND_PCI_QUIRK(0x1558, 0x7715, "Clevo X170KM-G", ALC1220_FIXUP_CLEVO_PB51ED), 2579 SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950), 2580 SND_PCI_QUIRK(0x1558, 0x9506, "Clevo P955HQ", ALC1220_FIXUP_CLEVO_P950), 2581 SND_PCI_QUIRK(0x1558, 0x950a, "Clevo P955H[PR]", ALC1220_FIXUP_CLEVO_P950), 2582 SND_PCI_QUIRK(0x1558, 0x95e1, "Clevo P95xER", ALC1220_FIXUP_CLEVO_P950), 2583 SND_PCI_QUIRK(0x1558, 0x95e2, "Clevo P950ER", ALC1220_FIXUP_CLEVO_P950), 2584 SND_PCI_QUIRK(0x1558, 0x95e3, "Clevo P955[ER]T", ALC1220_FIXUP_CLEVO_P950), 2585 SND_PCI_QUIRK(0x1558, 0x95e4, "Clevo P955ER", ALC1220_FIXUP_CLEVO_P950), 2586 SND_PCI_QUIRK(0x1558, 0x95e5, "Clevo P955EE6", ALC1220_FIXUP_CLEVO_P950), 2587 SND_PCI_QUIRK(0x1558, 0x95e6, "Clevo P950R[CDF]", ALC1220_FIXUP_CLEVO_P950), 2588 SND_PCI_QUIRK(0x1558, 0x96e1, "Clevo P960[ER][CDFN]-K", ALC1220_FIXUP_CLEVO_P950), 2589 SND_PCI_QUIRK(0x1558, 0x97e1, "Clevo P970[ER][CDFN]", ALC1220_FIXUP_CLEVO_P950), 2590 SND_PCI_QUIRK(0x1558, 0x97e2, "Clevo P970RC-M", ALC1220_FIXUP_CLEVO_P950), 2591 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD), 2592 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD), 2593 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530), 2594 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF), 2595 {} 2596 }; 2597 2598 static const struct hda_model_fixup alc882_fixup_models[] = { 2599 {.id = ALC882_FIXUP_ABIT_AW9D_MAX, .name = "abit-aw9d"}, 2600 {.id = ALC882_FIXUP_LENOVO_Y530, .name = "lenovo-y530"}, 2601 {.id = ALC882_FIXUP_ACER_ASPIRE_7736, .name = "acer-aspire-7736"}, 2602 {.id = ALC882_FIXUP_ASUS_W90V, .name = "asus-w90v"}, 2603 {.id = ALC889_FIXUP_CD, .name = "cd"}, 2604 {.id = ALC889_FIXUP_FRONT_HP_NO_PRESENCE, .name = "no-front-hp"}, 2605 {.id = ALC889_FIXUP_VAIO_TT, .name = "vaio-tt"}, 2606 {.id = ALC888_FIXUP_EEE1601, .name = "eee1601"}, 2607 {.id = ALC882_FIXUP_EAPD, .name = "alc882-eapd"}, 2608 {.id = ALC883_FIXUP_EAPD, .name = "alc883-eapd"}, 2609 {.id = ALC882_FIXUP_GPIO1, .name = "gpio1"}, 2610 {.id = ALC882_FIXUP_GPIO2, .name = "gpio2"}, 2611 {.id = ALC882_FIXUP_GPIO3, .name = "gpio3"}, 2612 {.id = ALC889_FIXUP_COEF, .name = "alc889-coef"}, 2613 {.id = ALC882_FIXUP_ASUS_W2JC, .name = "asus-w2jc"}, 2614 {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"}, 2615 {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"}, 2616 {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"}, 2617 {.id = ALC885_FIXUP_MACPRO_GPIO, .name = "macpro-gpio"}, 2618 {.id = ALC889_FIXUP_DAC_ROUTE, .name = "dac-route"}, 2619 {.id = ALC889_FIXUP_MBP_VREF, .name = "mbp-vref"}, 2620 {.id = ALC889_FIXUP_IMAC91_VREF, .name = "imac91-vref"}, 2621 {.id = ALC889_FIXUP_MBA11_VREF, .name = "mba11-vref"}, 2622 {.id = ALC889_FIXUP_MBA21_VREF, .name = "mba21-vref"}, 2623 {.id = ALC889_FIXUP_MP11_VREF, .name = "mp11-vref"}, 2624 {.id = ALC889_FIXUP_MP41_VREF, .name = "mp41-vref"}, 2625 {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"}, 2626 {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"}, 2627 {.id = ALC887_FIXUP_ASUS_BASS, .name = "asus-bass"}, 2628 {.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"}, 2629 {.id = ALC1220_FIXUP_CLEVO_P950, .name = "clevo-p950"}, 2630 {} 2631 }; 2632 2633 static const struct snd_hda_pin_quirk alc882_pin_fixup_tbl[] = { 2634 SND_HDA_PIN_QUIRK(0x10ec1220, 0x1043, "ASUS", ALC1220_FIXUP_CLEVO_P950, 2635 {0x14, 0x01014010}, 2636 {0x15, 0x01011012}, 2637 {0x16, 0x01016011}, 2638 {0x18, 0x01a19040}, 2639 {0x19, 0x02a19050}, 2640 {0x1a, 0x0181304f}, 2641 {0x1b, 0x0221401f}, 2642 {0x1e, 0x01456130}), 2643 SND_HDA_PIN_QUIRK(0x10ec1220, 0x1462, "MS-7C35", ALC1220_FIXUP_CLEVO_P950, 2644 {0x14, 0x01015010}, 2645 {0x15, 0x01011012}, 2646 {0x16, 0x01011011}, 2647 {0x18, 0x01a11040}, 2648 {0x19, 0x02a19050}, 2649 {0x1a, 0x0181104f}, 2650 {0x1b, 0x0221401f}, 2651 {0x1e, 0x01451130}), 2652 {} 2653 }; 2654 2655 /* 2656 * BIOS auto configuration 2657 */ 2658 /* almost identical with ALC880 parser... */ 2659 static int alc882_parse_auto_config(struct hda_codec *codec) 2660 { 2661 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 }; 2662 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 2663 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids); 2664 } 2665 2666 /* 2667 */ 2668 static int patch_alc882(struct hda_codec *codec) 2669 { 2670 struct alc_spec *spec; 2671 int err; 2672 2673 err = alc_alloc_spec(codec, 0x0b); 2674 if (err < 0) 2675 return err; 2676 2677 spec = codec->spec; 2678 2679 switch (codec->core.vendor_id) { 2680 case 0x10ec0882: 2681 case 0x10ec0885: 2682 case 0x10ec0900: 2683 case 0x10ec0b00: 2684 case 0x10ec1220: 2685 break; 2686 default: 2687 /* ALC883 and variants */ 2688 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 2689 break; 2690 } 2691 2692 alc_pre_init(codec); 2693 2694 snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl, 2695 alc882_fixups); 2696 snd_hda_pick_pin_fixup(codec, alc882_pin_fixup_tbl, alc882_fixups, true); 2697 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 2698 2699 alc_auto_parse_customize_define(codec); 2700 2701 if (has_cdefine_beep(codec)) 2702 spec->gen.beep_nid = 0x01; 2703 2704 /* automatic parse from the BIOS config */ 2705 err = alc882_parse_auto_config(codec); 2706 if (err < 0) 2707 goto error; 2708 2709 if (!spec->gen.no_analog && spec->gen.beep_nid) { 2710 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 2711 if (err < 0) 2712 goto error; 2713 } 2714 2715 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 2716 2717 return 0; 2718 2719 error: 2720 alc_free(codec); 2721 return err; 2722 } 2723 2724 2725 /* 2726 * ALC262 support 2727 */ 2728 static int alc262_parse_auto_config(struct hda_codec *codec) 2729 { 2730 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 }; 2731 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 2732 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids); 2733 } 2734 2735 /* 2736 * Pin config fixes 2737 */ 2738 enum { 2739 ALC262_FIXUP_FSC_H270, 2740 ALC262_FIXUP_FSC_S7110, 2741 ALC262_FIXUP_HP_Z200, 2742 ALC262_FIXUP_TYAN, 2743 ALC262_FIXUP_LENOVO_3000, 2744 ALC262_FIXUP_BENQ, 2745 ALC262_FIXUP_BENQ_T31, 2746 ALC262_FIXUP_INV_DMIC, 2747 ALC262_FIXUP_INTEL_BAYLEYBAY, 2748 }; 2749 2750 static const struct hda_fixup alc262_fixups[] = { 2751 [ALC262_FIXUP_FSC_H270] = { 2752 .type = HDA_FIXUP_PINS, 2753 .v.pins = (const struct hda_pintbl[]) { 2754 { 0x14, 0x99130110 }, /* speaker */ 2755 { 0x15, 0x0221142f }, /* front HP */ 2756 { 0x1b, 0x0121141f }, /* rear HP */ 2757 { } 2758 } 2759 }, 2760 [ALC262_FIXUP_FSC_S7110] = { 2761 .type = HDA_FIXUP_PINS, 2762 .v.pins = (const struct hda_pintbl[]) { 2763 { 0x15, 0x90170110 }, /* speaker */ 2764 { } 2765 }, 2766 .chained = true, 2767 .chain_id = ALC262_FIXUP_BENQ, 2768 }, 2769 [ALC262_FIXUP_HP_Z200] = { 2770 .type = HDA_FIXUP_PINS, 2771 .v.pins = (const struct hda_pintbl[]) { 2772 { 0x16, 0x99130120 }, /* internal speaker */ 2773 { } 2774 } 2775 }, 2776 [ALC262_FIXUP_TYAN] = { 2777 .type = HDA_FIXUP_PINS, 2778 .v.pins = (const struct hda_pintbl[]) { 2779 { 0x14, 0x1993e1f0 }, /* int AUX */ 2780 { } 2781 } 2782 }, 2783 [ALC262_FIXUP_LENOVO_3000] = { 2784 .type = HDA_FIXUP_PINCTLS, 2785 .v.pins = (const struct hda_pintbl[]) { 2786 { 0x19, PIN_VREF50 }, 2787 {} 2788 }, 2789 .chained = true, 2790 .chain_id = ALC262_FIXUP_BENQ, 2791 }, 2792 [ALC262_FIXUP_BENQ] = { 2793 .type = HDA_FIXUP_VERBS, 2794 .v.verbs = (const struct hda_verb[]) { 2795 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2796 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 }, 2797 {} 2798 } 2799 }, 2800 [ALC262_FIXUP_BENQ_T31] = { 2801 .type = HDA_FIXUP_VERBS, 2802 .v.verbs = (const struct hda_verb[]) { 2803 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2804 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 }, 2805 {} 2806 } 2807 }, 2808 [ALC262_FIXUP_INV_DMIC] = { 2809 .type = HDA_FIXUP_FUNC, 2810 .v.func = alc_fixup_inv_dmic, 2811 }, 2812 [ALC262_FIXUP_INTEL_BAYLEYBAY] = { 2813 .type = HDA_FIXUP_FUNC, 2814 .v.func = alc_fixup_no_depop_delay, 2815 }, 2816 }; 2817 2818 static const struct snd_pci_quirk alc262_fixup_tbl[] = { 2819 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200), 2820 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110), 2821 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ), 2822 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN), 2823 SND_PCI_QUIRK(0x1734, 0x1141, "FSC ESPRIMO U9210", ALC262_FIXUP_FSC_H270), 2824 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270), 2825 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000), 2826 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ), 2827 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31), 2828 SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY), 2829 {} 2830 }; 2831 2832 static const struct hda_model_fixup alc262_fixup_models[] = { 2833 {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"}, 2834 {.id = ALC262_FIXUP_FSC_H270, .name = "fsc-h270"}, 2835 {.id = ALC262_FIXUP_FSC_S7110, .name = "fsc-s7110"}, 2836 {.id = ALC262_FIXUP_HP_Z200, .name = "hp-z200"}, 2837 {.id = ALC262_FIXUP_TYAN, .name = "tyan"}, 2838 {.id = ALC262_FIXUP_LENOVO_3000, .name = "lenovo-3000"}, 2839 {.id = ALC262_FIXUP_BENQ, .name = "benq"}, 2840 {.id = ALC262_FIXUP_BENQ_T31, .name = "benq-t31"}, 2841 {.id = ALC262_FIXUP_INTEL_BAYLEYBAY, .name = "bayleybay"}, 2842 {} 2843 }; 2844 2845 /* 2846 */ 2847 static int patch_alc262(struct hda_codec *codec) 2848 { 2849 struct alc_spec *spec; 2850 int err; 2851 2852 err = alc_alloc_spec(codec, 0x0b); 2853 if (err < 0) 2854 return err; 2855 2856 spec = codec->spec; 2857 spec->gen.shared_mic_vref_pin = 0x18; 2858 2859 spec->shutup = alc_eapd_shutup; 2860 2861 #if 0 2862 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is 2863 * under-run 2864 */ 2865 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80); 2866 #endif 2867 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 2868 2869 alc_pre_init(codec); 2870 2871 snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl, 2872 alc262_fixups); 2873 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 2874 2875 alc_auto_parse_customize_define(codec); 2876 2877 if (has_cdefine_beep(codec)) 2878 spec->gen.beep_nid = 0x01; 2879 2880 /* automatic parse from the BIOS config */ 2881 err = alc262_parse_auto_config(codec); 2882 if (err < 0) 2883 goto error; 2884 2885 if (!spec->gen.no_analog && spec->gen.beep_nid) { 2886 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 2887 if (err < 0) 2888 goto error; 2889 } 2890 2891 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 2892 2893 return 0; 2894 2895 error: 2896 alc_free(codec); 2897 return err; 2898 } 2899 2900 /* 2901 * ALC268 2902 */ 2903 /* bind Beep switches of both NID 0x0f and 0x10 */ 2904 static int alc268_beep_switch_put(struct snd_kcontrol *kcontrol, 2905 struct snd_ctl_elem_value *ucontrol) 2906 { 2907 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2908 unsigned long pval; 2909 int err; 2910 2911 mutex_lock(&codec->control_mutex); 2912 pval = kcontrol->private_value; 2913 kcontrol->private_value = (pval & ~0xff) | 0x0f; 2914 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); 2915 if (err >= 0) { 2916 kcontrol->private_value = (pval & ~0xff) | 0x10; 2917 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); 2918 } 2919 kcontrol->private_value = pval; 2920 mutex_unlock(&codec->control_mutex); 2921 return err; 2922 } 2923 2924 static const struct snd_kcontrol_new alc268_beep_mixer[] = { 2925 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT), 2926 { 2927 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2928 .name = "Beep Playback Switch", 2929 .subdevice = HDA_SUBDEV_AMP_FLAG, 2930 .info = snd_hda_mixer_amp_switch_info, 2931 .get = snd_hda_mixer_amp_switch_get, 2932 .put = alc268_beep_switch_put, 2933 .private_value = HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT) 2934 }, 2935 }; 2936 2937 /* set PCBEEP vol = 0, mute connections */ 2938 static const struct hda_verb alc268_beep_init_verbs[] = { 2939 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2940 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2941 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2942 { } 2943 }; 2944 2945 enum { 2946 ALC268_FIXUP_INV_DMIC, 2947 ALC268_FIXUP_HP_EAPD, 2948 ALC268_FIXUP_SPDIF, 2949 }; 2950 2951 static const struct hda_fixup alc268_fixups[] = { 2952 [ALC268_FIXUP_INV_DMIC] = { 2953 .type = HDA_FIXUP_FUNC, 2954 .v.func = alc_fixup_inv_dmic, 2955 }, 2956 [ALC268_FIXUP_HP_EAPD] = { 2957 .type = HDA_FIXUP_VERBS, 2958 .v.verbs = (const struct hda_verb[]) { 2959 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0}, 2960 {} 2961 } 2962 }, 2963 [ALC268_FIXUP_SPDIF] = { 2964 .type = HDA_FIXUP_PINS, 2965 .v.pins = (const struct hda_pintbl[]) { 2966 { 0x1e, 0x014b1180 }, /* enable SPDIF out */ 2967 {} 2968 } 2969 }, 2970 }; 2971 2972 static const struct hda_model_fixup alc268_fixup_models[] = { 2973 {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"}, 2974 {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"}, 2975 {.id = ALC268_FIXUP_SPDIF, .name = "spdif"}, 2976 {} 2977 }; 2978 2979 static const struct snd_pci_quirk alc268_fixup_tbl[] = { 2980 SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF), 2981 SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC), 2982 /* below is codec SSID since multiple Toshiba laptops have the 2983 * same PCI SSID 1179:ff00 2984 */ 2985 SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD), 2986 {} 2987 }; 2988 2989 /* 2990 * BIOS auto configuration 2991 */ 2992 static int alc268_parse_auto_config(struct hda_codec *codec) 2993 { 2994 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 2995 return alc_parse_auto_config(codec, NULL, alc268_ssids); 2996 } 2997 2998 /* 2999 */ 3000 static int patch_alc268(struct hda_codec *codec) 3001 { 3002 struct alc_spec *spec; 3003 int i, err; 3004 3005 /* ALC268 has no aa-loopback mixer */ 3006 err = alc_alloc_spec(codec, 0); 3007 if (err < 0) 3008 return err; 3009 3010 spec = codec->spec; 3011 if (has_cdefine_beep(codec)) 3012 spec->gen.beep_nid = 0x01; 3013 3014 spec->shutup = alc_eapd_shutup; 3015 3016 alc_pre_init(codec); 3017 3018 snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups); 3019 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 3020 3021 /* automatic parse from the BIOS config */ 3022 err = alc268_parse_auto_config(codec); 3023 if (err < 0) 3024 goto error; 3025 3026 if (err > 0 && !spec->gen.no_analog && 3027 spec->gen.autocfg.speaker_pins[0] != 0x1d) { 3028 for (i = 0; i < ARRAY_SIZE(alc268_beep_mixer); i++) { 3029 if (!snd_hda_gen_add_kctl(&spec->gen, NULL, 3030 &alc268_beep_mixer[i])) { 3031 err = -ENOMEM; 3032 goto error; 3033 } 3034 } 3035 snd_hda_add_verbs(codec, alc268_beep_init_verbs); 3036 if (!query_amp_caps(codec, 0x1d, HDA_INPUT)) 3037 /* override the amp caps for beep generator */ 3038 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT, 3039 (0x0c << AC_AMPCAP_OFFSET_SHIFT) | 3040 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) | 3041 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) | 3042 (0 << AC_AMPCAP_MUTE_SHIFT)); 3043 } 3044 3045 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 3046 3047 return 0; 3048 3049 error: 3050 alc_free(codec); 3051 return err; 3052 } 3053 3054 /* 3055 * ALC269 3056 */ 3057 3058 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = { 3059 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */ 3060 }; 3061 3062 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = { 3063 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */ 3064 }; 3065 3066 /* different alc269-variants */ 3067 enum { 3068 ALC269_TYPE_ALC269VA, 3069 ALC269_TYPE_ALC269VB, 3070 ALC269_TYPE_ALC269VC, 3071 ALC269_TYPE_ALC269VD, 3072 ALC269_TYPE_ALC280, 3073 ALC269_TYPE_ALC282, 3074 ALC269_TYPE_ALC283, 3075 ALC269_TYPE_ALC284, 3076 ALC269_TYPE_ALC293, 3077 ALC269_TYPE_ALC286, 3078 ALC269_TYPE_ALC298, 3079 ALC269_TYPE_ALC255, 3080 ALC269_TYPE_ALC256, 3081 ALC269_TYPE_ALC257, 3082 ALC269_TYPE_ALC215, 3083 ALC269_TYPE_ALC225, 3084 ALC269_TYPE_ALC287, 3085 ALC269_TYPE_ALC294, 3086 ALC269_TYPE_ALC300, 3087 ALC269_TYPE_ALC623, 3088 ALC269_TYPE_ALC700, 3089 }; 3090 3091 /* 3092 * BIOS auto configuration 3093 */ 3094 static int alc269_parse_auto_config(struct hda_codec *codec) 3095 { 3096 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 }; 3097 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 }; 3098 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 3099 struct alc_spec *spec = codec->spec; 3100 const hda_nid_t *ssids; 3101 3102 switch (spec->codec_variant) { 3103 case ALC269_TYPE_ALC269VA: 3104 case ALC269_TYPE_ALC269VC: 3105 case ALC269_TYPE_ALC280: 3106 case ALC269_TYPE_ALC284: 3107 case ALC269_TYPE_ALC293: 3108 ssids = alc269va_ssids; 3109 break; 3110 case ALC269_TYPE_ALC269VB: 3111 case ALC269_TYPE_ALC269VD: 3112 case ALC269_TYPE_ALC282: 3113 case ALC269_TYPE_ALC283: 3114 case ALC269_TYPE_ALC286: 3115 case ALC269_TYPE_ALC298: 3116 case ALC269_TYPE_ALC255: 3117 case ALC269_TYPE_ALC256: 3118 case ALC269_TYPE_ALC257: 3119 case ALC269_TYPE_ALC215: 3120 case ALC269_TYPE_ALC225: 3121 case ALC269_TYPE_ALC287: 3122 case ALC269_TYPE_ALC294: 3123 case ALC269_TYPE_ALC300: 3124 case ALC269_TYPE_ALC623: 3125 case ALC269_TYPE_ALC700: 3126 ssids = alc269_ssids; 3127 break; 3128 default: 3129 ssids = alc269_ssids; 3130 break; 3131 } 3132 3133 return alc_parse_auto_config(codec, alc269_ignore, ssids); 3134 } 3135 3136 static const struct hda_jack_keymap alc_headset_btn_keymap[] = { 3137 { SND_JACK_BTN_0, KEY_PLAYPAUSE }, 3138 { SND_JACK_BTN_1, KEY_VOICECOMMAND }, 3139 { SND_JACK_BTN_2, KEY_VOLUMEUP }, 3140 { SND_JACK_BTN_3, KEY_VOLUMEDOWN }, 3141 {} 3142 }; 3143 3144 static void alc_headset_btn_callback(struct hda_codec *codec, 3145 struct hda_jack_callback *jack) 3146 { 3147 int report = 0; 3148 3149 if (jack->unsol_res & (7 << 13)) 3150 report |= SND_JACK_BTN_0; 3151 3152 if (jack->unsol_res & (1 << 16 | 3 << 8)) 3153 report |= SND_JACK_BTN_1; 3154 3155 /* Volume up key */ 3156 if (jack->unsol_res & (7 << 23)) 3157 report |= SND_JACK_BTN_2; 3158 3159 /* Volume down key */ 3160 if (jack->unsol_res & (7 << 10)) 3161 report |= SND_JACK_BTN_3; 3162 3163 snd_hda_jack_set_button_state(codec, jack->nid, report); 3164 } 3165 3166 static void alc_disable_headset_jack_key(struct hda_codec *codec) 3167 { 3168 struct alc_spec *spec = codec->spec; 3169 3170 if (!spec->has_hs_key) 3171 return; 3172 3173 switch (codec->core.vendor_id) { 3174 case 0x10ec0215: 3175 case 0x10ec0225: 3176 case 0x10ec0285: 3177 case 0x10ec0287: 3178 case 0x10ec0295: 3179 case 0x10ec0289: 3180 case 0x10ec0299: 3181 alc_write_coef_idx(codec, 0x48, 0x0); 3182 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0); 3183 alc_update_coef_idx(codec, 0x44, 0x0045 << 8, 0x0); 3184 break; 3185 case 0x10ec0230: 3186 case 0x10ec0236: 3187 case 0x10ec0256: 3188 alc_write_coef_idx(codec, 0x48, 0x0); 3189 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0); 3190 break; 3191 } 3192 } 3193 3194 static void alc_enable_headset_jack_key(struct hda_codec *codec) 3195 { 3196 struct alc_spec *spec = codec->spec; 3197 3198 if (!spec->has_hs_key) 3199 return; 3200 3201 switch (codec->core.vendor_id) { 3202 case 0x10ec0215: 3203 case 0x10ec0225: 3204 case 0x10ec0285: 3205 case 0x10ec0287: 3206 case 0x10ec0295: 3207 case 0x10ec0289: 3208 case 0x10ec0299: 3209 alc_write_coef_idx(codec, 0x48, 0xd011); 3210 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045); 3211 alc_update_coef_idx(codec, 0x44, 0x007f << 8, 0x0045 << 8); 3212 break; 3213 case 0x10ec0230: 3214 case 0x10ec0236: 3215 case 0x10ec0256: 3216 alc_write_coef_idx(codec, 0x48, 0xd011); 3217 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045); 3218 break; 3219 } 3220 } 3221 3222 static void alc_fixup_headset_jack(struct hda_codec *codec, 3223 const struct hda_fixup *fix, int action) 3224 { 3225 struct alc_spec *spec = codec->spec; 3226 hda_nid_t hp_pin; 3227 3228 switch (action) { 3229 case HDA_FIXUP_ACT_PRE_PROBE: 3230 spec->has_hs_key = 1; 3231 snd_hda_jack_detect_enable_callback(codec, 0x55, 3232 alc_headset_btn_callback); 3233 break; 3234 case HDA_FIXUP_ACT_BUILD: 3235 hp_pin = alc_get_hp_pin(spec); 3236 if (!hp_pin || snd_hda_jack_bind_keymap(codec, 0x55, 3237 alc_headset_btn_keymap, 3238 hp_pin)) 3239 snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack", 3240 false, SND_JACK_HEADSET, 3241 alc_headset_btn_keymap); 3242 3243 alc_enable_headset_jack_key(codec); 3244 break; 3245 } 3246 } 3247 3248 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up) 3249 { 3250 alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0); 3251 } 3252 3253 static void alc269_shutup(struct hda_codec *codec) 3254 { 3255 struct alc_spec *spec = codec->spec; 3256 3257 if (spec->codec_variant == ALC269_TYPE_ALC269VB) 3258 alc269vb_toggle_power_output(codec, 0); 3259 if (spec->codec_variant == ALC269_TYPE_ALC269VB && 3260 (alc_get_coef0(codec) & 0x00ff) == 0x018) { 3261 msleep(150); 3262 } 3263 alc_shutup_pins(codec); 3264 } 3265 3266 static const struct coef_fw alc282_coefs[] = { 3267 WRITE_COEF(0x03, 0x0002), /* Power Down Control */ 3268 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */ 3269 WRITE_COEF(0x07, 0x0200), /* DMIC control */ 3270 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */ 3271 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */ 3272 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */ 3273 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */ 3274 WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */ 3275 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */ 3276 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */ 3277 WRITE_COEF(0x6f, 0x0), /* Class D test 4 */ 3278 UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */ 3279 WRITE_COEF(0x34, 0xa0c0), /* ANC */ 3280 UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */ 3281 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */ 3282 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */ 3283 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */ 3284 WRITE_COEF(0x63, 0x2902), /* PLL */ 3285 WRITE_COEF(0x68, 0xa080), /* capless control 2 */ 3286 WRITE_COEF(0x69, 0x3400), /* capless control 3 */ 3287 WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */ 3288 WRITE_COEF(0x6b, 0x0), /* capless control 5 */ 3289 UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */ 3290 WRITE_COEF(0x6e, 0x110a), /* class D test 3 */ 3291 UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */ 3292 WRITE_COEF(0x71, 0x0014), /* class D test 6 */ 3293 WRITE_COEF(0x72, 0xc2ba), /* classD OCP */ 3294 UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */ 3295 WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */ 3296 {} 3297 }; 3298 3299 static void alc282_restore_default_value(struct hda_codec *codec) 3300 { 3301 alc_process_coef_fw(codec, alc282_coefs); 3302 } 3303 3304 static void alc282_init(struct hda_codec *codec) 3305 { 3306 struct alc_spec *spec = codec->spec; 3307 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3308 bool hp_pin_sense; 3309 int coef78; 3310 3311 alc282_restore_default_value(codec); 3312 3313 if (!hp_pin) 3314 return; 3315 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3316 coef78 = alc_read_coef_idx(codec, 0x78); 3317 3318 /* Index 0x78 Direct Drive HP AMP LPM Control 1 */ 3319 /* Headphone capless set to high power mode */ 3320 alc_write_coef_idx(codec, 0x78, 0x9004); 3321 3322 if (hp_pin_sense) 3323 msleep(2); 3324 3325 snd_hda_codec_write(codec, hp_pin, 0, 3326 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3327 3328 if (hp_pin_sense) 3329 msleep(85); 3330 3331 snd_hda_codec_write(codec, hp_pin, 0, 3332 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3333 3334 if (hp_pin_sense) 3335 msleep(100); 3336 3337 /* Headphone capless set to normal mode */ 3338 alc_write_coef_idx(codec, 0x78, coef78); 3339 } 3340 3341 static void alc282_shutup(struct hda_codec *codec) 3342 { 3343 struct alc_spec *spec = codec->spec; 3344 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3345 bool hp_pin_sense; 3346 int coef78; 3347 3348 if (!hp_pin) { 3349 alc269_shutup(codec); 3350 return; 3351 } 3352 3353 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3354 coef78 = alc_read_coef_idx(codec, 0x78); 3355 alc_write_coef_idx(codec, 0x78, 0x9004); 3356 3357 if (hp_pin_sense) 3358 msleep(2); 3359 3360 snd_hda_codec_write(codec, hp_pin, 0, 3361 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3362 3363 if (hp_pin_sense) 3364 msleep(85); 3365 3366 if (!spec->no_shutup_pins) 3367 snd_hda_codec_write(codec, hp_pin, 0, 3368 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3369 3370 if (hp_pin_sense) 3371 msleep(100); 3372 3373 alc_auto_setup_eapd(codec, false); 3374 alc_shutup_pins(codec); 3375 alc_write_coef_idx(codec, 0x78, coef78); 3376 } 3377 3378 static const struct coef_fw alc283_coefs[] = { 3379 WRITE_COEF(0x03, 0x0002), /* Power Down Control */ 3380 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */ 3381 WRITE_COEF(0x07, 0x0200), /* DMIC control */ 3382 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */ 3383 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */ 3384 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */ 3385 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */ 3386 WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */ 3387 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */ 3388 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */ 3389 WRITE_COEF(0x3a, 0x0), /* Class D test 4 */ 3390 UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */ 3391 WRITE_COEF(0x22, 0xa0c0), /* ANC */ 3392 UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */ 3393 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */ 3394 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */ 3395 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */ 3396 WRITE_COEF(0x2e, 0x2902), /* PLL */ 3397 WRITE_COEF(0x33, 0xa080), /* capless control 2 */ 3398 WRITE_COEF(0x34, 0x3400), /* capless control 3 */ 3399 WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */ 3400 WRITE_COEF(0x36, 0x0), /* capless control 5 */ 3401 UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */ 3402 WRITE_COEF(0x39, 0x110a), /* class D test 3 */ 3403 UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */ 3404 WRITE_COEF(0x3c, 0x0014), /* class D test 6 */ 3405 WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */ 3406 UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */ 3407 WRITE_COEF(0x49, 0x0), /* test mode */ 3408 UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */ 3409 UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */ 3410 WRITE_COEF(0x37, 0xfc06), /* Class D amp control */ 3411 UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */ 3412 {} 3413 }; 3414 3415 static void alc283_restore_default_value(struct hda_codec *codec) 3416 { 3417 alc_process_coef_fw(codec, alc283_coefs); 3418 } 3419 3420 static void alc283_init(struct hda_codec *codec) 3421 { 3422 struct alc_spec *spec = codec->spec; 3423 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3424 bool hp_pin_sense; 3425 3426 alc283_restore_default_value(codec); 3427 3428 if (!hp_pin) 3429 return; 3430 3431 msleep(30); 3432 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3433 3434 /* Index 0x43 Direct Drive HP AMP LPM Control 1 */ 3435 /* Headphone capless set to high power mode */ 3436 alc_write_coef_idx(codec, 0x43, 0x9004); 3437 3438 snd_hda_codec_write(codec, hp_pin, 0, 3439 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3440 3441 if (hp_pin_sense) 3442 msleep(85); 3443 3444 snd_hda_codec_write(codec, hp_pin, 0, 3445 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3446 3447 if (hp_pin_sense) 3448 msleep(85); 3449 /* Index 0x46 Combo jack auto switch control 2 */ 3450 /* 3k pull low control for Headset jack. */ 3451 alc_update_coef_idx(codec, 0x46, 3 << 12, 0); 3452 /* Headphone capless set to normal mode */ 3453 alc_write_coef_idx(codec, 0x43, 0x9614); 3454 } 3455 3456 static void alc283_shutup(struct hda_codec *codec) 3457 { 3458 struct alc_spec *spec = codec->spec; 3459 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3460 bool hp_pin_sense; 3461 3462 if (!hp_pin) { 3463 alc269_shutup(codec); 3464 return; 3465 } 3466 3467 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3468 3469 alc_write_coef_idx(codec, 0x43, 0x9004); 3470 3471 /*depop hp during suspend*/ 3472 alc_write_coef_idx(codec, 0x06, 0x2100); 3473 3474 snd_hda_codec_write(codec, hp_pin, 0, 3475 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3476 3477 if (hp_pin_sense) 3478 msleep(100); 3479 3480 if (!spec->no_shutup_pins) 3481 snd_hda_codec_write(codec, hp_pin, 0, 3482 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3483 3484 alc_update_coef_idx(codec, 0x46, 0, 3 << 12); 3485 3486 if (hp_pin_sense) 3487 msleep(100); 3488 alc_auto_setup_eapd(codec, false); 3489 alc_shutup_pins(codec); 3490 alc_write_coef_idx(codec, 0x43, 0x9614); 3491 } 3492 3493 static void alc256_init(struct hda_codec *codec) 3494 { 3495 struct alc_spec *spec = codec->spec; 3496 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3497 bool hp_pin_sense; 3498 3499 if (!hp_pin) 3500 hp_pin = 0x21; 3501 3502 msleep(30); 3503 3504 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3505 3506 if (hp_pin_sense) 3507 msleep(2); 3508 3509 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */ 3510 if (spec->ultra_low_power) { 3511 alc_update_coef_idx(codec, 0x03, 1<<1, 1<<1); 3512 alc_update_coef_idx(codec, 0x08, 3<<2, 3<<2); 3513 alc_update_coef_idx(codec, 0x08, 7<<4, 0); 3514 alc_update_coef_idx(codec, 0x3b, 1<<15, 0); 3515 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6); 3516 msleep(30); 3517 } 3518 3519 snd_hda_codec_write(codec, hp_pin, 0, 3520 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3521 3522 if (hp_pin_sense || spec->ultra_low_power) 3523 msleep(85); 3524 3525 snd_hda_codec_write(codec, hp_pin, 0, 3526 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3527 3528 if (hp_pin_sense || spec->ultra_low_power) 3529 msleep(100); 3530 3531 alc_update_coef_idx(codec, 0x46, 3 << 12, 0); 3532 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */ 3533 alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15); /* Clear bit */ 3534 alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15); 3535 /* 3536 * Expose headphone mic (or possibly Line In on some machines) instead 3537 * of PC Beep on 1Ah, and disable 1Ah loopback for all outputs. See 3538 * Documentation/sound/hd-audio/realtek-pc-beep.rst for details of 3539 * this register. 3540 */ 3541 alc_write_coef_idx(codec, 0x36, 0x5757); 3542 } 3543 3544 static void alc256_shutup(struct hda_codec *codec) 3545 { 3546 struct alc_spec *spec = codec->spec; 3547 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3548 bool hp_pin_sense; 3549 3550 if (!hp_pin) 3551 hp_pin = 0x21; 3552 3553 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3554 3555 if (hp_pin_sense) 3556 msleep(2); 3557 3558 snd_hda_codec_write(codec, hp_pin, 0, 3559 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3560 3561 if (hp_pin_sense || spec->ultra_low_power) 3562 msleep(85); 3563 3564 /* 3k pull low control for Headset jack. */ 3565 /* NOTE: call this before clearing the pin, otherwise codec stalls */ 3566 /* If disable 3k pulldown control for alc257, the Mic detection will not work correctly 3567 * when booting with headset plugged. So skip setting it for the codec alc257 3568 */ 3569 if (spec->codec_variant != ALC269_TYPE_ALC257 && 3570 spec->codec_variant != ALC269_TYPE_ALC256) 3571 alc_update_coef_idx(codec, 0x46, 0, 3 << 12); 3572 3573 if (!spec->no_shutup_pins) 3574 snd_hda_codec_write(codec, hp_pin, 0, 3575 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3576 3577 if (hp_pin_sense || spec->ultra_low_power) 3578 msleep(100); 3579 3580 alc_auto_setup_eapd(codec, false); 3581 alc_shutup_pins(codec); 3582 if (spec->ultra_low_power) { 3583 msleep(50); 3584 alc_update_coef_idx(codec, 0x03, 1<<1, 0); 3585 alc_update_coef_idx(codec, 0x08, 7<<4, 7<<4); 3586 alc_update_coef_idx(codec, 0x08, 3<<2, 0); 3587 alc_update_coef_idx(codec, 0x3b, 1<<15, 1<<15); 3588 alc_update_coef_idx(codec, 0x0e, 7<<6, 0); 3589 msleep(30); 3590 } 3591 } 3592 3593 static void alc285_hp_init(struct hda_codec *codec) 3594 { 3595 struct alc_spec *spec = codec->spec; 3596 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3597 int i, val; 3598 int coef38, coef0d, coef36; 3599 3600 alc_update_coef_idx(codec, 0x4a, 1<<15, 1<<15); /* Reset HP JD */ 3601 coef38 = alc_read_coef_idx(codec, 0x38); /* Amp control */ 3602 coef0d = alc_read_coef_idx(codec, 0x0d); /* Digital Misc control */ 3603 coef36 = alc_read_coef_idx(codec, 0x36); /* Passthrough Control */ 3604 alc_update_coef_idx(codec, 0x38, 1<<4, 0x0); 3605 alc_update_coef_idx(codec, 0x0d, 0x110, 0x0); 3606 3607 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000); 3608 3609 if (hp_pin) 3610 snd_hda_codec_write(codec, hp_pin, 0, 3611 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3612 3613 msleep(130); 3614 alc_update_coef_idx(codec, 0x36, 1<<14, 1<<14); 3615 alc_update_coef_idx(codec, 0x36, 1<<13, 0x0); 3616 3617 if (hp_pin) 3618 snd_hda_codec_write(codec, hp_pin, 0, 3619 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3620 msleep(10); 3621 alc_write_coef_idx(codec, 0x67, 0x0); /* Set HP depop to manual mode */ 3622 alc_write_coefex_idx(codec, 0x58, 0x00, 0x7880); 3623 alc_write_coefex_idx(codec, 0x58, 0x0f, 0xf049); 3624 alc_update_coefex_idx(codec, 0x58, 0x03, 0x00f0, 0x00c0); 3625 3626 alc_write_coefex_idx(codec, 0x58, 0x00, 0xf888); /* HP depop procedure start */ 3627 val = alc_read_coefex_idx(codec, 0x58, 0x00); 3628 for (i = 0; i < 20 && val & 0x8000; i++) { 3629 msleep(50); 3630 val = alc_read_coefex_idx(codec, 0x58, 0x00); 3631 } /* Wait for depop procedure finish */ 3632 3633 alc_write_coefex_idx(codec, 0x58, 0x00, val); /* write back the result */ 3634 alc_update_coef_idx(codec, 0x38, 1<<4, coef38); 3635 alc_update_coef_idx(codec, 0x0d, 0x110, coef0d); 3636 alc_update_coef_idx(codec, 0x36, 3<<13, coef36); 3637 3638 msleep(50); 3639 alc_update_coef_idx(codec, 0x4a, 1<<15, 0); 3640 } 3641 3642 static void alc225_init(struct hda_codec *codec) 3643 { 3644 struct alc_spec *spec = codec->spec; 3645 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3646 bool hp1_pin_sense, hp2_pin_sense; 3647 3648 if (spec->codec_variant != ALC269_TYPE_ALC287) 3649 /* required only at boot or S3 and S4 resume time */ 3650 if (!spec->done_hp_init || 3651 is_s3_resume(codec) || 3652 is_s4_resume(codec)) { 3653 alc285_hp_init(codec); 3654 spec->done_hp_init = true; 3655 } 3656 3657 if (!hp_pin) 3658 hp_pin = 0x21; 3659 msleep(30); 3660 3661 hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3662 hp2_pin_sense = snd_hda_jack_detect(codec, 0x16); 3663 3664 if (hp1_pin_sense || hp2_pin_sense) 3665 msleep(2); 3666 3667 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */ 3668 if (spec->ultra_low_power) { 3669 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 3<<2); 3670 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6); 3671 alc_update_coef_idx(codec, 0x33, 1<<11, 0); 3672 msleep(30); 3673 } 3674 3675 if (hp1_pin_sense || spec->ultra_low_power) 3676 snd_hda_codec_write(codec, hp_pin, 0, 3677 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3678 if (hp2_pin_sense) 3679 snd_hda_codec_write(codec, 0x16, 0, 3680 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3681 3682 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power) 3683 msleep(85); 3684 3685 if (hp1_pin_sense || spec->ultra_low_power) 3686 snd_hda_codec_write(codec, hp_pin, 0, 3687 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3688 if (hp2_pin_sense) 3689 snd_hda_codec_write(codec, 0x16, 0, 3690 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3691 3692 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power) 3693 msleep(100); 3694 3695 alc_update_coef_idx(codec, 0x4a, 3 << 10, 0); 3696 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */ 3697 } 3698 3699 static void alc225_shutup(struct hda_codec *codec) 3700 { 3701 struct alc_spec *spec = codec->spec; 3702 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3703 bool hp1_pin_sense, hp2_pin_sense; 3704 3705 if (!hp_pin) 3706 hp_pin = 0x21; 3707 3708 alc_disable_headset_jack_key(codec); 3709 /* 3k pull low control for Headset jack. */ 3710 alc_update_coef_idx(codec, 0x4a, 0, 3 << 10); 3711 3712 hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3713 hp2_pin_sense = snd_hda_jack_detect(codec, 0x16); 3714 3715 if (hp1_pin_sense || hp2_pin_sense) 3716 msleep(2); 3717 3718 if (hp1_pin_sense || spec->ultra_low_power) 3719 snd_hda_codec_write(codec, hp_pin, 0, 3720 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3721 if (hp2_pin_sense) 3722 snd_hda_codec_write(codec, 0x16, 0, 3723 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3724 3725 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power) 3726 msleep(85); 3727 3728 if (hp1_pin_sense || spec->ultra_low_power) 3729 snd_hda_codec_write(codec, hp_pin, 0, 3730 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3731 if (hp2_pin_sense) 3732 snd_hda_codec_write(codec, 0x16, 0, 3733 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3734 3735 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power) 3736 msleep(100); 3737 3738 alc_auto_setup_eapd(codec, false); 3739 alc_shutup_pins(codec); 3740 if (spec->ultra_low_power) { 3741 msleep(50); 3742 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 0x0c << 2); 3743 alc_update_coef_idx(codec, 0x0e, 7<<6, 0); 3744 alc_update_coef_idx(codec, 0x33, 1<<11, 1<<11); 3745 alc_update_coef_idx(codec, 0x4a, 3<<4, 2<<4); 3746 msleep(30); 3747 } 3748 3749 alc_update_coef_idx(codec, 0x4a, 3 << 10, 0); 3750 alc_enable_headset_jack_key(codec); 3751 } 3752 3753 static void alc_default_init(struct hda_codec *codec) 3754 { 3755 struct alc_spec *spec = codec->spec; 3756 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3757 bool hp_pin_sense; 3758 3759 if (!hp_pin) 3760 return; 3761 3762 msleep(30); 3763 3764 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3765 3766 if (hp_pin_sense) 3767 msleep(2); 3768 3769 snd_hda_codec_write(codec, hp_pin, 0, 3770 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3771 3772 if (hp_pin_sense) 3773 msleep(85); 3774 3775 snd_hda_codec_write(codec, hp_pin, 0, 3776 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 3777 3778 if (hp_pin_sense) 3779 msleep(100); 3780 } 3781 3782 static void alc_default_shutup(struct hda_codec *codec) 3783 { 3784 struct alc_spec *spec = codec->spec; 3785 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3786 bool hp_pin_sense; 3787 3788 if (!hp_pin) { 3789 alc269_shutup(codec); 3790 return; 3791 } 3792 3793 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 3794 3795 if (hp_pin_sense) 3796 msleep(2); 3797 3798 snd_hda_codec_write(codec, hp_pin, 0, 3799 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3800 3801 if (hp_pin_sense) 3802 msleep(85); 3803 3804 if (!spec->no_shutup_pins) 3805 snd_hda_codec_write(codec, hp_pin, 0, 3806 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3807 3808 if (hp_pin_sense) 3809 msleep(100); 3810 3811 alc_auto_setup_eapd(codec, false); 3812 alc_shutup_pins(codec); 3813 } 3814 3815 static void alc294_hp_init(struct hda_codec *codec) 3816 { 3817 struct alc_spec *spec = codec->spec; 3818 hda_nid_t hp_pin = alc_get_hp_pin(spec); 3819 int i, val; 3820 3821 if (!hp_pin) 3822 return; 3823 3824 snd_hda_codec_write(codec, hp_pin, 0, 3825 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 3826 3827 msleep(100); 3828 3829 if (!spec->no_shutup_pins) 3830 snd_hda_codec_write(codec, hp_pin, 0, 3831 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 3832 3833 alc_update_coef_idx(codec, 0x6f, 0x000f, 0);/* Set HP depop to manual mode */ 3834 alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000); /* HP depop procedure start */ 3835 3836 /* Wait for depop procedure finish */ 3837 val = alc_read_coefex_idx(codec, 0x58, 0x01); 3838 for (i = 0; i < 20 && val & 0x0080; i++) { 3839 msleep(50); 3840 val = alc_read_coefex_idx(codec, 0x58, 0x01); 3841 } 3842 /* Set HP depop to auto mode */ 3843 alc_update_coef_idx(codec, 0x6f, 0x000f, 0x000b); 3844 msleep(50); 3845 } 3846 3847 static void alc294_init(struct hda_codec *codec) 3848 { 3849 struct alc_spec *spec = codec->spec; 3850 3851 /* required only at boot or S4 resume time */ 3852 if (!spec->done_hp_init || 3853 codec->core.dev.power.power_state.event == PM_EVENT_RESTORE) { 3854 alc294_hp_init(codec); 3855 spec->done_hp_init = true; 3856 } 3857 alc_default_init(codec); 3858 } 3859 3860 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg, 3861 unsigned int val) 3862 { 3863 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1); 3864 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */ 3865 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */ 3866 } 3867 3868 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg) 3869 { 3870 unsigned int val; 3871 3872 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1); 3873 val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0) 3874 & 0xffff; 3875 val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0) 3876 << 16; 3877 return val; 3878 } 3879 3880 static void alc5505_dsp_halt(struct hda_codec *codec) 3881 { 3882 unsigned int val; 3883 3884 alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */ 3885 alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */ 3886 alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */ 3887 alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */ 3888 alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */ 3889 alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */ 3890 alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */ 3891 val = alc5505_coef_get(codec, 0x6220); 3892 alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */ 3893 } 3894 3895 static void alc5505_dsp_back_from_halt(struct hda_codec *codec) 3896 { 3897 alc5505_coef_set(codec, 0x61b8, 0x04133302); 3898 alc5505_coef_set(codec, 0x61b0, 0x00005b16); 3899 alc5505_coef_set(codec, 0x61b4, 0x040a2b02); 3900 alc5505_coef_set(codec, 0x6230, 0xf80d4011); 3901 alc5505_coef_set(codec, 0x6220, 0x2002010f); 3902 alc5505_coef_set(codec, 0x880c, 0x00000004); 3903 } 3904 3905 static void alc5505_dsp_init(struct hda_codec *codec) 3906 { 3907 unsigned int val; 3908 3909 alc5505_dsp_halt(codec); 3910 alc5505_dsp_back_from_halt(codec); 3911 alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */ 3912 alc5505_coef_set(codec, 0x61b0, 0x5b16); 3913 alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */ 3914 alc5505_coef_set(codec, 0x61b4, 0x04132b02); 3915 alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/ 3916 alc5505_coef_set(codec, 0x61b8, 0x041f3302); 3917 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */ 3918 alc5505_coef_set(codec, 0x61b8, 0x041b3302); 3919 alc5505_coef_set(codec, 0x61b8, 0x04173302); 3920 alc5505_coef_set(codec, 0x61b8, 0x04163302); 3921 alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */ 3922 alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */ 3923 alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */ 3924 3925 val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */ 3926 if (val <= 3) 3927 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */ 3928 else 3929 alc5505_coef_set(codec, 0x6220, 0x6002018f); 3930 3931 alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/ 3932 alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */ 3933 alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */ 3934 alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */ 3935 alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */ 3936 alc5505_coef_set(codec, 0x880c, 0x00000003); 3937 alc5505_coef_set(codec, 0x880c, 0x00000010); 3938 3939 #ifdef HALT_REALTEK_ALC5505 3940 alc5505_dsp_halt(codec); 3941 #endif 3942 } 3943 3944 #ifdef HALT_REALTEK_ALC5505 3945 #define alc5505_dsp_suspend(codec) do { } while (0) /* NOP */ 3946 #define alc5505_dsp_resume(codec) do { } while (0) /* NOP */ 3947 #else 3948 #define alc5505_dsp_suspend(codec) alc5505_dsp_halt(codec) 3949 #define alc5505_dsp_resume(codec) alc5505_dsp_back_from_halt(codec) 3950 #endif 3951 3952 #ifdef CONFIG_PM 3953 static int alc269_suspend(struct hda_codec *codec) 3954 { 3955 struct alc_spec *spec = codec->spec; 3956 3957 if (spec->has_alc5505_dsp) 3958 alc5505_dsp_suspend(codec); 3959 return alc_suspend(codec); 3960 } 3961 3962 static int alc269_resume(struct hda_codec *codec) 3963 { 3964 struct alc_spec *spec = codec->spec; 3965 3966 if (spec->codec_variant == ALC269_TYPE_ALC269VB) 3967 alc269vb_toggle_power_output(codec, 0); 3968 if (spec->codec_variant == ALC269_TYPE_ALC269VB && 3969 (alc_get_coef0(codec) & 0x00ff) == 0x018) { 3970 msleep(150); 3971 } 3972 3973 codec->patch_ops.init(codec); 3974 3975 if (spec->codec_variant == ALC269_TYPE_ALC269VB) 3976 alc269vb_toggle_power_output(codec, 1); 3977 if (spec->codec_variant == ALC269_TYPE_ALC269VB && 3978 (alc_get_coef0(codec) & 0x00ff) == 0x017) { 3979 msleep(200); 3980 } 3981 3982 snd_hda_regmap_sync(codec); 3983 hda_call_check_power_status(codec, 0x01); 3984 3985 /* on some machine, the BIOS will clear the codec gpio data when enter 3986 * suspend, and won't restore the data after resume, so we restore it 3987 * in the driver. 3988 */ 3989 if (spec->gpio_data) 3990 alc_write_gpio_data(codec); 3991 3992 if (spec->has_alc5505_dsp) 3993 alc5505_dsp_resume(codec); 3994 3995 return 0; 3996 } 3997 #endif /* CONFIG_PM */ 3998 3999 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec, 4000 const struct hda_fixup *fix, int action) 4001 { 4002 struct alc_spec *spec = codec->spec; 4003 4004 if (action == HDA_FIXUP_ACT_PRE_PROBE) 4005 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 4006 } 4007 4008 static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec, 4009 const struct hda_fixup *fix, 4010 int action) 4011 { 4012 unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21); 4013 unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19); 4014 4015 if (cfg_headphone && cfg_headset_mic == 0x411111f0) 4016 snd_hda_codec_set_pincfg(codec, 0x19, 4017 (cfg_headphone & ~AC_DEFCFG_DEVICE) | 4018 (AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT)); 4019 } 4020 4021 static void alc269_fixup_hweq(struct hda_codec *codec, 4022 const struct hda_fixup *fix, int action) 4023 { 4024 if (action == HDA_FIXUP_ACT_INIT) 4025 alc_update_coef_idx(codec, 0x1e, 0, 0x80); 4026 } 4027 4028 static void alc269_fixup_headset_mic(struct hda_codec *codec, 4029 const struct hda_fixup *fix, int action) 4030 { 4031 struct alc_spec *spec = codec->spec; 4032 4033 if (action == HDA_FIXUP_ACT_PRE_PROBE) 4034 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 4035 } 4036 4037 static void alc271_fixup_dmic(struct hda_codec *codec, 4038 const struct hda_fixup *fix, int action) 4039 { 4040 static const struct hda_verb verbs[] = { 4041 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d}, 4042 {0x20, AC_VERB_SET_PROC_COEF, 0x4000}, 4043 {} 4044 }; 4045 unsigned int cfg; 4046 4047 if (strcmp(codec->core.chip_name, "ALC271X") && 4048 strcmp(codec->core.chip_name, "ALC269VB")) 4049 return; 4050 cfg = snd_hda_codec_get_pincfg(codec, 0x12); 4051 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED) 4052 snd_hda_sequence_write(codec, verbs); 4053 } 4054 4055 /* Fix the speaker amp after resume, etc */ 4056 static void alc269vb_fixup_aspire_e1_coef(struct hda_codec *codec, 4057 const struct hda_fixup *fix, 4058 int action) 4059 { 4060 if (action == HDA_FIXUP_ACT_INIT) 4061 alc_update_coef_idx(codec, 0x0d, 0x6000, 0x6000); 4062 } 4063 4064 static void alc269_fixup_pcm_44k(struct hda_codec *codec, 4065 const struct hda_fixup *fix, int action) 4066 { 4067 struct alc_spec *spec = codec->spec; 4068 4069 if (action != HDA_FIXUP_ACT_PROBE) 4070 return; 4071 4072 /* Due to a hardware problem on Lenovo Ideadpad, we need to 4073 * fix the sample rate of analog I/O to 44.1kHz 4074 */ 4075 spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback; 4076 spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture; 4077 } 4078 4079 static void alc269_fixup_stereo_dmic(struct hda_codec *codec, 4080 const struct hda_fixup *fix, int action) 4081 { 4082 /* The digital-mic unit sends PDM (differential signal) instead of 4083 * the standard PCM, thus you can't record a valid mono stream as is. 4084 * Below is a workaround specific to ALC269 to control the dmic 4085 * signal source as mono. 4086 */ 4087 if (action == HDA_FIXUP_ACT_INIT) 4088 alc_update_coef_idx(codec, 0x07, 0, 0x80); 4089 } 4090 4091 static void alc269_quanta_automute(struct hda_codec *codec) 4092 { 4093 snd_hda_gen_update_outputs(codec); 4094 4095 alc_write_coef_idx(codec, 0x0c, 0x680); 4096 alc_write_coef_idx(codec, 0x0c, 0x480); 4097 } 4098 4099 static void alc269_fixup_quanta_mute(struct hda_codec *codec, 4100 const struct hda_fixup *fix, int action) 4101 { 4102 struct alc_spec *spec = codec->spec; 4103 if (action != HDA_FIXUP_ACT_PROBE) 4104 return; 4105 spec->gen.automute_hook = alc269_quanta_automute; 4106 } 4107 4108 static void alc269_x101_hp_automute_hook(struct hda_codec *codec, 4109 struct hda_jack_callback *jack) 4110 { 4111 struct alc_spec *spec = codec->spec; 4112 int vref; 4113 msleep(200); 4114 snd_hda_gen_hp_automute(codec, jack); 4115 4116 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0; 4117 msleep(100); 4118 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4119 vref); 4120 msleep(500); 4121 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4122 vref); 4123 } 4124 4125 /* 4126 * Magic sequence to make Huawei Matebook X right speaker working (bko#197801) 4127 */ 4128 struct hda_alc298_mbxinit { 4129 unsigned char value_0x23; 4130 unsigned char value_0x25; 4131 }; 4132 4133 static void alc298_huawei_mbx_stereo_seq(struct hda_codec *codec, 4134 const struct hda_alc298_mbxinit *initval, 4135 bool first) 4136 { 4137 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x0); 4138 alc_write_coef_idx(codec, 0x26, 0xb000); 4139 4140 if (first) 4141 snd_hda_codec_write(codec, 0x21, 0, AC_VERB_GET_PIN_SENSE, 0x0); 4142 4143 snd_hda_codec_write(codec, 0x6, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80); 4144 alc_write_coef_idx(codec, 0x26, 0xf000); 4145 alc_write_coef_idx(codec, 0x23, initval->value_0x23); 4146 4147 if (initval->value_0x23 != 0x1e) 4148 alc_write_coef_idx(codec, 0x25, initval->value_0x25); 4149 4150 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26); 4151 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010); 4152 } 4153 4154 static void alc298_fixup_huawei_mbx_stereo(struct hda_codec *codec, 4155 const struct hda_fixup *fix, 4156 int action) 4157 { 4158 /* Initialization magic */ 4159 static const struct hda_alc298_mbxinit dac_init[] = { 4160 {0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00}, 4161 {0x10, 0x00}, {0x1a, 0x40}, {0x1b, 0x82}, {0x1c, 0x00}, 4162 {0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00}, 4163 {0x20, 0xc2}, {0x21, 0xc8}, {0x22, 0x26}, {0x23, 0x24}, 4164 {0x27, 0xff}, {0x28, 0xff}, {0x29, 0xff}, {0x2a, 0x8f}, 4165 {0x2b, 0x02}, {0x2c, 0x48}, {0x2d, 0x34}, {0x2e, 0x00}, 4166 {0x2f, 0x00}, 4167 {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00}, 4168 {0x34, 0x00}, {0x35, 0x01}, {0x36, 0x93}, {0x37, 0x0c}, 4169 {0x38, 0x00}, {0x39, 0x00}, {0x3a, 0xf8}, {0x38, 0x80}, 4170 {} 4171 }; 4172 const struct hda_alc298_mbxinit *seq; 4173 4174 if (action != HDA_FIXUP_ACT_INIT) 4175 return; 4176 4177 /* Start */ 4178 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x00); 4179 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80); 4180 alc_write_coef_idx(codec, 0x26, 0xf000); 4181 alc_write_coef_idx(codec, 0x22, 0x31); 4182 alc_write_coef_idx(codec, 0x23, 0x0b); 4183 alc_write_coef_idx(codec, 0x25, 0x00); 4184 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26); 4185 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010); 4186 4187 for (seq = dac_init; seq->value_0x23; seq++) 4188 alc298_huawei_mbx_stereo_seq(codec, seq, seq == dac_init); 4189 } 4190 4191 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec, 4192 const struct hda_fixup *fix, int action) 4193 { 4194 struct alc_spec *spec = codec->spec; 4195 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4196 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 4197 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook; 4198 } 4199 } 4200 4201 static void alc_update_vref_led(struct hda_codec *codec, hda_nid_t pin, 4202 bool polarity, bool on) 4203 { 4204 unsigned int pinval; 4205 4206 if (!pin) 4207 return; 4208 if (polarity) 4209 on = !on; 4210 pinval = snd_hda_codec_get_pin_target(codec, pin); 4211 pinval &= ~AC_PINCTL_VREFEN; 4212 pinval |= on ? AC_PINCTL_VREF_80 : AC_PINCTL_VREF_HIZ; 4213 /* temporarily power up/down for setting VREF */ 4214 snd_hda_power_up_pm(codec); 4215 snd_hda_set_pin_ctl_cache(codec, pin, pinval); 4216 snd_hda_power_down_pm(codec); 4217 } 4218 4219 /* update mute-LED according to the speaker mute state via mic VREF pin */ 4220 static int vref_mute_led_set(struct led_classdev *led_cdev, 4221 enum led_brightness brightness) 4222 { 4223 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4224 struct alc_spec *spec = codec->spec; 4225 4226 alc_update_vref_led(codec, spec->mute_led_nid, 4227 spec->mute_led_polarity, brightness); 4228 return 0; 4229 } 4230 4231 /* Make sure the led works even in runtime suspend */ 4232 static unsigned int led_power_filter(struct hda_codec *codec, 4233 hda_nid_t nid, 4234 unsigned int power_state) 4235 { 4236 struct alc_spec *spec = codec->spec; 4237 4238 if (power_state != AC_PWRST_D3 || nid == 0 || 4239 (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid)) 4240 return power_state; 4241 4242 /* Set pin ctl again, it might have just been set to 0 */ 4243 snd_hda_set_pin_ctl(codec, nid, 4244 snd_hda_codec_get_pin_target(codec, nid)); 4245 4246 return snd_hda_gen_path_power_filter(codec, nid, power_state); 4247 } 4248 4249 static void alc269_fixup_hp_mute_led(struct hda_codec *codec, 4250 const struct hda_fixup *fix, int action) 4251 { 4252 struct alc_spec *spec = codec->spec; 4253 const struct dmi_device *dev = NULL; 4254 4255 if (action != HDA_FIXUP_ACT_PRE_PROBE) 4256 return; 4257 4258 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) { 4259 int pol, pin; 4260 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2) 4261 continue; 4262 if (pin < 0x0a || pin >= 0x10) 4263 break; 4264 spec->mute_led_polarity = pol; 4265 spec->mute_led_nid = pin - 0x0a + 0x18; 4266 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set); 4267 codec->power_filter = led_power_filter; 4268 codec_dbg(codec, 4269 "Detected mute LED for %x:%d\n", spec->mute_led_nid, 4270 spec->mute_led_polarity); 4271 break; 4272 } 4273 } 4274 4275 static void alc269_fixup_hp_mute_led_micx(struct hda_codec *codec, 4276 const struct hda_fixup *fix, 4277 int action, hda_nid_t pin) 4278 { 4279 struct alc_spec *spec = codec->spec; 4280 4281 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4282 spec->mute_led_polarity = 0; 4283 spec->mute_led_nid = pin; 4284 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set); 4285 codec->power_filter = led_power_filter; 4286 } 4287 } 4288 4289 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec, 4290 const struct hda_fixup *fix, int action) 4291 { 4292 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x18); 4293 } 4294 4295 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec, 4296 const struct hda_fixup *fix, int action) 4297 { 4298 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x19); 4299 } 4300 4301 static void alc269_fixup_hp_mute_led_mic3(struct hda_codec *codec, 4302 const struct hda_fixup *fix, int action) 4303 { 4304 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1b); 4305 } 4306 4307 /* update LED status via GPIO */ 4308 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask, 4309 int polarity, bool enabled) 4310 { 4311 if (polarity) 4312 enabled = !enabled; 4313 alc_update_gpio_data(codec, mask, !enabled); /* muted -> LED on */ 4314 } 4315 4316 /* turn on/off mute LED via GPIO per vmaster hook */ 4317 static int gpio_mute_led_set(struct led_classdev *led_cdev, 4318 enum led_brightness brightness) 4319 { 4320 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4321 struct alc_spec *spec = codec->spec; 4322 4323 alc_update_gpio_led(codec, spec->gpio_mute_led_mask, 4324 spec->mute_led_polarity, !brightness); 4325 return 0; 4326 } 4327 4328 /* turn on/off mic-mute LED via GPIO per capture hook */ 4329 static int micmute_led_set(struct led_classdev *led_cdev, 4330 enum led_brightness brightness) 4331 { 4332 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4333 struct alc_spec *spec = codec->spec; 4334 4335 alc_update_gpio_led(codec, spec->gpio_mic_led_mask, 4336 spec->micmute_led_polarity, !brightness); 4337 return 0; 4338 } 4339 4340 /* setup mute and mic-mute GPIO bits, add hooks appropriately */ 4341 static void alc_fixup_hp_gpio_led(struct hda_codec *codec, 4342 int action, 4343 unsigned int mute_mask, 4344 unsigned int micmute_mask) 4345 { 4346 struct alc_spec *spec = codec->spec; 4347 4348 alc_fixup_gpio(codec, action, mute_mask | micmute_mask); 4349 4350 if (action != HDA_FIXUP_ACT_PRE_PROBE) 4351 return; 4352 if (mute_mask) { 4353 spec->gpio_mute_led_mask = mute_mask; 4354 snd_hda_gen_add_mute_led_cdev(codec, gpio_mute_led_set); 4355 } 4356 if (micmute_mask) { 4357 spec->gpio_mic_led_mask = micmute_mask; 4358 snd_hda_gen_add_micmute_led_cdev(codec, micmute_led_set); 4359 } 4360 } 4361 4362 static void alc236_fixup_hp_gpio_led(struct hda_codec *codec, 4363 const struct hda_fixup *fix, int action) 4364 { 4365 alc_fixup_hp_gpio_led(codec, action, 0x02, 0x01); 4366 } 4367 4368 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec, 4369 const struct hda_fixup *fix, int action) 4370 { 4371 alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10); 4372 } 4373 4374 static void alc285_fixup_hp_gpio_led(struct hda_codec *codec, 4375 const struct hda_fixup *fix, int action) 4376 { 4377 alc_fixup_hp_gpio_led(codec, action, 0x04, 0x01); 4378 } 4379 4380 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec, 4381 const struct hda_fixup *fix, int action) 4382 { 4383 alc_fixup_hp_gpio_led(codec, action, 0x02, 0x20); 4384 } 4385 4386 static void alc287_fixup_hp_gpio_led(struct hda_codec *codec, 4387 const struct hda_fixup *fix, int action) 4388 { 4389 alc_fixup_hp_gpio_led(codec, action, 0x10, 0); 4390 } 4391 4392 static void alc245_fixup_hp_gpio_led(struct hda_codec *codec, 4393 const struct hda_fixup *fix, int action) 4394 { 4395 struct alc_spec *spec = codec->spec; 4396 4397 if (action == HDA_FIXUP_ACT_PRE_PROBE) 4398 spec->micmute_led_polarity = 1; 4399 alc_fixup_hp_gpio_led(codec, action, 0, 0x04); 4400 } 4401 4402 /* turn on/off mic-mute LED per capture hook via VREF change */ 4403 static int vref_micmute_led_set(struct led_classdev *led_cdev, 4404 enum led_brightness brightness) 4405 { 4406 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4407 struct alc_spec *spec = codec->spec; 4408 4409 alc_update_vref_led(codec, spec->cap_mute_led_nid, 4410 spec->micmute_led_polarity, brightness); 4411 return 0; 4412 } 4413 4414 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec, 4415 const struct hda_fixup *fix, int action) 4416 { 4417 struct alc_spec *spec = codec->spec; 4418 4419 alc_fixup_hp_gpio_led(codec, action, 0x08, 0); 4420 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4421 /* Like hp_gpio_mic1_led, but also needs GPIO4 low to 4422 * enable headphone amp 4423 */ 4424 spec->gpio_mask |= 0x10; 4425 spec->gpio_dir |= 0x10; 4426 spec->cap_mute_led_nid = 0x18; 4427 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set); 4428 codec->power_filter = led_power_filter; 4429 } 4430 } 4431 4432 static void alc280_fixup_hp_gpio4(struct hda_codec *codec, 4433 const struct hda_fixup *fix, int action) 4434 { 4435 struct alc_spec *spec = codec->spec; 4436 4437 alc_fixup_hp_gpio_led(codec, action, 0x08, 0); 4438 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4439 spec->cap_mute_led_nid = 0x18; 4440 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set); 4441 codec->power_filter = led_power_filter; 4442 } 4443 } 4444 4445 /* HP Spectre x360 14 model needs a unique workaround for enabling the amp; 4446 * it needs to toggle the GPIO0 once on and off at each time (bko#210633) 4447 */ 4448 static void alc245_fixup_hp_x360_amp(struct hda_codec *codec, 4449 const struct hda_fixup *fix, int action) 4450 { 4451 struct alc_spec *spec = codec->spec; 4452 4453 switch (action) { 4454 case HDA_FIXUP_ACT_PRE_PROBE: 4455 spec->gpio_mask |= 0x01; 4456 spec->gpio_dir |= 0x01; 4457 break; 4458 case HDA_FIXUP_ACT_INIT: 4459 /* need to toggle GPIO to enable the amp */ 4460 alc_update_gpio_data(codec, 0x01, true); 4461 msleep(100); 4462 alc_update_gpio_data(codec, 0x01, false); 4463 break; 4464 } 4465 } 4466 4467 /* toggle GPIO2 at each time stream is started; we use PREPARE state instead */ 4468 static void alc274_hp_envy_pcm_hook(struct hda_pcm_stream *hinfo, 4469 struct hda_codec *codec, 4470 struct snd_pcm_substream *substream, 4471 int action) 4472 { 4473 switch (action) { 4474 case HDA_GEN_PCM_ACT_PREPARE: 4475 alc_update_gpio_data(codec, 0x04, true); 4476 break; 4477 case HDA_GEN_PCM_ACT_CLEANUP: 4478 alc_update_gpio_data(codec, 0x04, false); 4479 break; 4480 } 4481 } 4482 4483 static void alc274_fixup_hp_envy_gpio(struct hda_codec *codec, 4484 const struct hda_fixup *fix, 4485 int action) 4486 { 4487 struct alc_spec *spec = codec->spec; 4488 4489 if (action == HDA_FIXUP_ACT_PROBE) { 4490 spec->gpio_mask |= 0x04; 4491 spec->gpio_dir |= 0x04; 4492 spec->gen.pcm_playback_hook = alc274_hp_envy_pcm_hook; 4493 } 4494 } 4495 4496 static void alc_update_coef_led(struct hda_codec *codec, 4497 struct alc_coef_led *led, 4498 bool polarity, bool on) 4499 { 4500 if (polarity) 4501 on = !on; 4502 /* temporarily power up/down for setting COEF bit */ 4503 alc_update_coef_idx(codec, led->idx, led->mask, 4504 on ? led->on : led->off); 4505 } 4506 4507 /* update mute-LED according to the speaker mute state via COEF bit */ 4508 static int coef_mute_led_set(struct led_classdev *led_cdev, 4509 enum led_brightness brightness) 4510 { 4511 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4512 struct alc_spec *spec = codec->spec; 4513 4514 alc_update_coef_led(codec, &spec->mute_led_coef, 4515 spec->mute_led_polarity, brightness); 4516 return 0; 4517 } 4518 4519 static void alc285_fixup_hp_mute_led_coefbit(struct hda_codec *codec, 4520 const struct hda_fixup *fix, 4521 int action) 4522 { 4523 struct alc_spec *spec = codec->spec; 4524 4525 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4526 spec->mute_led_polarity = 0; 4527 spec->mute_led_coef.idx = 0x0b; 4528 spec->mute_led_coef.mask = 1 << 3; 4529 spec->mute_led_coef.on = 1 << 3; 4530 spec->mute_led_coef.off = 0; 4531 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set); 4532 } 4533 } 4534 4535 static void alc236_fixup_hp_mute_led_coefbit(struct hda_codec *codec, 4536 const struct hda_fixup *fix, 4537 int action) 4538 { 4539 struct alc_spec *spec = codec->spec; 4540 4541 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4542 spec->mute_led_polarity = 0; 4543 spec->mute_led_coef.idx = 0x34; 4544 spec->mute_led_coef.mask = 1 << 5; 4545 spec->mute_led_coef.on = 0; 4546 spec->mute_led_coef.off = 1 << 5; 4547 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set); 4548 } 4549 } 4550 4551 /* turn on/off mic-mute LED per capture hook by coef bit */ 4552 static int coef_micmute_led_set(struct led_classdev *led_cdev, 4553 enum led_brightness brightness) 4554 { 4555 struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent); 4556 struct alc_spec *spec = codec->spec; 4557 4558 alc_update_coef_led(codec, &spec->mic_led_coef, 4559 spec->micmute_led_polarity, brightness); 4560 return 0; 4561 } 4562 4563 static void alc285_fixup_hp_coef_micmute_led(struct hda_codec *codec, 4564 const struct hda_fixup *fix, int action) 4565 { 4566 struct alc_spec *spec = codec->spec; 4567 4568 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4569 spec->mic_led_coef.idx = 0x19; 4570 spec->mic_led_coef.mask = 1 << 13; 4571 spec->mic_led_coef.on = 1 << 13; 4572 spec->mic_led_coef.off = 0; 4573 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set); 4574 } 4575 } 4576 4577 static void alc236_fixup_hp_coef_micmute_led(struct hda_codec *codec, 4578 const struct hda_fixup *fix, int action) 4579 { 4580 struct alc_spec *spec = codec->spec; 4581 4582 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4583 spec->mic_led_coef.idx = 0x35; 4584 spec->mic_led_coef.mask = 3 << 2; 4585 spec->mic_led_coef.on = 2 << 2; 4586 spec->mic_led_coef.off = 1 << 2; 4587 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set); 4588 } 4589 } 4590 4591 static void alc285_fixup_hp_mute_led(struct hda_codec *codec, 4592 const struct hda_fixup *fix, int action) 4593 { 4594 alc285_fixup_hp_mute_led_coefbit(codec, fix, action); 4595 alc285_fixup_hp_coef_micmute_led(codec, fix, action); 4596 } 4597 4598 static void alc236_fixup_hp_mute_led(struct hda_codec *codec, 4599 const struct hda_fixup *fix, int action) 4600 { 4601 alc236_fixup_hp_mute_led_coefbit(codec, fix, action); 4602 alc236_fixup_hp_coef_micmute_led(codec, fix, action); 4603 } 4604 4605 static void alc236_fixup_hp_micmute_led_vref(struct hda_codec *codec, 4606 const struct hda_fixup *fix, int action) 4607 { 4608 struct alc_spec *spec = codec->spec; 4609 4610 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4611 spec->cap_mute_led_nid = 0x1a; 4612 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set); 4613 codec->power_filter = led_power_filter; 4614 } 4615 } 4616 4617 static void alc236_fixup_hp_mute_led_micmute_vref(struct hda_codec *codec, 4618 const struct hda_fixup *fix, int action) 4619 { 4620 alc236_fixup_hp_mute_led_coefbit(codec, fix, action); 4621 alc236_fixup_hp_micmute_led_vref(codec, fix, action); 4622 } 4623 4624 #if IS_REACHABLE(CONFIG_INPUT) 4625 static void gpio2_mic_hotkey_event(struct hda_codec *codec, 4626 struct hda_jack_callback *event) 4627 { 4628 struct alc_spec *spec = codec->spec; 4629 4630 /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore 4631 send both key on and key off event for every interrupt. */ 4632 input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1); 4633 input_sync(spec->kb_dev); 4634 input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0); 4635 input_sync(spec->kb_dev); 4636 } 4637 4638 static int alc_register_micmute_input_device(struct hda_codec *codec) 4639 { 4640 struct alc_spec *spec = codec->spec; 4641 int i; 4642 4643 spec->kb_dev = input_allocate_device(); 4644 if (!spec->kb_dev) { 4645 codec_err(codec, "Out of memory (input_allocate_device)\n"); 4646 return -ENOMEM; 4647 } 4648 4649 spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE; 4650 4651 spec->kb_dev->name = "Microphone Mute Button"; 4652 spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY); 4653 spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]); 4654 spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map); 4655 spec->kb_dev->keycode = spec->alc_mute_keycode_map; 4656 for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++) 4657 set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit); 4658 4659 if (input_register_device(spec->kb_dev)) { 4660 codec_err(codec, "input_register_device failed\n"); 4661 input_free_device(spec->kb_dev); 4662 spec->kb_dev = NULL; 4663 return -ENOMEM; 4664 } 4665 4666 return 0; 4667 } 4668 4669 /* GPIO1 = set according to SKU external amp 4670 * GPIO2 = mic mute hotkey 4671 * GPIO3 = mute LED 4672 * GPIO4 = mic mute LED 4673 */ 4674 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec, 4675 const struct hda_fixup *fix, int action) 4676 { 4677 struct alc_spec *spec = codec->spec; 4678 4679 alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10); 4680 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4681 spec->init_amp = ALC_INIT_DEFAULT; 4682 if (alc_register_micmute_input_device(codec) != 0) 4683 return; 4684 4685 spec->gpio_mask |= 0x06; 4686 spec->gpio_dir |= 0x02; 4687 spec->gpio_data |= 0x02; 4688 snd_hda_codec_write_cache(codec, codec->core.afg, 0, 4689 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04); 4690 snd_hda_jack_detect_enable_callback(codec, codec->core.afg, 4691 gpio2_mic_hotkey_event); 4692 return; 4693 } 4694 4695 if (!spec->kb_dev) 4696 return; 4697 4698 switch (action) { 4699 case HDA_FIXUP_ACT_FREE: 4700 input_unregister_device(spec->kb_dev); 4701 spec->kb_dev = NULL; 4702 } 4703 } 4704 4705 /* Line2 = mic mute hotkey 4706 * GPIO2 = mic mute LED 4707 */ 4708 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec, 4709 const struct hda_fixup *fix, int action) 4710 { 4711 struct alc_spec *spec = codec->spec; 4712 4713 alc_fixup_hp_gpio_led(codec, action, 0, 0x04); 4714 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4715 spec->init_amp = ALC_INIT_DEFAULT; 4716 if (alc_register_micmute_input_device(codec) != 0) 4717 return; 4718 4719 snd_hda_jack_detect_enable_callback(codec, 0x1b, 4720 gpio2_mic_hotkey_event); 4721 return; 4722 } 4723 4724 if (!spec->kb_dev) 4725 return; 4726 4727 switch (action) { 4728 case HDA_FIXUP_ACT_FREE: 4729 input_unregister_device(spec->kb_dev); 4730 spec->kb_dev = NULL; 4731 } 4732 } 4733 #else /* INPUT */ 4734 #define alc280_fixup_hp_gpio2_mic_hotkey NULL 4735 #define alc233_fixup_lenovo_line2_mic_hotkey NULL 4736 #endif /* INPUT */ 4737 4738 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec, 4739 const struct hda_fixup *fix, int action) 4740 { 4741 struct alc_spec *spec = codec->spec; 4742 4743 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1a); 4744 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4745 spec->cap_mute_led_nid = 0x18; 4746 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set); 4747 } 4748 } 4749 4750 static const struct coef_fw alc225_pre_hsmode[] = { 4751 UPDATE_COEF(0x4a, 1<<8, 0), 4752 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), 4753 UPDATE_COEF(0x63, 3<<14, 3<<14), 4754 UPDATE_COEF(0x4a, 3<<4, 2<<4), 4755 UPDATE_COEF(0x4a, 3<<10, 3<<10), 4756 UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10), 4757 UPDATE_COEF(0x4a, 3<<10, 0), 4758 {} 4759 }; 4760 4761 static void alc_headset_mode_unplugged(struct hda_codec *codec) 4762 { 4763 struct alc_spec *spec = codec->spec; 4764 static const struct coef_fw coef0255[] = { 4765 WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */ 4766 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */ 4767 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/ 4768 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */ 4769 WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */ 4770 {} 4771 }; 4772 static const struct coef_fw coef0256[] = { 4773 WRITE_COEF(0x1b, 0x0c4b), /* LDO and MISC control */ 4774 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */ 4775 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */ 4776 WRITE_COEFEX(0x57, 0x03, 0x09a3), /* Direct Drive HP Amp control */ 4777 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/ 4778 {} 4779 }; 4780 static const struct coef_fw coef0233[] = { 4781 WRITE_COEF(0x1b, 0x0c0b), 4782 WRITE_COEF(0x45, 0xc429), 4783 UPDATE_COEF(0x35, 0x4000, 0), 4784 WRITE_COEF(0x06, 0x2104), 4785 WRITE_COEF(0x1a, 0x0001), 4786 WRITE_COEF(0x26, 0x0004), 4787 WRITE_COEF(0x32, 0x42a3), 4788 {} 4789 }; 4790 static const struct coef_fw coef0288[] = { 4791 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), 4792 UPDATE_COEF(0x50, 0x2000, 0x2000), 4793 UPDATE_COEF(0x56, 0x0006, 0x0006), 4794 UPDATE_COEF(0x66, 0x0008, 0), 4795 UPDATE_COEF(0x67, 0x2000, 0), 4796 {} 4797 }; 4798 static const struct coef_fw coef0298[] = { 4799 UPDATE_COEF(0x19, 0x1300, 0x0300), 4800 {} 4801 }; 4802 static const struct coef_fw coef0292[] = { 4803 WRITE_COEF(0x76, 0x000e), 4804 WRITE_COEF(0x6c, 0x2400), 4805 WRITE_COEF(0x18, 0x7308), 4806 WRITE_COEF(0x6b, 0xc429), 4807 {} 4808 }; 4809 static const struct coef_fw coef0293[] = { 4810 UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */ 4811 UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */ 4812 UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */ 4813 UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */ 4814 WRITE_COEF(0x45, 0xc429), /* Set to TRS type */ 4815 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */ 4816 {} 4817 }; 4818 static const struct coef_fw coef0668[] = { 4819 WRITE_COEF(0x15, 0x0d40), 4820 WRITE_COEF(0xb7, 0x802b), 4821 {} 4822 }; 4823 static const struct coef_fw coef0225[] = { 4824 UPDATE_COEF(0x63, 3<<14, 0), 4825 {} 4826 }; 4827 static const struct coef_fw coef0274[] = { 4828 UPDATE_COEF(0x4a, 0x0100, 0), 4829 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0), 4830 UPDATE_COEF(0x6b, 0xf000, 0x5000), 4831 UPDATE_COEF(0x4a, 0x0010, 0), 4832 UPDATE_COEF(0x4a, 0x0c00, 0x0c00), 4833 WRITE_COEF(0x45, 0x5289), 4834 UPDATE_COEF(0x4a, 0x0c00, 0), 4835 {} 4836 }; 4837 4838 if (spec->no_internal_mic_pin) { 4839 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12); 4840 return; 4841 } 4842 4843 switch (codec->core.vendor_id) { 4844 case 0x10ec0255: 4845 alc_process_coef_fw(codec, coef0255); 4846 break; 4847 case 0x10ec0230: 4848 case 0x10ec0236: 4849 case 0x10ec0256: 4850 alc_process_coef_fw(codec, coef0256); 4851 break; 4852 case 0x10ec0234: 4853 case 0x10ec0274: 4854 case 0x10ec0294: 4855 alc_process_coef_fw(codec, coef0274); 4856 break; 4857 case 0x10ec0233: 4858 case 0x10ec0283: 4859 alc_process_coef_fw(codec, coef0233); 4860 break; 4861 case 0x10ec0286: 4862 case 0x10ec0288: 4863 alc_process_coef_fw(codec, coef0288); 4864 break; 4865 case 0x10ec0298: 4866 alc_process_coef_fw(codec, coef0298); 4867 alc_process_coef_fw(codec, coef0288); 4868 break; 4869 case 0x10ec0292: 4870 alc_process_coef_fw(codec, coef0292); 4871 break; 4872 case 0x10ec0293: 4873 alc_process_coef_fw(codec, coef0293); 4874 break; 4875 case 0x10ec0668: 4876 alc_process_coef_fw(codec, coef0668); 4877 break; 4878 case 0x10ec0215: 4879 case 0x10ec0225: 4880 case 0x10ec0285: 4881 case 0x10ec0295: 4882 case 0x10ec0289: 4883 case 0x10ec0299: 4884 alc_process_coef_fw(codec, alc225_pre_hsmode); 4885 alc_process_coef_fw(codec, coef0225); 4886 break; 4887 case 0x10ec0867: 4888 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0); 4889 break; 4890 } 4891 codec_dbg(codec, "Headset jack set to unplugged mode.\n"); 4892 } 4893 4894 4895 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin, 4896 hda_nid_t mic_pin) 4897 { 4898 static const struct coef_fw coef0255[] = { 4899 WRITE_COEFEX(0x57, 0x03, 0x8aa6), 4900 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */ 4901 {} 4902 }; 4903 static const struct coef_fw coef0256[] = { 4904 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), /* Direct Drive HP Amp control(Set to verb control)*/ 4905 WRITE_COEFEX(0x57, 0x03, 0x09a3), 4906 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */ 4907 {} 4908 }; 4909 static const struct coef_fw coef0233[] = { 4910 UPDATE_COEF(0x35, 0, 1<<14), 4911 WRITE_COEF(0x06, 0x2100), 4912 WRITE_COEF(0x1a, 0x0021), 4913 WRITE_COEF(0x26, 0x008c), 4914 {} 4915 }; 4916 static const struct coef_fw coef0288[] = { 4917 UPDATE_COEF(0x4f, 0x00c0, 0), 4918 UPDATE_COEF(0x50, 0x2000, 0), 4919 UPDATE_COEF(0x56, 0x0006, 0), 4920 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), 4921 UPDATE_COEF(0x66, 0x0008, 0x0008), 4922 UPDATE_COEF(0x67, 0x2000, 0x2000), 4923 {} 4924 }; 4925 static const struct coef_fw coef0292[] = { 4926 WRITE_COEF(0x19, 0xa208), 4927 WRITE_COEF(0x2e, 0xacf0), 4928 {} 4929 }; 4930 static const struct coef_fw coef0293[] = { 4931 UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */ 4932 UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */ 4933 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */ 4934 {} 4935 }; 4936 static const struct coef_fw coef0688[] = { 4937 WRITE_COEF(0xb7, 0x802b), 4938 WRITE_COEF(0xb5, 0x1040), 4939 UPDATE_COEF(0xc3, 0, 1<<12), 4940 {} 4941 }; 4942 static const struct coef_fw coef0225[] = { 4943 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), 4944 UPDATE_COEF(0x4a, 3<<4, 2<<4), 4945 UPDATE_COEF(0x63, 3<<14, 0), 4946 {} 4947 }; 4948 static const struct coef_fw coef0274[] = { 4949 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0x4000), 4950 UPDATE_COEF(0x4a, 0x0010, 0), 4951 UPDATE_COEF(0x6b, 0xf000, 0), 4952 {} 4953 }; 4954 4955 switch (codec->core.vendor_id) { 4956 case 0x10ec0255: 4957 alc_write_coef_idx(codec, 0x45, 0xc489); 4958 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 4959 alc_process_coef_fw(codec, coef0255); 4960 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 4961 break; 4962 case 0x10ec0230: 4963 case 0x10ec0236: 4964 case 0x10ec0256: 4965 alc_write_coef_idx(codec, 0x45, 0xc489); 4966 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 4967 alc_process_coef_fw(codec, coef0256); 4968 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 4969 break; 4970 case 0x10ec0234: 4971 case 0x10ec0274: 4972 case 0x10ec0294: 4973 alc_write_coef_idx(codec, 0x45, 0x4689); 4974 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 4975 alc_process_coef_fw(codec, coef0274); 4976 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 4977 break; 4978 case 0x10ec0233: 4979 case 0x10ec0283: 4980 alc_write_coef_idx(codec, 0x45, 0xc429); 4981 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 4982 alc_process_coef_fw(codec, coef0233); 4983 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 4984 break; 4985 case 0x10ec0286: 4986 case 0x10ec0288: 4987 case 0x10ec0298: 4988 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 4989 alc_process_coef_fw(codec, coef0288); 4990 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 4991 break; 4992 case 0x10ec0292: 4993 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 4994 alc_process_coef_fw(codec, coef0292); 4995 break; 4996 case 0x10ec0293: 4997 /* Set to TRS mode */ 4998 alc_write_coef_idx(codec, 0x45, 0xc429); 4999 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5000 alc_process_coef_fw(codec, coef0293); 5001 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 5002 break; 5003 case 0x10ec0867: 5004 alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14); 5005 fallthrough; 5006 case 0x10ec0221: 5007 case 0x10ec0662: 5008 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5009 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 5010 break; 5011 case 0x10ec0668: 5012 alc_write_coef_idx(codec, 0x11, 0x0001); 5013 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5014 alc_process_coef_fw(codec, coef0688); 5015 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 5016 break; 5017 case 0x10ec0215: 5018 case 0x10ec0225: 5019 case 0x10ec0285: 5020 case 0x10ec0295: 5021 case 0x10ec0289: 5022 case 0x10ec0299: 5023 alc_process_coef_fw(codec, alc225_pre_hsmode); 5024 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10); 5025 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 5026 alc_process_coef_fw(codec, coef0225); 5027 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 5028 break; 5029 } 5030 codec_dbg(codec, "Headset jack set to mic-in mode.\n"); 5031 } 5032 5033 static void alc_headset_mode_default(struct hda_codec *codec) 5034 { 5035 static const struct coef_fw coef0225[] = { 5036 UPDATE_COEF(0x45, 0x3f<<10, 0x30<<10), 5037 UPDATE_COEF(0x45, 0x3f<<10, 0x31<<10), 5038 UPDATE_COEF(0x49, 3<<8, 0<<8), 5039 UPDATE_COEF(0x4a, 3<<4, 3<<4), 5040 UPDATE_COEF(0x63, 3<<14, 0), 5041 UPDATE_COEF(0x67, 0xf000, 0x3000), 5042 {} 5043 }; 5044 static const struct coef_fw coef0255[] = { 5045 WRITE_COEF(0x45, 0xc089), 5046 WRITE_COEF(0x45, 0xc489), 5047 WRITE_COEFEX(0x57, 0x03, 0x8ea6), 5048 WRITE_COEF(0x49, 0x0049), 5049 {} 5050 }; 5051 static const struct coef_fw coef0256[] = { 5052 WRITE_COEF(0x45, 0xc489), 5053 WRITE_COEFEX(0x57, 0x03, 0x0da3), 5054 WRITE_COEF(0x49, 0x0049), 5055 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/ 5056 WRITE_COEF(0x06, 0x6100), 5057 {} 5058 }; 5059 static const struct coef_fw coef0233[] = { 5060 WRITE_COEF(0x06, 0x2100), 5061 WRITE_COEF(0x32, 0x4ea3), 5062 {} 5063 }; 5064 static const struct coef_fw coef0288[] = { 5065 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */ 5066 UPDATE_COEF(0x50, 0x2000, 0x2000), 5067 UPDATE_COEF(0x56, 0x0006, 0x0006), 5068 UPDATE_COEF(0x66, 0x0008, 0), 5069 UPDATE_COEF(0x67, 0x2000, 0), 5070 {} 5071 }; 5072 static const struct coef_fw coef0292[] = { 5073 WRITE_COEF(0x76, 0x000e), 5074 WRITE_COEF(0x6c, 0x2400), 5075 WRITE_COEF(0x6b, 0xc429), 5076 WRITE_COEF(0x18, 0x7308), 5077 {} 5078 }; 5079 static const struct coef_fw coef0293[] = { 5080 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */ 5081 WRITE_COEF(0x45, 0xC429), /* Set to TRS type */ 5082 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */ 5083 {} 5084 }; 5085 static const struct coef_fw coef0688[] = { 5086 WRITE_COEF(0x11, 0x0041), 5087 WRITE_COEF(0x15, 0x0d40), 5088 WRITE_COEF(0xb7, 0x802b), 5089 {} 5090 }; 5091 static const struct coef_fw coef0274[] = { 5092 WRITE_COEF(0x45, 0x4289), 5093 UPDATE_COEF(0x4a, 0x0010, 0x0010), 5094 UPDATE_COEF(0x6b, 0x0f00, 0), 5095 UPDATE_COEF(0x49, 0x0300, 0x0300), 5096 {} 5097 }; 5098 5099 switch (codec->core.vendor_id) { 5100 case 0x10ec0215: 5101 case 0x10ec0225: 5102 case 0x10ec0285: 5103 case 0x10ec0295: 5104 case 0x10ec0289: 5105 case 0x10ec0299: 5106 alc_process_coef_fw(codec, alc225_pre_hsmode); 5107 alc_process_coef_fw(codec, coef0225); 5108 break; 5109 case 0x10ec0255: 5110 alc_process_coef_fw(codec, coef0255); 5111 break; 5112 case 0x10ec0230: 5113 case 0x10ec0236: 5114 case 0x10ec0256: 5115 alc_write_coef_idx(codec, 0x1b, 0x0e4b); 5116 alc_write_coef_idx(codec, 0x45, 0xc089); 5117 msleep(50); 5118 alc_process_coef_fw(codec, coef0256); 5119 break; 5120 case 0x10ec0234: 5121 case 0x10ec0274: 5122 case 0x10ec0294: 5123 alc_process_coef_fw(codec, coef0274); 5124 break; 5125 case 0x10ec0233: 5126 case 0x10ec0283: 5127 alc_process_coef_fw(codec, coef0233); 5128 break; 5129 case 0x10ec0286: 5130 case 0x10ec0288: 5131 case 0x10ec0298: 5132 alc_process_coef_fw(codec, coef0288); 5133 break; 5134 case 0x10ec0292: 5135 alc_process_coef_fw(codec, coef0292); 5136 break; 5137 case 0x10ec0293: 5138 alc_process_coef_fw(codec, coef0293); 5139 break; 5140 case 0x10ec0668: 5141 alc_process_coef_fw(codec, coef0688); 5142 break; 5143 case 0x10ec0867: 5144 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0); 5145 break; 5146 } 5147 codec_dbg(codec, "Headset jack set to headphone (default) mode.\n"); 5148 } 5149 5150 /* Iphone type */ 5151 static void alc_headset_mode_ctia(struct hda_codec *codec) 5152 { 5153 int val; 5154 5155 static const struct coef_fw coef0255[] = { 5156 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */ 5157 WRITE_COEF(0x1b, 0x0c2b), 5158 WRITE_COEFEX(0x57, 0x03, 0x8ea6), 5159 {} 5160 }; 5161 static const struct coef_fw coef0256[] = { 5162 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */ 5163 WRITE_COEF(0x1b, 0x0e6b), 5164 {} 5165 }; 5166 static const struct coef_fw coef0233[] = { 5167 WRITE_COEF(0x45, 0xd429), 5168 WRITE_COEF(0x1b, 0x0c2b), 5169 WRITE_COEF(0x32, 0x4ea3), 5170 {} 5171 }; 5172 static const struct coef_fw coef0288[] = { 5173 UPDATE_COEF(0x50, 0x2000, 0x2000), 5174 UPDATE_COEF(0x56, 0x0006, 0x0006), 5175 UPDATE_COEF(0x66, 0x0008, 0), 5176 UPDATE_COEF(0x67, 0x2000, 0), 5177 {} 5178 }; 5179 static const struct coef_fw coef0292[] = { 5180 WRITE_COEF(0x6b, 0xd429), 5181 WRITE_COEF(0x76, 0x0008), 5182 WRITE_COEF(0x18, 0x7388), 5183 {} 5184 }; 5185 static const struct coef_fw coef0293[] = { 5186 WRITE_COEF(0x45, 0xd429), /* Set to ctia type */ 5187 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */ 5188 {} 5189 }; 5190 static const struct coef_fw coef0688[] = { 5191 WRITE_COEF(0x11, 0x0001), 5192 WRITE_COEF(0x15, 0x0d60), 5193 WRITE_COEF(0xc3, 0x0000), 5194 {} 5195 }; 5196 static const struct coef_fw coef0225_1[] = { 5197 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10), 5198 UPDATE_COEF(0x63, 3<<14, 2<<14), 5199 {} 5200 }; 5201 static const struct coef_fw coef0225_2[] = { 5202 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10), 5203 UPDATE_COEF(0x63, 3<<14, 1<<14), 5204 {} 5205 }; 5206 5207 switch (codec->core.vendor_id) { 5208 case 0x10ec0255: 5209 alc_process_coef_fw(codec, coef0255); 5210 break; 5211 case 0x10ec0230: 5212 case 0x10ec0236: 5213 case 0x10ec0256: 5214 alc_process_coef_fw(codec, coef0256); 5215 break; 5216 case 0x10ec0234: 5217 case 0x10ec0274: 5218 case 0x10ec0294: 5219 alc_write_coef_idx(codec, 0x45, 0xd689); 5220 break; 5221 case 0x10ec0233: 5222 case 0x10ec0283: 5223 alc_process_coef_fw(codec, coef0233); 5224 break; 5225 case 0x10ec0298: 5226 val = alc_read_coef_idx(codec, 0x50); 5227 if (val & (1 << 12)) { 5228 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020); 5229 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400); 5230 msleep(300); 5231 } else { 5232 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010); 5233 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400); 5234 msleep(300); 5235 } 5236 break; 5237 case 0x10ec0286: 5238 case 0x10ec0288: 5239 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400); 5240 msleep(300); 5241 alc_process_coef_fw(codec, coef0288); 5242 break; 5243 case 0x10ec0292: 5244 alc_process_coef_fw(codec, coef0292); 5245 break; 5246 case 0x10ec0293: 5247 alc_process_coef_fw(codec, coef0293); 5248 break; 5249 case 0x10ec0668: 5250 alc_process_coef_fw(codec, coef0688); 5251 break; 5252 case 0x10ec0215: 5253 case 0x10ec0225: 5254 case 0x10ec0285: 5255 case 0x10ec0295: 5256 case 0x10ec0289: 5257 case 0x10ec0299: 5258 val = alc_read_coef_idx(codec, 0x45); 5259 if (val & (1 << 9)) 5260 alc_process_coef_fw(codec, coef0225_2); 5261 else 5262 alc_process_coef_fw(codec, coef0225_1); 5263 break; 5264 case 0x10ec0867: 5265 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0); 5266 break; 5267 } 5268 codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n"); 5269 } 5270 5271 /* Nokia type */ 5272 static void alc_headset_mode_omtp(struct hda_codec *codec) 5273 { 5274 static const struct coef_fw coef0255[] = { 5275 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */ 5276 WRITE_COEF(0x1b, 0x0c2b), 5277 WRITE_COEFEX(0x57, 0x03, 0x8ea6), 5278 {} 5279 }; 5280 static const struct coef_fw coef0256[] = { 5281 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */ 5282 WRITE_COEF(0x1b, 0x0e6b), 5283 {} 5284 }; 5285 static const struct coef_fw coef0233[] = { 5286 WRITE_COEF(0x45, 0xe429), 5287 WRITE_COEF(0x1b, 0x0c2b), 5288 WRITE_COEF(0x32, 0x4ea3), 5289 {} 5290 }; 5291 static const struct coef_fw coef0288[] = { 5292 UPDATE_COEF(0x50, 0x2000, 0x2000), 5293 UPDATE_COEF(0x56, 0x0006, 0x0006), 5294 UPDATE_COEF(0x66, 0x0008, 0), 5295 UPDATE_COEF(0x67, 0x2000, 0), 5296 {} 5297 }; 5298 static const struct coef_fw coef0292[] = { 5299 WRITE_COEF(0x6b, 0xe429), 5300 WRITE_COEF(0x76, 0x0008), 5301 WRITE_COEF(0x18, 0x7388), 5302 {} 5303 }; 5304 static const struct coef_fw coef0293[] = { 5305 WRITE_COEF(0x45, 0xe429), /* Set to omtp type */ 5306 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */ 5307 {} 5308 }; 5309 static const struct coef_fw coef0688[] = { 5310 WRITE_COEF(0x11, 0x0001), 5311 WRITE_COEF(0x15, 0x0d50), 5312 WRITE_COEF(0xc3, 0x0000), 5313 {} 5314 }; 5315 static const struct coef_fw coef0225[] = { 5316 UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10), 5317 UPDATE_COEF(0x63, 3<<14, 2<<14), 5318 {} 5319 }; 5320 5321 switch (codec->core.vendor_id) { 5322 case 0x10ec0255: 5323 alc_process_coef_fw(codec, coef0255); 5324 break; 5325 case 0x10ec0230: 5326 case 0x10ec0236: 5327 case 0x10ec0256: 5328 alc_process_coef_fw(codec, coef0256); 5329 break; 5330 case 0x10ec0234: 5331 case 0x10ec0274: 5332 case 0x10ec0294: 5333 alc_write_coef_idx(codec, 0x45, 0xe689); 5334 break; 5335 case 0x10ec0233: 5336 case 0x10ec0283: 5337 alc_process_coef_fw(codec, coef0233); 5338 break; 5339 case 0x10ec0298: 5340 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */ 5341 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400); 5342 msleep(300); 5343 break; 5344 case 0x10ec0286: 5345 case 0x10ec0288: 5346 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400); 5347 msleep(300); 5348 alc_process_coef_fw(codec, coef0288); 5349 break; 5350 case 0x10ec0292: 5351 alc_process_coef_fw(codec, coef0292); 5352 break; 5353 case 0x10ec0293: 5354 alc_process_coef_fw(codec, coef0293); 5355 break; 5356 case 0x10ec0668: 5357 alc_process_coef_fw(codec, coef0688); 5358 break; 5359 case 0x10ec0215: 5360 case 0x10ec0225: 5361 case 0x10ec0285: 5362 case 0x10ec0295: 5363 case 0x10ec0289: 5364 case 0x10ec0299: 5365 alc_process_coef_fw(codec, coef0225); 5366 break; 5367 } 5368 codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n"); 5369 } 5370 5371 static void alc_determine_headset_type(struct hda_codec *codec) 5372 { 5373 int val; 5374 bool is_ctia = false; 5375 struct alc_spec *spec = codec->spec; 5376 static const struct coef_fw coef0255[] = { 5377 WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/ 5378 WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref 5379 conteol) */ 5380 {} 5381 }; 5382 static const struct coef_fw coef0288[] = { 5383 UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */ 5384 {} 5385 }; 5386 static const struct coef_fw coef0298[] = { 5387 UPDATE_COEF(0x50, 0x2000, 0x2000), 5388 UPDATE_COEF(0x56, 0x0006, 0x0006), 5389 UPDATE_COEF(0x66, 0x0008, 0), 5390 UPDATE_COEF(0x67, 0x2000, 0), 5391 UPDATE_COEF(0x19, 0x1300, 0x1300), 5392 {} 5393 }; 5394 static const struct coef_fw coef0293[] = { 5395 UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */ 5396 WRITE_COEF(0x45, 0xD429), /* Set to ctia type */ 5397 {} 5398 }; 5399 static const struct coef_fw coef0688[] = { 5400 WRITE_COEF(0x11, 0x0001), 5401 WRITE_COEF(0xb7, 0x802b), 5402 WRITE_COEF(0x15, 0x0d60), 5403 WRITE_COEF(0xc3, 0x0c00), 5404 {} 5405 }; 5406 static const struct coef_fw coef0274[] = { 5407 UPDATE_COEF(0x4a, 0x0010, 0), 5408 UPDATE_COEF(0x4a, 0x8000, 0), 5409 WRITE_COEF(0x45, 0xd289), 5410 UPDATE_COEF(0x49, 0x0300, 0x0300), 5411 {} 5412 }; 5413 5414 if (spec->no_internal_mic_pin) { 5415 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12); 5416 return; 5417 } 5418 5419 switch (codec->core.vendor_id) { 5420 case 0x10ec0255: 5421 alc_process_coef_fw(codec, coef0255); 5422 msleep(300); 5423 val = alc_read_coef_idx(codec, 0x46); 5424 is_ctia = (val & 0x0070) == 0x0070; 5425 break; 5426 case 0x10ec0230: 5427 case 0x10ec0236: 5428 case 0x10ec0256: 5429 alc_write_coef_idx(codec, 0x1b, 0x0e4b); 5430 alc_write_coef_idx(codec, 0x06, 0x6104); 5431 alc_write_coefex_idx(codec, 0x57, 0x3, 0x09a3); 5432 5433 snd_hda_codec_write(codec, 0x21, 0, 5434 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 5435 msleep(80); 5436 snd_hda_codec_write(codec, 0x21, 0, 5437 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 5438 5439 alc_process_coef_fw(codec, coef0255); 5440 msleep(300); 5441 val = alc_read_coef_idx(codec, 0x46); 5442 is_ctia = (val & 0x0070) == 0x0070; 5443 5444 alc_write_coefex_idx(codec, 0x57, 0x3, 0x0da3); 5445 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0); 5446 5447 snd_hda_codec_write(codec, 0x21, 0, 5448 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 5449 msleep(80); 5450 snd_hda_codec_write(codec, 0x21, 0, 5451 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 5452 break; 5453 case 0x10ec0234: 5454 case 0x10ec0274: 5455 case 0x10ec0294: 5456 alc_process_coef_fw(codec, coef0274); 5457 msleep(850); 5458 val = alc_read_coef_idx(codec, 0x46); 5459 is_ctia = (val & 0x00f0) == 0x00f0; 5460 break; 5461 case 0x10ec0233: 5462 case 0x10ec0283: 5463 alc_write_coef_idx(codec, 0x45, 0xd029); 5464 msleep(300); 5465 val = alc_read_coef_idx(codec, 0x46); 5466 is_ctia = (val & 0x0070) == 0x0070; 5467 break; 5468 case 0x10ec0298: 5469 snd_hda_codec_write(codec, 0x21, 0, 5470 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 5471 msleep(100); 5472 snd_hda_codec_write(codec, 0x21, 0, 5473 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 5474 msleep(200); 5475 5476 val = alc_read_coef_idx(codec, 0x50); 5477 if (val & (1 << 12)) { 5478 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020); 5479 alc_process_coef_fw(codec, coef0288); 5480 msleep(350); 5481 val = alc_read_coef_idx(codec, 0x50); 5482 is_ctia = (val & 0x0070) == 0x0070; 5483 } else { 5484 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010); 5485 alc_process_coef_fw(codec, coef0288); 5486 msleep(350); 5487 val = alc_read_coef_idx(codec, 0x50); 5488 is_ctia = (val & 0x0070) == 0x0070; 5489 } 5490 alc_process_coef_fw(codec, coef0298); 5491 snd_hda_codec_write(codec, 0x21, 0, 5492 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP); 5493 msleep(75); 5494 snd_hda_codec_write(codec, 0x21, 0, 5495 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 5496 break; 5497 case 0x10ec0286: 5498 case 0x10ec0288: 5499 alc_process_coef_fw(codec, coef0288); 5500 msleep(350); 5501 val = alc_read_coef_idx(codec, 0x50); 5502 is_ctia = (val & 0x0070) == 0x0070; 5503 break; 5504 case 0x10ec0292: 5505 alc_write_coef_idx(codec, 0x6b, 0xd429); 5506 msleep(300); 5507 val = alc_read_coef_idx(codec, 0x6c); 5508 is_ctia = (val & 0x001c) == 0x001c; 5509 break; 5510 case 0x10ec0293: 5511 alc_process_coef_fw(codec, coef0293); 5512 msleep(300); 5513 val = alc_read_coef_idx(codec, 0x46); 5514 is_ctia = (val & 0x0070) == 0x0070; 5515 break; 5516 case 0x10ec0668: 5517 alc_process_coef_fw(codec, coef0688); 5518 msleep(300); 5519 val = alc_read_coef_idx(codec, 0xbe); 5520 is_ctia = (val & 0x1c02) == 0x1c02; 5521 break; 5522 case 0x10ec0215: 5523 case 0x10ec0225: 5524 case 0x10ec0285: 5525 case 0x10ec0295: 5526 case 0x10ec0289: 5527 case 0x10ec0299: 5528 snd_hda_codec_write(codec, 0x21, 0, 5529 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 5530 msleep(80); 5531 snd_hda_codec_write(codec, 0x21, 0, 5532 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 5533 5534 alc_process_coef_fw(codec, alc225_pre_hsmode); 5535 alc_update_coef_idx(codec, 0x67, 0xf000, 0x1000); 5536 val = alc_read_coef_idx(codec, 0x45); 5537 if (val & (1 << 9)) { 5538 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10); 5539 alc_update_coef_idx(codec, 0x49, 3<<8, 2<<8); 5540 msleep(800); 5541 val = alc_read_coef_idx(codec, 0x46); 5542 is_ctia = (val & 0x00f0) == 0x00f0; 5543 } else { 5544 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10); 5545 alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8); 5546 msleep(800); 5547 val = alc_read_coef_idx(codec, 0x46); 5548 is_ctia = (val & 0x00f0) == 0x00f0; 5549 } 5550 alc_update_coef_idx(codec, 0x4a, 7<<6, 7<<6); 5551 alc_update_coef_idx(codec, 0x4a, 3<<4, 3<<4); 5552 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000); 5553 5554 snd_hda_codec_write(codec, 0x21, 0, 5555 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 5556 msleep(80); 5557 snd_hda_codec_write(codec, 0x21, 0, 5558 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 5559 break; 5560 case 0x10ec0867: 5561 is_ctia = true; 5562 break; 5563 } 5564 5565 codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n", 5566 is_ctia ? "yes" : "no"); 5567 spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP; 5568 } 5569 5570 static void alc_update_headset_mode(struct hda_codec *codec) 5571 { 5572 struct alc_spec *spec = codec->spec; 5573 5574 hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]]; 5575 hda_nid_t hp_pin = alc_get_hp_pin(spec); 5576 5577 int new_headset_mode; 5578 5579 if (!snd_hda_jack_detect(codec, hp_pin)) 5580 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED; 5581 else if (mux_pin == spec->headset_mic_pin) 5582 new_headset_mode = ALC_HEADSET_MODE_HEADSET; 5583 else if (mux_pin == spec->headphone_mic_pin) 5584 new_headset_mode = ALC_HEADSET_MODE_MIC; 5585 else 5586 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE; 5587 5588 if (new_headset_mode == spec->current_headset_mode) { 5589 snd_hda_gen_update_outputs(codec); 5590 return; 5591 } 5592 5593 switch (new_headset_mode) { 5594 case ALC_HEADSET_MODE_UNPLUGGED: 5595 alc_headset_mode_unplugged(codec); 5596 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN; 5597 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN; 5598 spec->gen.hp_jack_present = false; 5599 break; 5600 case ALC_HEADSET_MODE_HEADSET: 5601 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN) 5602 alc_determine_headset_type(codec); 5603 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA) 5604 alc_headset_mode_ctia(codec); 5605 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP) 5606 alc_headset_mode_omtp(codec); 5607 spec->gen.hp_jack_present = true; 5608 break; 5609 case ALC_HEADSET_MODE_MIC: 5610 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin); 5611 spec->gen.hp_jack_present = false; 5612 break; 5613 case ALC_HEADSET_MODE_HEADPHONE: 5614 alc_headset_mode_default(codec); 5615 spec->gen.hp_jack_present = true; 5616 break; 5617 } 5618 if (new_headset_mode != ALC_HEADSET_MODE_MIC) { 5619 snd_hda_set_pin_ctl_cache(codec, hp_pin, 5620 AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN); 5621 if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin) 5622 snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin, 5623 PIN_VREFHIZ); 5624 } 5625 spec->current_headset_mode = new_headset_mode; 5626 5627 snd_hda_gen_update_outputs(codec); 5628 } 5629 5630 static void alc_update_headset_mode_hook(struct hda_codec *codec, 5631 struct snd_kcontrol *kcontrol, 5632 struct snd_ctl_elem_value *ucontrol) 5633 { 5634 alc_update_headset_mode(codec); 5635 } 5636 5637 static void alc_update_headset_jack_cb(struct hda_codec *codec, 5638 struct hda_jack_callback *jack) 5639 { 5640 snd_hda_gen_hp_automute(codec, jack); 5641 alc_update_headset_mode(codec); 5642 } 5643 5644 static void alc_probe_headset_mode(struct hda_codec *codec) 5645 { 5646 int i; 5647 struct alc_spec *spec = codec->spec; 5648 struct auto_pin_cfg *cfg = &spec->gen.autocfg; 5649 5650 /* Find mic pins */ 5651 for (i = 0; i < cfg->num_inputs; i++) { 5652 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin) 5653 spec->headset_mic_pin = cfg->inputs[i].pin; 5654 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin) 5655 spec->headphone_mic_pin = cfg->inputs[i].pin; 5656 } 5657 5658 WARN_ON(spec->gen.cap_sync_hook); 5659 spec->gen.cap_sync_hook = alc_update_headset_mode_hook; 5660 spec->gen.automute_hook = alc_update_headset_mode; 5661 spec->gen.hp_automute_hook = alc_update_headset_jack_cb; 5662 } 5663 5664 static void alc_fixup_headset_mode(struct hda_codec *codec, 5665 const struct hda_fixup *fix, int action) 5666 { 5667 struct alc_spec *spec = codec->spec; 5668 5669 switch (action) { 5670 case HDA_FIXUP_ACT_PRE_PROBE: 5671 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC; 5672 break; 5673 case HDA_FIXUP_ACT_PROBE: 5674 alc_probe_headset_mode(codec); 5675 break; 5676 case HDA_FIXUP_ACT_INIT: 5677 if (is_s3_resume(codec) || is_s4_resume(codec)) { 5678 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN; 5679 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN; 5680 } 5681 alc_update_headset_mode(codec); 5682 break; 5683 } 5684 } 5685 5686 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec, 5687 const struct hda_fixup *fix, int action) 5688 { 5689 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5690 struct alc_spec *spec = codec->spec; 5691 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 5692 } 5693 else 5694 alc_fixup_headset_mode(codec, fix, action); 5695 } 5696 5697 static void alc255_set_default_jack_type(struct hda_codec *codec) 5698 { 5699 /* Set to iphone type */ 5700 static const struct coef_fw alc255fw[] = { 5701 WRITE_COEF(0x1b, 0x880b), 5702 WRITE_COEF(0x45, 0xd089), 5703 WRITE_COEF(0x1b, 0x080b), 5704 WRITE_COEF(0x46, 0x0004), 5705 WRITE_COEF(0x1b, 0x0c0b), 5706 {} 5707 }; 5708 static const struct coef_fw alc256fw[] = { 5709 WRITE_COEF(0x1b, 0x884b), 5710 WRITE_COEF(0x45, 0xd089), 5711 WRITE_COEF(0x1b, 0x084b), 5712 WRITE_COEF(0x46, 0x0004), 5713 WRITE_COEF(0x1b, 0x0c4b), 5714 {} 5715 }; 5716 switch (codec->core.vendor_id) { 5717 case 0x10ec0255: 5718 alc_process_coef_fw(codec, alc255fw); 5719 break; 5720 case 0x10ec0230: 5721 case 0x10ec0236: 5722 case 0x10ec0256: 5723 alc_process_coef_fw(codec, alc256fw); 5724 break; 5725 } 5726 msleep(30); 5727 } 5728 5729 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec, 5730 const struct hda_fixup *fix, int action) 5731 { 5732 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5733 alc255_set_default_jack_type(codec); 5734 } 5735 alc_fixup_headset_mode(codec, fix, action); 5736 } 5737 5738 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec, 5739 const struct hda_fixup *fix, int action) 5740 { 5741 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5742 struct alc_spec *spec = codec->spec; 5743 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 5744 alc255_set_default_jack_type(codec); 5745 } 5746 else 5747 alc_fixup_headset_mode(codec, fix, action); 5748 } 5749 5750 static void alc288_update_headset_jack_cb(struct hda_codec *codec, 5751 struct hda_jack_callback *jack) 5752 { 5753 struct alc_spec *spec = codec->spec; 5754 5755 alc_update_headset_jack_cb(codec, jack); 5756 /* Headset Mic enable or disable, only for Dell Dino */ 5757 alc_update_gpio_data(codec, 0x40, spec->gen.hp_jack_present); 5758 } 5759 5760 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec, 5761 const struct hda_fixup *fix, int action) 5762 { 5763 alc_fixup_headset_mode(codec, fix, action); 5764 if (action == HDA_FIXUP_ACT_PROBE) { 5765 struct alc_spec *spec = codec->spec; 5766 /* toggled via hp_automute_hook */ 5767 spec->gpio_mask |= 0x40; 5768 spec->gpio_dir |= 0x40; 5769 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb; 5770 } 5771 } 5772 5773 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec, 5774 const struct hda_fixup *fix, int action) 5775 { 5776 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5777 struct alc_spec *spec = codec->spec; 5778 spec->gen.auto_mute_via_amp = 1; 5779 } 5780 } 5781 5782 static void alc_fixup_no_shutup(struct hda_codec *codec, 5783 const struct hda_fixup *fix, int action) 5784 { 5785 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5786 struct alc_spec *spec = codec->spec; 5787 spec->no_shutup_pins = 1; 5788 } 5789 } 5790 5791 static void alc_fixup_disable_aamix(struct hda_codec *codec, 5792 const struct hda_fixup *fix, int action) 5793 { 5794 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5795 struct alc_spec *spec = codec->spec; 5796 /* Disable AA-loopback as it causes white noise */ 5797 spec->gen.mixer_nid = 0; 5798 } 5799 } 5800 5801 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */ 5802 static void alc_fixup_tpt440_dock(struct hda_codec *codec, 5803 const struct hda_fixup *fix, int action) 5804 { 5805 static const struct hda_pintbl pincfgs[] = { 5806 { 0x16, 0x21211010 }, /* dock headphone */ 5807 { 0x19, 0x21a11010 }, /* dock mic */ 5808 { } 5809 }; 5810 struct alc_spec *spec = codec->spec; 5811 5812 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5813 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 5814 codec->power_save_node = 0; /* avoid click noises */ 5815 snd_hda_apply_pincfgs(codec, pincfgs); 5816 } 5817 } 5818 5819 static void alc_fixup_tpt470_dock(struct hda_codec *codec, 5820 const struct hda_fixup *fix, int action) 5821 { 5822 static const struct hda_pintbl pincfgs[] = { 5823 { 0x17, 0x21211010 }, /* dock headphone */ 5824 { 0x19, 0x21a11010 }, /* dock mic */ 5825 { } 5826 }; 5827 struct alc_spec *spec = codec->spec; 5828 5829 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5830 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 5831 snd_hda_apply_pincfgs(codec, pincfgs); 5832 } else if (action == HDA_FIXUP_ACT_INIT) { 5833 /* Enable DOCK device */ 5834 snd_hda_codec_write(codec, 0x17, 0, 5835 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0); 5836 /* Enable DOCK device */ 5837 snd_hda_codec_write(codec, 0x19, 0, 5838 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0); 5839 } 5840 } 5841 5842 static void alc_fixup_tpt470_dacs(struct hda_codec *codec, 5843 const struct hda_fixup *fix, int action) 5844 { 5845 /* Assure the speaker pin to be coupled with DAC NID 0x03; otherwise 5846 * the speaker output becomes too low by some reason on Thinkpads with 5847 * ALC298 codec 5848 */ 5849 static const hda_nid_t preferred_pairs[] = { 5850 0x14, 0x03, 0x17, 0x02, 0x21, 0x02, 5851 0 5852 }; 5853 struct alc_spec *spec = codec->spec; 5854 5855 if (action == HDA_FIXUP_ACT_PRE_PROBE) 5856 spec->gen.preferred_dacs = preferred_pairs; 5857 } 5858 5859 static void alc295_fixup_asus_dacs(struct hda_codec *codec, 5860 const struct hda_fixup *fix, int action) 5861 { 5862 static const hda_nid_t preferred_pairs[] = { 5863 0x17, 0x02, 0x21, 0x03, 0 5864 }; 5865 struct alc_spec *spec = codec->spec; 5866 5867 if (action == HDA_FIXUP_ACT_PRE_PROBE) 5868 spec->gen.preferred_dacs = preferred_pairs; 5869 } 5870 5871 static void alc_shutup_dell_xps13(struct hda_codec *codec) 5872 { 5873 struct alc_spec *spec = codec->spec; 5874 int hp_pin = alc_get_hp_pin(spec); 5875 5876 /* Prevent pop noises when headphones are plugged in */ 5877 snd_hda_codec_write(codec, hp_pin, 0, 5878 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 5879 msleep(20); 5880 } 5881 5882 static void alc_fixup_dell_xps13(struct hda_codec *codec, 5883 const struct hda_fixup *fix, int action) 5884 { 5885 struct alc_spec *spec = codec->spec; 5886 struct hda_input_mux *imux = &spec->gen.input_mux; 5887 int i; 5888 5889 switch (action) { 5890 case HDA_FIXUP_ACT_PRE_PROBE: 5891 /* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise 5892 * it causes a click noise at start up 5893 */ 5894 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ); 5895 spec->shutup = alc_shutup_dell_xps13; 5896 break; 5897 case HDA_FIXUP_ACT_PROBE: 5898 /* Make the internal mic the default input source. */ 5899 for (i = 0; i < imux->num_items; i++) { 5900 if (spec->gen.imux_pins[i] == 0x12) { 5901 spec->gen.cur_mux[0] = i; 5902 break; 5903 } 5904 } 5905 break; 5906 } 5907 } 5908 5909 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec, 5910 const struct hda_fixup *fix, int action) 5911 { 5912 struct alc_spec *spec = codec->spec; 5913 5914 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5915 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 5916 spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */ 5917 5918 /* Disable boost for mic-in permanently. (This code is only called 5919 from quirks that guarantee that the headphone is at NID 0x1b.) */ 5920 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000); 5921 snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP); 5922 } else 5923 alc_fixup_headset_mode(codec, fix, action); 5924 } 5925 5926 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec, 5927 const struct hda_fixup *fix, int action) 5928 { 5929 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 5930 alc_write_coef_idx(codec, 0xc4, 0x8000); 5931 alc_update_coef_idx(codec, 0xc2, ~0xfe, 0); 5932 snd_hda_set_pin_ctl_cache(codec, 0x18, 0); 5933 } 5934 alc_fixup_headset_mode(codec, fix, action); 5935 } 5936 5937 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */ 5938 static int find_ext_mic_pin(struct hda_codec *codec) 5939 { 5940 struct alc_spec *spec = codec->spec; 5941 struct auto_pin_cfg *cfg = &spec->gen.autocfg; 5942 hda_nid_t nid; 5943 unsigned int defcfg; 5944 int i; 5945 5946 for (i = 0; i < cfg->num_inputs; i++) { 5947 if (cfg->inputs[i].type != AUTO_PIN_MIC) 5948 continue; 5949 nid = cfg->inputs[i].pin; 5950 defcfg = snd_hda_codec_get_pincfg(codec, nid); 5951 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT) 5952 continue; 5953 return nid; 5954 } 5955 5956 return 0; 5957 } 5958 5959 static void alc271_hp_gate_mic_jack(struct hda_codec *codec, 5960 const struct hda_fixup *fix, 5961 int action) 5962 { 5963 struct alc_spec *spec = codec->spec; 5964 5965 if (action == HDA_FIXUP_ACT_PROBE) { 5966 int mic_pin = find_ext_mic_pin(codec); 5967 int hp_pin = alc_get_hp_pin(spec); 5968 5969 if (snd_BUG_ON(!mic_pin || !hp_pin)) 5970 return; 5971 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin); 5972 } 5973 } 5974 5975 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec, 5976 const struct hda_fixup *fix, 5977 int action) 5978 { 5979 struct alc_spec *spec = codec->spec; 5980 struct auto_pin_cfg *cfg = &spec->gen.autocfg; 5981 int i; 5982 5983 /* The mic boosts on level 2 and 3 are too noisy 5984 on the internal mic input. 5985 Therefore limit the boost to 0 or 1. */ 5986 5987 if (action != HDA_FIXUP_ACT_PROBE) 5988 return; 5989 5990 for (i = 0; i < cfg->num_inputs; i++) { 5991 hda_nid_t nid = cfg->inputs[i].pin; 5992 unsigned int defcfg; 5993 if (cfg->inputs[i].type != AUTO_PIN_MIC) 5994 continue; 5995 defcfg = snd_hda_codec_get_pincfg(codec, nid); 5996 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT) 5997 continue; 5998 5999 snd_hda_override_amp_caps(codec, nid, HDA_INPUT, 6000 (0x00 << AC_AMPCAP_OFFSET_SHIFT) | 6001 (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) | 6002 (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) | 6003 (0 << AC_AMPCAP_MUTE_SHIFT)); 6004 } 6005 } 6006 6007 static void alc283_hp_automute_hook(struct hda_codec *codec, 6008 struct hda_jack_callback *jack) 6009 { 6010 struct alc_spec *spec = codec->spec; 6011 int vref; 6012 6013 msleep(200); 6014 snd_hda_gen_hp_automute(codec, jack); 6015 6016 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0; 6017 6018 msleep(600); 6019 snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 6020 vref); 6021 } 6022 6023 static void alc283_fixup_chromebook(struct hda_codec *codec, 6024 const struct hda_fixup *fix, int action) 6025 { 6026 struct alc_spec *spec = codec->spec; 6027 6028 switch (action) { 6029 case HDA_FIXUP_ACT_PRE_PROBE: 6030 snd_hda_override_wcaps(codec, 0x03, 0); 6031 /* Disable AA-loopback as it causes white noise */ 6032 spec->gen.mixer_nid = 0; 6033 break; 6034 case HDA_FIXUP_ACT_INIT: 6035 /* MIC2-VREF control */ 6036 /* Set to manual mode */ 6037 alc_update_coef_idx(codec, 0x06, 0x000c, 0); 6038 /* Enable Line1 input control by verb */ 6039 alc_update_coef_idx(codec, 0x1a, 0, 1 << 4); 6040 break; 6041 } 6042 } 6043 6044 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec, 6045 const struct hda_fixup *fix, int action) 6046 { 6047 struct alc_spec *spec = codec->spec; 6048 6049 switch (action) { 6050 case HDA_FIXUP_ACT_PRE_PROBE: 6051 spec->gen.hp_automute_hook = alc283_hp_automute_hook; 6052 break; 6053 case HDA_FIXUP_ACT_INIT: 6054 /* MIC2-VREF control */ 6055 /* Set to manual mode */ 6056 alc_update_coef_idx(codec, 0x06, 0x000c, 0); 6057 break; 6058 } 6059 } 6060 6061 /* mute tablet speaker pin (0x14) via dock plugging in addition */ 6062 static void asus_tx300_automute(struct hda_codec *codec) 6063 { 6064 struct alc_spec *spec = codec->spec; 6065 snd_hda_gen_update_outputs(codec); 6066 if (snd_hda_jack_detect(codec, 0x1b)) 6067 spec->gen.mute_bits |= (1ULL << 0x14); 6068 } 6069 6070 static void alc282_fixup_asus_tx300(struct hda_codec *codec, 6071 const struct hda_fixup *fix, int action) 6072 { 6073 struct alc_spec *spec = codec->spec; 6074 static const struct hda_pintbl dock_pins[] = { 6075 { 0x1b, 0x21114000 }, /* dock speaker pin */ 6076 {} 6077 }; 6078 6079 switch (action) { 6080 case HDA_FIXUP_ACT_PRE_PROBE: 6081 spec->init_amp = ALC_INIT_DEFAULT; 6082 /* TX300 needs to set up GPIO2 for the speaker amp */ 6083 alc_setup_gpio(codec, 0x04); 6084 snd_hda_apply_pincfgs(codec, dock_pins); 6085 spec->gen.auto_mute_via_amp = 1; 6086 spec->gen.automute_hook = asus_tx300_automute; 6087 snd_hda_jack_detect_enable_callback(codec, 0x1b, 6088 snd_hda_gen_hp_automute); 6089 break; 6090 case HDA_FIXUP_ACT_PROBE: 6091 spec->init_amp = ALC_INIT_DEFAULT; 6092 break; 6093 case HDA_FIXUP_ACT_BUILD: 6094 /* this is a bit tricky; give more sane names for the main 6095 * (tablet) speaker and the dock speaker, respectively 6096 */ 6097 rename_ctl(codec, "Speaker Playback Switch", 6098 "Dock Speaker Playback Switch"); 6099 rename_ctl(codec, "Bass Speaker Playback Switch", 6100 "Speaker Playback Switch"); 6101 break; 6102 } 6103 } 6104 6105 static void alc290_fixup_mono_speakers(struct hda_codec *codec, 6106 const struct hda_fixup *fix, int action) 6107 { 6108 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6109 /* DAC node 0x03 is giving mono output. We therefore want to 6110 make sure 0x14 (front speaker) and 0x15 (headphones) use the 6111 stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */ 6112 static const hda_nid_t conn1[] = { 0x0c }; 6113 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1); 6114 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1); 6115 } 6116 } 6117 6118 static void alc298_fixup_speaker_volume(struct hda_codec *codec, 6119 const struct hda_fixup *fix, int action) 6120 { 6121 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6122 /* The speaker is routed to the Node 0x06 by a mistake, as a result 6123 we can't adjust the speaker's volume since this node does not has 6124 Amp-out capability. we change the speaker's route to: 6125 Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 ( 6126 Pin Complex), since Node 0x02 has Amp-out caps, we can adjust 6127 speaker's volume now. */ 6128 6129 static const hda_nid_t conn1[] = { 0x0c }; 6130 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn1), conn1); 6131 } 6132 } 6133 6134 /* disable DAC3 (0x06) selection on NID 0x17 as it has no volume amp control */ 6135 static void alc295_fixup_disable_dac3(struct hda_codec *codec, 6136 const struct hda_fixup *fix, int action) 6137 { 6138 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6139 static const hda_nid_t conn[] = { 0x02, 0x03 }; 6140 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 6141 } 6142 } 6143 6144 /* force NID 0x17 (Bass Speaker) to DAC1 to share it with the main speaker */ 6145 static void alc285_fixup_speaker2_to_dac1(struct hda_codec *codec, 6146 const struct hda_fixup *fix, int action) 6147 { 6148 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6149 static const hda_nid_t conn[] = { 0x02 }; 6150 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 6151 } 6152 } 6153 6154 /* Hook to update amp GPIO4 for automute */ 6155 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec, 6156 struct hda_jack_callback *jack) 6157 { 6158 struct alc_spec *spec = codec->spec; 6159 6160 snd_hda_gen_hp_automute(codec, jack); 6161 /* mute_led_polarity is set to 0, so we pass inverted value here */ 6162 alc_update_gpio_led(codec, 0x10, spec->mute_led_polarity, 6163 !spec->gen.hp_jack_present); 6164 } 6165 6166 /* Manage GPIOs for HP EliteBook Folio 9480m. 6167 * 6168 * GPIO4 is the headphone amplifier power control 6169 * GPIO3 is the audio output mute indicator LED 6170 */ 6171 6172 static void alc280_fixup_hp_9480m(struct hda_codec *codec, 6173 const struct hda_fixup *fix, 6174 int action) 6175 { 6176 struct alc_spec *spec = codec->spec; 6177 6178 alc_fixup_hp_gpio_led(codec, action, 0x08, 0); 6179 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6180 /* amp at GPIO4; toggled via alc280_hp_gpio4_automute_hook() */ 6181 spec->gpio_mask |= 0x10; 6182 spec->gpio_dir |= 0x10; 6183 spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook; 6184 } 6185 } 6186 6187 static void alc275_fixup_gpio4_off(struct hda_codec *codec, 6188 const struct hda_fixup *fix, 6189 int action) 6190 { 6191 struct alc_spec *spec = codec->spec; 6192 6193 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6194 spec->gpio_mask |= 0x04; 6195 spec->gpio_dir |= 0x04; 6196 /* set data bit low */ 6197 } 6198 } 6199 6200 /* Quirk for Thinkpad X1 7th and 8th Gen 6201 * The following fixed routing needed 6202 * DAC1 (NID 0x02) -> Speaker (NID 0x14); some eq applied secretly 6203 * DAC2 (NID 0x03) -> Bass (NID 0x17) & Headphone (NID 0x21); sharing a DAC 6204 * DAC3 (NID 0x06) -> Unused, due to the lack of volume amp 6205 */ 6206 static void alc285_fixup_thinkpad_x1_gen7(struct hda_codec *codec, 6207 const struct hda_fixup *fix, int action) 6208 { 6209 static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */ 6210 static const hda_nid_t preferred_pairs[] = { 6211 0x14, 0x02, 0x17, 0x03, 0x21, 0x03, 0 6212 }; 6213 struct alc_spec *spec = codec->spec; 6214 6215 switch (action) { 6216 case HDA_FIXUP_ACT_PRE_PROBE: 6217 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 6218 spec->gen.preferred_dacs = preferred_pairs; 6219 break; 6220 case HDA_FIXUP_ACT_BUILD: 6221 /* The generic parser creates somewhat unintuitive volume ctls 6222 * with the fixed routing above, and the shared DAC2 may be 6223 * confusing for PA. 6224 * Rename those to unique names so that PA doesn't touch them 6225 * and use only Master volume. 6226 */ 6227 rename_ctl(codec, "Front Playback Volume", "DAC1 Playback Volume"); 6228 rename_ctl(codec, "Bass Speaker Playback Volume", "DAC2 Playback Volume"); 6229 break; 6230 } 6231 } 6232 6233 static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec, 6234 const struct hda_fixup *fix, 6235 int action) 6236 { 6237 alc_fixup_dual_codecs(codec, fix, action); 6238 switch (action) { 6239 case HDA_FIXUP_ACT_PRE_PROBE: 6240 /* override card longname to provide a unique UCM profile */ 6241 strcpy(codec->card->longname, "HDAudio-Lenovo-DualCodecs"); 6242 break; 6243 case HDA_FIXUP_ACT_BUILD: 6244 /* rename Capture controls depending on the codec */ 6245 rename_ctl(codec, "Capture Volume", 6246 codec->addr == 0 ? 6247 "Rear-Panel Capture Volume" : 6248 "Front-Panel Capture Volume"); 6249 rename_ctl(codec, "Capture Switch", 6250 codec->addr == 0 ? 6251 "Rear-Panel Capture Switch" : 6252 "Front-Panel Capture Switch"); 6253 break; 6254 } 6255 } 6256 6257 static void alc225_fixup_s3_pop_noise(struct hda_codec *codec, 6258 const struct hda_fixup *fix, int action) 6259 { 6260 if (action != HDA_FIXUP_ACT_PRE_PROBE) 6261 return; 6262 6263 codec->power_save_node = 1; 6264 } 6265 6266 /* Forcibly assign NID 0x03 to HP/LO while NID 0x02 to SPK for EQ */ 6267 static void alc274_fixup_bind_dacs(struct hda_codec *codec, 6268 const struct hda_fixup *fix, int action) 6269 { 6270 struct alc_spec *spec = codec->spec; 6271 static const hda_nid_t preferred_pairs[] = { 6272 0x21, 0x03, 0x1b, 0x03, 0x16, 0x02, 6273 0 6274 }; 6275 6276 if (action != HDA_FIXUP_ACT_PRE_PROBE) 6277 return; 6278 6279 spec->gen.preferred_dacs = preferred_pairs; 6280 spec->gen.auto_mute_via_amp = 1; 6281 codec->power_save_node = 0; 6282 } 6283 6284 /* avoid DAC 0x06 for bass speaker 0x17; it has no volume control */ 6285 static void alc289_fixup_asus_ga401(struct hda_codec *codec, 6286 const struct hda_fixup *fix, int action) 6287 { 6288 static const hda_nid_t preferred_pairs[] = { 6289 0x14, 0x02, 0x17, 0x02, 0x21, 0x03, 0 6290 }; 6291 struct alc_spec *spec = codec->spec; 6292 6293 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6294 spec->gen.preferred_dacs = preferred_pairs; 6295 spec->gen.obey_preferred_dacs = 1; 6296 } 6297 } 6298 6299 /* The DAC of NID 0x3 will introduce click/pop noise on headphones, so invalidate it */ 6300 static void alc285_fixup_invalidate_dacs(struct hda_codec *codec, 6301 const struct hda_fixup *fix, int action) 6302 { 6303 if (action != HDA_FIXUP_ACT_PRE_PROBE) 6304 return; 6305 6306 snd_hda_override_wcaps(codec, 0x03, 0); 6307 } 6308 6309 static void alc_combo_jack_hp_jd_restart(struct hda_codec *codec) 6310 { 6311 switch (codec->core.vendor_id) { 6312 case 0x10ec0274: 6313 case 0x10ec0294: 6314 case 0x10ec0225: 6315 case 0x10ec0295: 6316 case 0x10ec0299: 6317 alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */ 6318 alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15); 6319 break; 6320 case 0x10ec0230: 6321 case 0x10ec0235: 6322 case 0x10ec0236: 6323 case 0x10ec0255: 6324 case 0x10ec0256: 6325 alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */ 6326 alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15); 6327 break; 6328 } 6329 } 6330 6331 static void alc295_fixup_chromebook(struct hda_codec *codec, 6332 const struct hda_fixup *fix, int action) 6333 { 6334 struct alc_spec *spec = codec->spec; 6335 6336 switch (action) { 6337 case HDA_FIXUP_ACT_PRE_PROBE: 6338 spec->ultra_low_power = true; 6339 break; 6340 case HDA_FIXUP_ACT_INIT: 6341 alc_combo_jack_hp_jd_restart(codec); 6342 break; 6343 } 6344 } 6345 6346 static void alc_fixup_disable_mic_vref(struct hda_codec *codec, 6347 const struct hda_fixup *fix, int action) 6348 { 6349 if (action == HDA_FIXUP_ACT_PRE_PROBE) 6350 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ); 6351 } 6352 6353 6354 static void alc294_gx502_toggle_output(struct hda_codec *codec, 6355 struct hda_jack_callback *cb) 6356 { 6357 /* The Windows driver sets the codec up in a very different way where 6358 * it appears to leave 0x10 = 0x8a20 set. For Linux we need to toggle it 6359 */ 6360 if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT) 6361 alc_write_coef_idx(codec, 0x10, 0x8a20); 6362 else 6363 alc_write_coef_idx(codec, 0x10, 0x0a20); 6364 } 6365 6366 static void alc294_fixup_gx502_hp(struct hda_codec *codec, 6367 const struct hda_fixup *fix, int action) 6368 { 6369 /* Pin 0x21: headphones/headset mic */ 6370 if (!is_jack_detectable(codec, 0x21)) 6371 return; 6372 6373 switch (action) { 6374 case HDA_FIXUP_ACT_PRE_PROBE: 6375 snd_hda_jack_detect_enable_callback(codec, 0x21, 6376 alc294_gx502_toggle_output); 6377 break; 6378 case HDA_FIXUP_ACT_INIT: 6379 /* Make sure to start in a correct state, i.e. if 6380 * headphones have been plugged in before powering up the system 6381 */ 6382 alc294_gx502_toggle_output(codec, NULL); 6383 break; 6384 } 6385 } 6386 6387 static void alc294_gu502_toggle_output(struct hda_codec *codec, 6388 struct hda_jack_callback *cb) 6389 { 6390 /* Windows sets 0x10 to 0x8420 for Node 0x20 which is 6391 * responsible from changes between speakers and headphones 6392 */ 6393 if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT) 6394 alc_write_coef_idx(codec, 0x10, 0x8420); 6395 else 6396 alc_write_coef_idx(codec, 0x10, 0x0a20); 6397 } 6398 6399 static void alc294_fixup_gu502_hp(struct hda_codec *codec, 6400 const struct hda_fixup *fix, int action) 6401 { 6402 if (!is_jack_detectable(codec, 0x21)) 6403 return; 6404 6405 switch (action) { 6406 case HDA_FIXUP_ACT_PRE_PROBE: 6407 snd_hda_jack_detect_enable_callback(codec, 0x21, 6408 alc294_gu502_toggle_output); 6409 break; 6410 case HDA_FIXUP_ACT_INIT: 6411 alc294_gu502_toggle_output(codec, NULL); 6412 break; 6413 } 6414 } 6415 6416 static void alc285_fixup_hp_gpio_amp_init(struct hda_codec *codec, 6417 const struct hda_fixup *fix, int action) 6418 { 6419 if (action != HDA_FIXUP_ACT_INIT) 6420 return; 6421 6422 msleep(100); 6423 alc_write_coef_idx(codec, 0x65, 0x0); 6424 } 6425 6426 static void alc274_fixup_hp_headset_mic(struct hda_codec *codec, 6427 const struct hda_fixup *fix, int action) 6428 { 6429 switch (action) { 6430 case HDA_FIXUP_ACT_INIT: 6431 alc_combo_jack_hp_jd_restart(codec); 6432 break; 6433 } 6434 } 6435 6436 static void alc_fixup_no_int_mic(struct hda_codec *codec, 6437 const struct hda_fixup *fix, int action) 6438 { 6439 struct alc_spec *spec = codec->spec; 6440 6441 switch (action) { 6442 case HDA_FIXUP_ACT_PRE_PROBE: 6443 /* Mic RING SLEEVE swap for combo jack */ 6444 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12); 6445 spec->no_internal_mic_pin = true; 6446 break; 6447 case HDA_FIXUP_ACT_INIT: 6448 alc_combo_jack_hp_jd_restart(codec); 6449 break; 6450 } 6451 } 6452 6453 /* GPIO1 = amplifier on/off 6454 * GPIO3 = mic mute LED 6455 */ 6456 static void alc285_fixup_hp_spectre_x360_eb1(struct hda_codec *codec, 6457 const struct hda_fixup *fix, int action) 6458 { 6459 static const hda_nid_t conn[] = { 0x02 }; 6460 6461 struct alc_spec *spec = codec->spec; 6462 static const struct hda_pintbl pincfgs[] = { 6463 { 0x14, 0x90170110 }, /* front/high speakers */ 6464 { 0x17, 0x90170130 }, /* back/bass speakers */ 6465 { } 6466 }; 6467 6468 //enable micmute led 6469 alc_fixup_hp_gpio_led(codec, action, 0x00, 0x04); 6470 6471 switch (action) { 6472 case HDA_FIXUP_ACT_PRE_PROBE: 6473 spec->micmute_led_polarity = 1; 6474 /* needed for amp of back speakers */ 6475 spec->gpio_mask |= 0x01; 6476 spec->gpio_dir |= 0x01; 6477 snd_hda_apply_pincfgs(codec, pincfgs); 6478 /* share DAC to have unified volume control */ 6479 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn); 6480 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 6481 break; 6482 case HDA_FIXUP_ACT_INIT: 6483 /* need to toggle GPIO to enable the amp of back speakers */ 6484 alc_update_gpio_data(codec, 0x01, true); 6485 msleep(100); 6486 alc_update_gpio_data(codec, 0x01, false); 6487 break; 6488 } 6489 } 6490 6491 static void alc285_fixup_hp_spectre_x360(struct hda_codec *codec, 6492 const struct hda_fixup *fix, int action) 6493 { 6494 static const hda_nid_t conn[] = { 0x02 }; 6495 static const struct hda_pintbl pincfgs[] = { 6496 { 0x14, 0x90170110 }, /* rear speaker */ 6497 { } 6498 }; 6499 6500 switch (action) { 6501 case HDA_FIXUP_ACT_PRE_PROBE: 6502 snd_hda_apply_pincfgs(codec, pincfgs); 6503 /* force front speaker to DAC1 */ 6504 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn); 6505 break; 6506 } 6507 } 6508 6509 /* for hda_fixup_thinkpad_acpi() */ 6510 #include "thinkpad_helper.c" 6511 6512 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec, 6513 const struct hda_fixup *fix, int action) 6514 { 6515 alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */ 6516 hda_fixup_thinkpad_acpi(codec, fix, action); 6517 } 6518 6519 /* Fixup for Lenovo Legion 15IMHg05 speaker output on headset removal. */ 6520 static void alc287_fixup_legion_15imhg05_speakers(struct hda_codec *codec, 6521 const struct hda_fixup *fix, 6522 int action) 6523 { 6524 struct alc_spec *spec = codec->spec; 6525 6526 switch (action) { 6527 case HDA_FIXUP_ACT_PRE_PROBE: 6528 spec->gen.suppress_auto_mute = 1; 6529 break; 6530 } 6531 } 6532 6533 static int comp_match_dev_name(struct device *dev, void *data) 6534 { 6535 return strcmp(dev_name(dev), data) == 0; 6536 } 6537 6538 static int find_comp_by_dev_name(struct alc_spec *spec, const char *name) 6539 { 6540 int i; 6541 6542 for (i = 0; i < HDA_MAX_COMPONENTS; i++) { 6543 if (strcmp(spec->comps[i].name, name) == 0) 6544 return i; 6545 } 6546 6547 return -ENODEV; 6548 } 6549 6550 static int comp_bind(struct device *dev) 6551 { 6552 struct hda_codec *cdc = dev_to_hda_codec(dev); 6553 struct alc_spec *spec = cdc->spec; 6554 6555 return component_bind_all(dev, spec->comps); 6556 } 6557 6558 static void comp_unbind(struct device *dev) 6559 { 6560 struct hda_codec *cdc = dev_to_hda_codec(dev); 6561 struct alc_spec *spec = cdc->spec; 6562 6563 component_unbind_all(dev, spec->comps); 6564 } 6565 6566 static const struct component_master_ops comp_master_ops = { 6567 .bind = comp_bind, 6568 .unbind = comp_unbind, 6569 }; 6570 6571 static void comp_generic_playback_hook(struct hda_pcm_stream *hinfo, struct hda_codec *cdc, 6572 struct snd_pcm_substream *sub, int action) 6573 { 6574 struct alc_spec *spec = cdc->spec; 6575 int i; 6576 6577 for (i = 0; i < HDA_MAX_COMPONENTS; i++) { 6578 if (spec->comps[i].dev) 6579 spec->comps[i].playback_hook(spec->comps[i].dev, action); 6580 } 6581 } 6582 6583 static void cs35l41_generic_fixup(struct hda_codec *cdc, int action, const char *bus, 6584 const char *hid, int count) 6585 { 6586 struct device *dev = hda_codec_dev(cdc); 6587 struct alc_spec *spec = cdc->spec; 6588 char *name; 6589 int ret, i; 6590 6591 switch (action) { 6592 case HDA_FIXUP_ACT_PRE_PROBE: 6593 for (i = 0; i < count; i++) { 6594 name = devm_kasprintf(dev, GFP_KERNEL, 6595 "%s-%s:00-cs35l41-hda.%d", bus, hid, i); 6596 if (!name) 6597 return; 6598 component_match_add(dev, &spec->match, comp_match_dev_name, name); 6599 } 6600 ret = component_master_add_with_match(dev, &comp_master_ops, spec->match); 6601 if (ret) 6602 codec_err(cdc, "Fail to register component aggregator %d\n", ret); 6603 else 6604 spec->gen.pcm_playback_hook = comp_generic_playback_hook; 6605 break; 6606 } 6607 } 6608 6609 static void cs35l41_fixup_i2c_two(struct hda_codec *cdc, const struct hda_fixup *fix, int action) 6610 { 6611 cs35l41_generic_fixup(cdc, action, "i2c", "CSC3551", 2); 6612 } 6613 6614 static void alc287_legion_16achg6_playback_hook(struct hda_pcm_stream *hinfo, struct hda_codec *cdc, 6615 struct snd_pcm_substream *sub, int action) 6616 { 6617 struct alc_spec *spec = cdc->spec; 6618 unsigned int rx_slot; 6619 int i; 6620 6621 switch (action) { 6622 case HDA_GEN_PCM_ACT_PREPARE: 6623 rx_slot = 0; 6624 i = find_comp_by_dev_name(spec, "i2c-CLSA0100:00-cs35l41-hda.0"); 6625 if (i >= 0) 6626 spec->comps[i].set_channel_map(spec->comps[i].dev, 0, NULL, 1, &rx_slot); 6627 6628 rx_slot = 1; 6629 i = find_comp_by_dev_name(spec, "i2c-CLSA0100:00-cs35l41-hda.1"); 6630 if (i >= 0) 6631 spec->comps[i].set_channel_map(spec->comps[i].dev, 0, NULL, 1, &rx_slot); 6632 break; 6633 } 6634 6635 comp_generic_playback_hook(hinfo, cdc, sub, action); 6636 } 6637 6638 static void alc287_fixup_legion_16achg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix, 6639 int action) 6640 { 6641 struct device *dev = hda_codec_dev(cdc); 6642 struct alc_spec *spec = cdc->spec; 6643 int ret; 6644 6645 switch (action) { 6646 case HDA_FIXUP_ACT_PRE_PROBE: 6647 component_match_add(dev, &spec->match, comp_match_dev_name, 6648 "i2c-CLSA0100:00-cs35l41-hda.0"); 6649 component_match_add(dev, &spec->match, comp_match_dev_name, 6650 "i2c-CLSA0100:00-cs35l41-hda.1"); 6651 ret = component_master_add_with_match(dev, &comp_master_ops, spec->match); 6652 if (ret) 6653 codec_err(cdc, "Fail to register component aggregator %d\n", ret); 6654 else 6655 spec->gen.pcm_playback_hook = alc287_legion_16achg6_playback_hook; 6656 break; 6657 } 6658 } 6659 6660 /* for alc295_fixup_hp_top_speakers */ 6661 #include "hp_x360_helper.c" 6662 6663 /* for alc285_fixup_ideapad_s740_coef() */ 6664 #include "ideapad_s740_helper.c" 6665 6666 static const struct coef_fw alc256_fixup_set_coef_defaults_coefs[] = { 6667 WRITE_COEF(0x10, 0x0020), WRITE_COEF(0x24, 0x0000), 6668 WRITE_COEF(0x26, 0x0000), WRITE_COEF(0x29, 0x3000), 6669 WRITE_COEF(0x37, 0xfe05), WRITE_COEF(0x45, 0x5089), 6670 {} 6671 }; 6672 6673 static void alc256_fixup_set_coef_defaults(struct hda_codec *codec, 6674 const struct hda_fixup *fix, 6675 int action) 6676 { 6677 /* 6678 * A certain other OS sets these coeffs to different values. On at least 6679 * one TongFang barebone these settings might survive even a cold 6680 * reboot. So to restore a clean slate the values are explicitly reset 6681 * to default here. Without this, the external microphone is always in a 6682 * plugged-in state, while the internal microphone is always in an 6683 * unplugged state, breaking the ability to use the internal microphone. 6684 */ 6685 alc_process_coef_fw(codec, alc256_fixup_set_coef_defaults_coefs); 6686 } 6687 6688 static const struct coef_fw alc233_fixup_no_audio_jack_coefs[] = { 6689 WRITE_COEF(0x1a, 0x9003), WRITE_COEF(0x1b, 0x0e2b), WRITE_COEF(0x37, 0xfe06), 6690 WRITE_COEF(0x38, 0x4981), WRITE_COEF(0x45, 0xd489), WRITE_COEF(0x46, 0x0074), 6691 WRITE_COEF(0x49, 0x0149), 6692 {} 6693 }; 6694 6695 static void alc233_fixup_no_audio_jack(struct hda_codec *codec, 6696 const struct hda_fixup *fix, 6697 int action) 6698 { 6699 /* 6700 * The audio jack input and output is not detected on the ASRock NUC Box 6701 * 1100 series when cold booting without this fix. Warm rebooting from a 6702 * certain other OS makes the audio functional, as COEF settings are 6703 * preserved in this case. This fix sets these altered COEF values as 6704 * the default. 6705 */ 6706 alc_process_coef_fw(codec, alc233_fixup_no_audio_jack_coefs); 6707 } 6708 6709 static void alc256_fixup_mic_no_presence_and_resume(struct hda_codec *codec, 6710 const struct hda_fixup *fix, 6711 int action) 6712 { 6713 /* 6714 * The Clevo NJ51CU comes either with the ALC293 or the ALC256 codec, 6715 * but uses the 0x8686 subproduct id in both cases. The ALC256 codec 6716 * needs an additional quirk for sound working after suspend and resume. 6717 */ 6718 if (codec->core.vendor_id == 0x10ec0256) { 6719 alc_update_coef_idx(codec, 0x10, 1<<9, 0); 6720 snd_hda_codec_set_pincfg(codec, 0x19, 0x04a11120); 6721 } else { 6722 snd_hda_codec_set_pincfg(codec, 0x1a, 0x04a1113c); 6723 } 6724 } 6725 6726 enum { 6727 ALC269_FIXUP_GPIO2, 6728 ALC269_FIXUP_SONY_VAIO, 6729 ALC275_FIXUP_SONY_VAIO_GPIO2, 6730 ALC269_FIXUP_DELL_M101Z, 6731 ALC269_FIXUP_SKU_IGNORE, 6732 ALC269_FIXUP_ASUS_G73JW, 6733 ALC269_FIXUP_LENOVO_EAPD, 6734 ALC275_FIXUP_SONY_HWEQ, 6735 ALC275_FIXUP_SONY_DISABLE_AAMIX, 6736 ALC271_FIXUP_DMIC, 6737 ALC269_FIXUP_PCM_44K, 6738 ALC269_FIXUP_STEREO_DMIC, 6739 ALC269_FIXUP_HEADSET_MIC, 6740 ALC269_FIXUP_QUANTA_MUTE, 6741 ALC269_FIXUP_LIFEBOOK, 6742 ALC269_FIXUP_LIFEBOOK_EXTMIC, 6743 ALC269_FIXUP_LIFEBOOK_HP_PIN, 6744 ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT, 6745 ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, 6746 ALC269_FIXUP_AMIC, 6747 ALC269_FIXUP_DMIC, 6748 ALC269VB_FIXUP_AMIC, 6749 ALC269VB_FIXUP_DMIC, 6750 ALC269_FIXUP_HP_MUTE_LED, 6751 ALC269_FIXUP_HP_MUTE_LED_MIC1, 6752 ALC269_FIXUP_HP_MUTE_LED_MIC2, 6753 ALC269_FIXUP_HP_MUTE_LED_MIC3, 6754 ALC269_FIXUP_HP_GPIO_LED, 6755 ALC269_FIXUP_HP_GPIO_MIC1_LED, 6756 ALC269_FIXUP_HP_LINE1_MIC1_LED, 6757 ALC269_FIXUP_INV_DMIC, 6758 ALC269_FIXUP_LENOVO_DOCK, 6759 ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, 6760 ALC269_FIXUP_NO_SHUTUP, 6761 ALC286_FIXUP_SONY_MIC_NO_PRESENCE, 6762 ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT, 6763 ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 6764 ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, 6765 ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, 6766 ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 6767 ALC269_FIXUP_HEADSET_MODE, 6768 ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, 6769 ALC269_FIXUP_ASPIRE_HEADSET_MIC, 6770 ALC269_FIXUP_ASUS_X101_FUNC, 6771 ALC269_FIXUP_ASUS_X101_VERB, 6772 ALC269_FIXUP_ASUS_X101, 6773 ALC271_FIXUP_AMIC_MIC2, 6774 ALC271_FIXUP_HP_GATE_MIC_JACK, 6775 ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, 6776 ALC269_FIXUP_ACER_AC700, 6777 ALC269_FIXUP_LIMIT_INT_MIC_BOOST, 6778 ALC269VB_FIXUP_ASUS_ZENBOOK, 6779 ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, 6780 ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED, 6781 ALC269VB_FIXUP_ORDISSIMO_EVE2, 6782 ALC283_FIXUP_CHROME_BOOK, 6783 ALC283_FIXUP_SENSE_COMBO_JACK, 6784 ALC282_FIXUP_ASUS_TX300, 6785 ALC283_FIXUP_INT_MIC, 6786 ALC290_FIXUP_MONO_SPEAKERS, 6787 ALC290_FIXUP_MONO_SPEAKERS_HSJACK, 6788 ALC290_FIXUP_SUBWOOFER, 6789 ALC290_FIXUP_SUBWOOFER_HSJACK, 6790 ALC269_FIXUP_THINKPAD_ACPI, 6791 ALC269_FIXUP_DMIC_THINKPAD_ACPI, 6792 ALC255_FIXUP_ACER_MIC_NO_PRESENCE, 6793 ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, 6794 ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 6795 ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, 6796 ALC255_FIXUP_HEADSET_MODE, 6797 ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC, 6798 ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, 6799 ALC292_FIXUP_TPT440_DOCK, 6800 ALC292_FIXUP_TPT440, 6801 ALC283_FIXUP_HEADSET_MIC, 6802 ALC255_FIXUP_MIC_MUTE_LED, 6803 ALC282_FIXUP_ASPIRE_V5_PINS, 6804 ALC269VB_FIXUP_ASPIRE_E1_COEF, 6805 ALC280_FIXUP_HP_GPIO4, 6806 ALC286_FIXUP_HP_GPIO_LED, 6807 ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, 6808 ALC280_FIXUP_HP_DOCK_PINS, 6809 ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, 6810 ALC280_FIXUP_HP_9480M, 6811 ALC245_FIXUP_HP_X360_AMP, 6812 ALC285_FIXUP_HP_SPECTRE_X360_EB1, 6813 ALC288_FIXUP_DELL_HEADSET_MODE, 6814 ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, 6815 ALC288_FIXUP_DELL_XPS_13, 6816 ALC288_FIXUP_DISABLE_AAMIX, 6817 ALC292_FIXUP_DELL_E7X_AAMIX, 6818 ALC292_FIXUP_DELL_E7X, 6819 ALC292_FIXUP_DISABLE_AAMIX, 6820 ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, 6821 ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE, 6822 ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 6823 ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, 6824 ALC275_FIXUP_DELL_XPS, 6825 ALC293_FIXUP_LENOVO_SPK_NOISE, 6826 ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, 6827 ALC255_FIXUP_DELL_SPK_NOISE, 6828 ALC225_FIXUP_DISABLE_MIC_VREF, 6829 ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 6830 ALC295_FIXUP_DISABLE_DAC3, 6831 ALC285_FIXUP_SPEAKER2_TO_DAC1, 6832 ALC280_FIXUP_HP_HEADSET_MIC, 6833 ALC221_FIXUP_HP_FRONT_MIC, 6834 ALC292_FIXUP_TPT460, 6835 ALC298_FIXUP_SPK_VOLUME, 6836 ALC298_FIXUP_LENOVO_SPK_VOLUME, 6837 ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, 6838 ALC269_FIXUP_ATIV_BOOK_8, 6839 ALC221_FIXUP_HP_MIC_NO_PRESENCE, 6840 ALC256_FIXUP_ASUS_HEADSET_MODE, 6841 ALC256_FIXUP_ASUS_MIC, 6842 ALC256_FIXUP_ASUS_AIO_GPIO2, 6843 ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, 6844 ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, 6845 ALC233_FIXUP_LENOVO_MULTI_CODECS, 6846 ALC233_FIXUP_ACER_HEADSET_MIC, 6847 ALC294_FIXUP_LENOVO_MIC_LOCATION, 6848 ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, 6849 ALC225_FIXUP_S3_POP_NOISE, 6850 ALC700_FIXUP_INTEL_REFERENCE, 6851 ALC274_FIXUP_DELL_BIND_DACS, 6852 ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, 6853 ALC298_FIXUP_TPT470_DOCK_FIX, 6854 ALC298_FIXUP_TPT470_DOCK, 6855 ALC255_FIXUP_DUMMY_LINEOUT_VERB, 6856 ALC255_FIXUP_DELL_HEADSET_MIC, 6857 ALC256_FIXUP_HUAWEI_MACH_WX9_PINS, 6858 ALC298_FIXUP_HUAWEI_MBX_STEREO, 6859 ALC295_FIXUP_HP_X360, 6860 ALC221_FIXUP_HP_HEADSET_MIC, 6861 ALC285_FIXUP_LENOVO_HEADPHONE_NOISE, 6862 ALC295_FIXUP_HP_AUTO_MUTE, 6863 ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE, 6864 ALC294_FIXUP_ASUS_MIC, 6865 ALC294_FIXUP_ASUS_HEADSET_MIC, 6866 ALC294_FIXUP_ASUS_SPK, 6867 ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE, 6868 ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE, 6869 ALC255_FIXUP_ACER_HEADSET_MIC, 6870 ALC295_FIXUP_CHROME_BOOK, 6871 ALC225_FIXUP_HEADSET_JACK, 6872 ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE, 6873 ALC225_FIXUP_WYSE_AUTO_MUTE, 6874 ALC225_FIXUP_WYSE_DISABLE_MIC_VREF, 6875 ALC286_FIXUP_ACER_AIO_HEADSET_MIC, 6876 ALC256_FIXUP_ASUS_HEADSET_MIC, 6877 ALC256_FIXUP_ASUS_MIC_NO_PRESENCE, 6878 ALC299_FIXUP_PREDATOR_SPK, 6879 ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, 6880 ALC289_FIXUP_DELL_SPK2, 6881 ALC289_FIXUP_DUAL_SPK, 6882 ALC294_FIXUP_SPK2_TO_DAC1, 6883 ALC294_FIXUP_ASUS_DUAL_SPK, 6884 ALC285_FIXUP_THINKPAD_X1_GEN7, 6885 ALC285_FIXUP_THINKPAD_HEADSET_JACK, 6886 ALC294_FIXUP_ASUS_HPE, 6887 ALC294_FIXUP_ASUS_COEF_1B, 6888 ALC294_FIXUP_ASUS_GX502_HP, 6889 ALC294_FIXUP_ASUS_GX502_PINS, 6890 ALC294_FIXUP_ASUS_GX502_VERBS, 6891 ALC294_FIXUP_ASUS_GU502_HP, 6892 ALC294_FIXUP_ASUS_GU502_PINS, 6893 ALC294_FIXUP_ASUS_GU502_VERBS, 6894 ALC285_FIXUP_HP_GPIO_LED, 6895 ALC285_FIXUP_HP_MUTE_LED, 6896 ALC236_FIXUP_HP_GPIO_LED, 6897 ALC236_FIXUP_HP_MUTE_LED, 6898 ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF, 6899 ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, 6900 ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, 6901 ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS, 6902 ALC269VC_FIXUP_ACER_HEADSET_MIC, 6903 ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE, 6904 ALC289_FIXUP_ASUS_GA401, 6905 ALC289_FIXUP_ASUS_GA502, 6906 ALC256_FIXUP_ACER_MIC_NO_PRESENCE, 6907 ALC285_FIXUP_HP_GPIO_AMP_INIT, 6908 ALC269_FIXUP_CZC_B20, 6909 ALC269_FIXUP_CZC_TMI, 6910 ALC269_FIXUP_CZC_L101, 6911 ALC269_FIXUP_LEMOTE_A1802, 6912 ALC269_FIXUP_LEMOTE_A190X, 6913 ALC256_FIXUP_INTEL_NUC8_RUGGED, 6914 ALC233_FIXUP_INTEL_NUC8_DMIC, 6915 ALC233_FIXUP_INTEL_NUC8_BOOST, 6916 ALC256_FIXUP_INTEL_NUC10, 6917 ALC255_FIXUP_XIAOMI_HEADSET_MIC, 6918 ALC274_FIXUP_HP_MIC, 6919 ALC274_FIXUP_HP_HEADSET_MIC, 6920 ALC274_FIXUP_HP_ENVY_GPIO, 6921 ALC256_FIXUP_ASUS_HPE, 6922 ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK, 6923 ALC287_FIXUP_HP_GPIO_LED, 6924 ALC256_FIXUP_HP_HEADSET_MIC, 6925 ALC245_FIXUP_HP_GPIO_LED, 6926 ALC236_FIXUP_DELL_AIO_HEADSET_MIC, 6927 ALC282_FIXUP_ACER_DISABLE_LINEOUT, 6928 ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST, 6929 ALC256_FIXUP_ACER_HEADSET_MIC, 6930 ALC285_FIXUP_IDEAPAD_S740_COEF, 6931 ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST, 6932 ALC295_FIXUP_ASUS_DACS, 6933 ALC295_FIXUP_HP_OMEN, 6934 ALC285_FIXUP_HP_SPECTRE_X360, 6935 ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, 6936 ALC623_FIXUP_LENOVO_THINKSTATION_P340, 6937 ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, 6938 ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST, 6939 ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS, 6940 ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE, 6941 ALC287_FIXUP_YOGA7_14ITL_SPEAKERS, 6942 ALC287_FIXUP_13S_GEN2_SPEAKERS, 6943 ALC256_FIXUP_SET_COEF_DEFAULTS, 6944 ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE, 6945 ALC233_FIXUP_NO_AUDIO_JACK, 6946 ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME, 6947 ALC285_FIXUP_LEGION_Y9000X_SPEAKERS, 6948 ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE, 6949 ALC287_FIXUP_LEGION_16ACHG6, 6950 ALC287_FIXUP_CS35L41_I2C_2, 6951 ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED, 6952 }; 6953 6954 static const struct hda_fixup alc269_fixups[] = { 6955 [ALC269_FIXUP_GPIO2] = { 6956 .type = HDA_FIXUP_FUNC, 6957 .v.func = alc_fixup_gpio2, 6958 }, 6959 [ALC269_FIXUP_SONY_VAIO] = { 6960 .type = HDA_FIXUP_PINCTLS, 6961 .v.pins = (const struct hda_pintbl[]) { 6962 {0x19, PIN_VREFGRD}, 6963 {} 6964 } 6965 }, 6966 [ALC275_FIXUP_SONY_VAIO_GPIO2] = { 6967 .type = HDA_FIXUP_FUNC, 6968 .v.func = alc275_fixup_gpio4_off, 6969 .chained = true, 6970 .chain_id = ALC269_FIXUP_SONY_VAIO 6971 }, 6972 [ALC269_FIXUP_DELL_M101Z] = { 6973 .type = HDA_FIXUP_VERBS, 6974 .v.verbs = (const struct hda_verb[]) { 6975 /* Enables internal speaker */ 6976 {0x20, AC_VERB_SET_COEF_INDEX, 13}, 6977 {0x20, AC_VERB_SET_PROC_COEF, 0x4040}, 6978 {} 6979 } 6980 }, 6981 [ALC269_FIXUP_SKU_IGNORE] = { 6982 .type = HDA_FIXUP_FUNC, 6983 .v.func = alc_fixup_sku_ignore, 6984 }, 6985 [ALC269_FIXUP_ASUS_G73JW] = { 6986 .type = HDA_FIXUP_PINS, 6987 .v.pins = (const struct hda_pintbl[]) { 6988 { 0x17, 0x99130111 }, /* subwoofer */ 6989 { } 6990 } 6991 }, 6992 [ALC269_FIXUP_LENOVO_EAPD] = { 6993 .type = HDA_FIXUP_VERBS, 6994 .v.verbs = (const struct hda_verb[]) { 6995 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0}, 6996 {} 6997 } 6998 }, 6999 [ALC275_FIXUP_SONY_HWEQ] = { 7000 .type = HDA_FIXUP_FUNC, 7001 .v.func = alc269_fixup_hweq, 7002 .chained = true, 7003 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2 7004 }, 7005 [ALC275_FIXUP_SONY_DISABLE_AAMIX] = { 7006 .type = HDA_FIXUP_FUNC, 7007 .v.func = alc_fixup_disable_aamix, 7008 .chained = true, 7009 .chain_id = ALC269_FIXUP_SONY_VAIO 7010 }, 7011 [ALC271_FIXUP_DMIC] = { 7012 .type = HDA_FIXUP_FUNC, 7013 .v.func = alc271_fixup_dmic, 7014 }, 7015 [ALC269_FIXUP_PCM_44K] = { 7016 .type = HDA_FIXUP_FUNC, 7017 .v.func = alc269_fixup_pcm_44k, 7018 .chained = true, 7019 .chain_id = ALC269_FIXUP_QUANTA_MUTE 7020 }, 7021 [ALC269_FIXUP_STEREO_DMIC] = { 7022 .type = HDA_FIXUP_FUNC, 7023 .v.func = alc269_fixup_stereo_dmic, 7024 }, 7025 [ALC269_FIXUP_HEADSET_MIC] = { 7026 .type = HDA_FIXUP_FUNC, 7027 .v.func = alc269_fixup_headset_mic, 7028 }, 7029 [ALC269_FIXUP_QUANTA_MUTE] = { 7030 .type = HDA_FIXUP_FUNC, 7031 .v.func = alc269_fixup_quanta_mute, 7032 }, 7033 [ALC269_FIXUP_LIFEBOOK] = { 7034 .type = HDA_FIXUP_PINS, 7035 .v.pins = (const struct hda_pintbl[]) { 7036 { 0x1a, 0x2101103f }, /* dock line-out */ 7037 { 0x1b, 0x23a11040 }, /* dock mic-in */ 7038 { } 7039 }, 7040 .chained = true, 7041 .chain_id = ALC269_FIXUP_QUANTA_MUTE 7042 }, 7043 [ALC269_FIXUP_LIFEBOOK_EXTMIC] = { 7044 .type = HDA_FIXUP_PINS, 7045 .v.pins = (const struct hda_pintbl[]) { 7046 { 0x19, 0x01a1903c }, /* headset mic, with jack detect */ 7047 { } 7048 }, 7049 }, 7050 [ALC269_FIXUP_LIFEBOOK_HP_PIN] = { 7051 .type = HDA_FIXUP_PINS, 7052 .v.pins = (const struct hda_pintbl[]) { 7053 { 0x21, 0x0221102f }, /* HP out */ 7054 { } 7055 }, 7056 }, 7057 [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = { 7058 .type = HDA_FIXUP_FUNC, 7059 .v.func = alc269_fixup_pincfg_no_hp_to_lineout, 7060 }, 7061 [ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = { 7062 .type = HDA_FIXUP_FUNC, 7063 .v.func = alc269_fixup_pincfg_U7x7_headset_mic, 7064 }, 7065 [ALC269_FIXUP_AMIC] = { 7066 .type = HDA_FIXUP_PINS, 7067 .v.pins = (const struct hda_pintbl[]) { 7068 { 0x14, 0x99130110 }, /* speaker */ 7069 { 0x15, 0x0121401f }, /* HP out */ 7070 { 0x18, 0x01a19c20 }, /* mic */ 7071 { 0x19, 0x99a3092f }, /* int-mic */ 7072 { } 7073 }, 7074 }, 7075 [ALC269_FIXUP_DMIC] = { 7076 .type = HDA_FIXUP_PINS, 7077 .v.pins = (const struct hda_pintbl[]) { 7078 { 0x12, 0x99a3092f }, /* int-mic */ 7079 { 0x14, 0x99130110 }, /* speaker */ 7080 { 0x15, 0x0121401f }, /* HP out */ 7081 { 0x18, 0x01a19c20 }, /* mic */ 7082 { } 7083 }, 7084 }, 7085 [ALC269VB_FIXUP_AMIC] = { 7086 .type = HDA_FIXUP_PINS, 7087 .v.pins = (const struct hda_pintbl[]) { 7088 { 0x14, 0x99130110 }, /* speaker */ 7089 { 0x18, 0x01a19c20 }, /* mic */ 7090 { 0x19, 0x99a3092f }, /* int-mic */ 7091 { 0x21, 0x0121401f }, /* HP out */ 7092 { } 7093 }, 7094 }, 7095 [ALC269VB_FIXUP_DMIC] = { 7096 .type = HDA_FIXUP_PINS, 7097 .v.pins = (const struct hda_pintbl[]) { 7098 { 0x12, 0x99a3092f }, /* int-mic */ 7099 { 0x14, 0x99130110 }, /* speaker */ 7100 { 0x18, 0x01a19c20 }, /* mic */ 7101 { 0x21, 0x0121401f }, /* HP out */ 7102 { } 7103 }, 7104 }, 7105 [ALC269_FIXUP_HP_MUTE_LED] = { 7106 .type = HDA_FIXUP_FUNC, 7107 .v.func = alc269_fixup_hp_mute_led, 7108 }, 7109 [ALC269_FIXUP_HP_MUTE_LED_MIC1] = { 7110 .type = HDA_FIXUP_FUNC, 7111 .v.func = alc269_fixup_hp_mute_led_mic1, 7112 }, 7113 [ALC269_FIXUP_HP_MUTE_LED_MIC2] = { 7114 .type = HDA_FIXUP_FUNC, 7115 .v.func = alc269_fixup_hp_mute_led_mic2, 7116 }, 7117 [ALC269_FIXUP_HP_MUTE_LED_MIC3] = { 7118 .type = HDA_FIXUP_FUNC, 7119 .v.func = alc269_fixup_hp_mute_led_mic3, 7120 .chained = true, 7121 .chain_id = ALC295_FIXUP_HP_AUTO_MUTE 7122 }, 7123 [ALC269_FIXUP_HP_GPIO_LED] = { 7124 .type = HDA_FIXUP_FUNC, 7125 .v.func = alc269_fixup_hp_gpio_led, 7126 }, 7127 [ALC269_FIXUP_HP_GPIO_MIC1_LED] = { 7128 .type = HDA_FIXUP_FUNC, 7129 .v.func = alc269_fixup_hp_gpio_mic1_led, 7130 }, 7131 [ALC269_FIXUP_HP_LINE1_MIC1_LED] = { 7132 .type = HDA_FIXUP_FUNC, 7133 .v.func = alc269_fixup_hp_line1_mic1_led, 7134 }, 7135 [ALC269_FIXUP_INV_DMIC] = { 7136 .type = HDA_FIXUP_FUNC, 7137 .v.func = alc_fixup_inv_dmic, 7138 }, 7139 [ALC269_FIXUP_NO_SHUTUP] = { 7140 .type = HDA_FIXUP_FUNC, 7141 .v.func = alc_fixup_no_shutup, 7142 }, 7143 [ALC269_FIXUP_LENOVO_DOCK] = { 7144 .type = HDA_FIXUP_PINS, 7145 .v.pins = (const struct hda_pintbl[]) { 7146 { 0x19, 0x23a11040 }, /* dock mic */ 7147 { 0x1b, 0x2121103f }, /* dock headphone */ 7148 { } 7149 }, 7150 .chained = true, 7151 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT 7152 }, 7153 [ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST] = { 7154 .type = HDA_FIXUP_FUNC, 7155 .v.func = alc269_fixup_limit_int_mic_boost, 7156 .chained = true, 7157 .chain_id = ALC269_FIXUP_LENOVO_DOCK, 7158 }, 7159 [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = { 7160 .type = HDA_FIXUP_FUNC, 7161 .v.func = alc269_fixup_pincfg_no_hp_to_lineout, 7162 .chained = true, 7163 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 7164 }, 7165 [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = { 7166 .type = HDA_FIXUP_PINS, 7167 .v.pins = (const struct hda_pintbl[]) { 7168 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7169 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 7170 { } 7171 }, 7172 .chained = true, 7173 .chain_id = ALC269_FIXUP_HEADSET_MODE 7174 }, 7175 [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = { 7176 .type = HDA_FIXUP_PINS, 7177 .v.pins = (const struct hda_pintbl[]) { 7178 { 0x16, 0x21014020 }, /* dock line out */ 7179 { 0x19, 0x21a19030 }, /* dock mic */ 7180 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7181 { } 7182 }, 7183 .chained = true, 7184 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 7185 }, 7186 [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = { 7187 .type = HDA_FIXUP_PINS, 7188 .v.pins = (const struct hda_pintbl[]) { 7189 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7190 { } 7191 }, 7192 .chained = true, 7193 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 7194 }, 7195 [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = { 7196 .type = HDA_FIXUP_PINS, 7197 .v.pins = (const struct hda_pintbl[]) { 7198 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7199 { 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 7200 { } 7201 }, 7202 .chained = true, 7203 .chain_id = ALC269_FIXUP_HEADSET_MODE 7204 }, 7205 [ALC269_FIXUP_HEADSET_MODE] = { 7206 .type = HDA_FIXUP_FUNC, 7207 .v.func = alc_fixup_headset_mode, 7208 .chained = true, 7209 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 7210 }, 7211 [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = { 7212 .type = HDA_FIXUP_FUNC, 7213 .v.func = alc_fixup_headset_mode_no_hp_mic, 7214 }, 7215 [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = { 7216 .type = HDA_FIXUP_PINS, 7217 .v.pins = (const struct hda_pintbl[]) { 7218 { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */ 7219 { } 7220 }, 7221 .chained = true, 7222 .chain_id = ALC269_FIXUP_HEADSET_MODE, 7223 }, 7224 [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = { 7225 .type = HDA_FIXUP_PINS, 7226 .v.pins = (const struct hda_pintbl[]) { 7227 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7228 { } 7229 }, 7230 .chained = true, 7231 .chain_id = ALC269_FIXUP_HEADSET_MIC 7232 }, 7233 [ALC256_FIXUP_HUAWEI_MACH_WX9_PINS] = { 7234 .type = HDA_FIXUP_PINS, 7235 .v.pins = (const struct hda_pintbl[]) { 7236 {0x12, 0x90a60130}, 7237 {0x13, 0x40000000}, 7238 {0x14, 0x90170110}, 7239 {0x18, 0x411111f0}, 7240 {0x19, 0x04a11040}, 7241 {0x1a, 0x411111f0}, 7242 {0x1b, 0x90170112}, 7243 {0x1d, 0x40759a05}, 7244 {0x1e, 0x411111f0}, 7245 {0x21, 0x04211020}, 7246 { } 7247 }, 7248 .chained = true, 7249 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 7250 }, 7251 [ALC298_FIXUP_HUAWEI_MBX_STEREO] = { 7252 .type = HDA_FIXUP_FUNC, 7253 .v.func = alc298_fixup_huawei_mbx_stereo, 7254 .chained = true, 7255 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 7256 }, 7257 [ALC269_FIXUP_ASUS_X101_FUNC] = { 7258 .type = HDA_FIXUP_FUNC, 7259 .v.func = alc269_fixup_x101_headset_mic, 7260 }, 7261 [ALC269_FIXUP_ASUS_X101_VERB] = { 7262 .type = HDA_FIXUP_VERBS, 7263 .v.verbs = (const struct hda_verb[]) { 7264 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 7265 {0x20, AC_VERB_SET_COEF_INDEX, 0x08}, 7266 {0x20, AC_VERB_SET_PROC_COEF, 0x0310}, 7267 { } 7268 }, 7269 .chained = true, 7270 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC 7271 }, 7272 [ALC269_FIXUP_ASUS_X101] = { 7273 .type = HDA_FIXUP_PINS, 7274 .v.pins = (const struct hda_pintbl[]) { 7275 { 0x18, 0x04a1182c }, /* Headset mic */ 7276 { } 7277 }, 7278 .chained = true, 7279 .chain_id = ALC269_FIXUP_ASUS_X101_VERB 7280 }, 7281 [ALC271_FIXUP_AMIC_MIC2] = { 7282 .type = HDA_FIXUP_PINS, 7283 .v.pins = (const struct hda_pintbl[]) { 7284 { 0x14, 0x99130110 }, /* speaker */ 7285 { 0x19, 0x01a19c20 }, /* mic */ 7286 { 0x1b, 0x99a7012f }, /* int-mic */ 7287 { 0x21, 0x0121401f }, /* HP out */ 7288 { } 7289 }, 7290 }, 7291 [ALC271_FIXUP_HP_GATE_MIC_JACK] = { 7292 .type = HDA_FIXUP_FUNC, 7293 .v.func = alc271_hp_gate_mic_jack, 7294 .chained = true, 7295 .chain_id = ALC271_FIXUP_AMIC_MIC2, 7296 }, 7297 [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = { 7298 .type = HDA_FIXUP_FUNC, 7299 .v.func = alc269_fixup_limit_int_mic_boost, 7300 .chained = true, 7301 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK, 7302 }, 7303 [ALC269_FIXUP_ACER_AC700] = { 7304 .type = HDA_FIXUP_PINS, 7305 .v.pins = (const struct hda_pintbl[]) { 7306 { 0x12, 0x99a3092f }, /* int-mic */ 7307 { 0x14, 0x99130110 }, /* speaker */ 7308 { 0x18, 0x03a11c20 }, /* mic */ 7309 { 0x1e, 0x0346101e }, /* SPDIF1 */ 7310 { 0x21, 0x0321101f }, /* HP out */ 7311 { } 7312 }, 7313 .chained = true, 7314 .chain_id = ALC271_FIXUP_DMIC, 7315 }, 7316 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = { 7317 .type = HDA_FIXUP_FUNC, 7318 .v.func = alc269_fixup_limit_int_mic_boost, 7319 .chained = true, 7320 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 7321 }, 7322 [ALC269VB_FIXUP_ASUS_ZENBOOK] = { 7323 .type = HDA_FIXUP_FUNC, 7324 .v.func = alc269_fixup_limit_int_mic_boost, 7325 .chained = true, 7326 .chain_id = ALC269VB_FIXUP_DMIC, 7327 }, 7328 [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = { 7329 .type = HDA_FIXUP_VERBS, 7330 .v.verbs = (const struct hda_verb[]) { 7331 /* class-D output amp +5dB */ 7332 { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 }, 7333 { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 }, 7334 {} 7335 }, 7336 .chained = true, 7337 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK, 7338 }, 7339 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = { 7340 .type = HDA_FIXUP_FUNC, 7341 .v.func = alc269_fixup_limit_int_mic_boost, 7342 .chained = true, 7343 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1, 7344 }, 7345 [ALC269VB_FIXUP_ORDISSIMO_EVE2] = { 7346 .type = HDA_FIXUP_PINS, 7347 .v.pins = (const struct hda_pintbl[]) { 7348 { 0x12, 0x99a3092f }, /* int-mic */ 7349 { 0x18, 0x03a11d20 }, /* mic */ 7350 { 0x19, 0x411111f0 }, /* Unused bogus pin */ 7351 { } 7352 }, 7353 }, 7354 [ALC283_FIXUP_CHROME_BOOK] = { 7355 .type = HDA_FIXUP_FUNC, 7356 .v.func = alc283_fixup_chromebook, 7357 }, 7358 [ALC283_FIXUP_SENSE_COMBO_JACK] = { 7359 .type = HDA_FIXUP_FUNC, 7360 .v.func = alc283_fixup_sense_combo_jack, 7361 .chained = true, 7362 .chain_id = ALC283_FIXUP_CHROME_BOOK, 7363 }, 7364 [ALC282_FIXUP_ASUS_TX300] = { 7365 .type = HDA_FIXUP_FUNC, 7366 .v.func = alc282_fixup_asus_tx300, 7367 }, 7368 [ALC283_FIXUP_INT_MIC] = { 7369 .type = HDA_FIXUP_VERBS, 7370 .v.verbs = (const struct hda_verb[]) { 7371 {0x20, AC_VERB_SET_COEF_INDEX, 0x1a}, 7372 {0x20, AC_VERB_SET_PROC_COEF, 0x0011}, 7373 { } 7374 }, 7375 .chained = true, 7376 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST 7377 }, 7378 [ALC290_FIXUP_SUBWOOFER_HSJACK] = { 7379 .type = HDA_FIXUP_PINS, 7380 .v.pins = (const struct hda_pintbl[]) { 7381 { 0x17, 0x90170112 }, /* subwoofer */ 7382 { } 7383 }, 7384 .chained = true, 7385 .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, 7386 }, 7387 [ALC290_FIXUP_SUBWOOFER] = { 7388 .type = HDA_FIXUP_PINS, 7389 .v.pins = (const struct hda_pintbl[]) { 7390 { 0x17, 0x90170112 }, /* subwoofer */ 7391 { } 7392 }, 7393 .chained = true, 7394 .chain_id = ALC290_FIXUP_MONO_SPEAKERS, 7395 }, 7396 [ALC290_FIXUP_MONO_SPEAKERS] = { 7397 .type = HDA_FIXUP_FUNC, 7398 .v.func = alc290_fixup_mono_speakers, 7399 }, 7400 [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = { 7401 .type = HDA_FIXUP_FUNC, 7402 .v.func = alc290_fixup_mono_speakers, 7403 .chained = true, 7404 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, 7405 }, 7406 [ALC269_FIXUP_THINKPAD_ACPI] = { 7407 .type = HDA_FIXUP_FUNC, 7408 .v.func = alc_fixup_thinkpad_acpi, 7409 .chained = true, 7410 .chain_id = ALC269_FIXUP_SKU_IGNORE, 7411 }, 7412 [ALC269_FIXUP_DMIC_THINKPAD_ACPI] = { 7413 .type = HDA_FIXUP_FUNC, 7414 .v.func = alc_fixup_inv_dmic, 7415 .chained = true, 7416 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 7417 }, 7418 [ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = { 7419 .type = HDA_FIXUP_PINS, 7420 .v.pins = (const struct hda_pintbl[]) { 7421 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7422 { } 7423 }, 7424 .chained = true, 7425 .chain_id = ALC255_FIXUP_HEADSET_MODE 7426 }, 7427 [ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = { 7428 .type = HDA_FIXUP_PINS, 7429 .v.pins = (const struct hda_pintbl[]) { 7430 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7431 { } 7432 }, 7433 .chained = true, 7434 .chain_id = ALC255_FIXUP_HEADSET_MODE 7435 }, 7436 [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = { 7437 .type = HDA_FIXUP_PINS, 7438 .v.pins = (const struct hda_pintbl[]) { 7439 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7440 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 7441 { } 7442 }, 7443 .chained = true, 7444 .chain_id = ALC255_FIXUP_HEADSET_MODE 7445 }, 7446 [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = { 7447 .type = HDA_FIXUP_PINS, 7448 .v.pins = (const struct hda_pintbl[]) { 7449 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7450 { } 7451 }, 7452 .chained = true, 7453 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC 7454 }, 7455 [ALC255_FIXUP_HEADSET_MODE] = { 7456 .type = HDA_FIXUP_FUNC, 7457 .v.func = alc_fixup_headset_mode_alc255, 7458 .chained = true, 7459 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 7460 }, 7461 [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = { 7462 .type = HDA_FIXUP_FUNC, 7463 .v.func = alc_fixup_headset_mode_alc255_no_hp_mic, 7464 }, 7465 [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = { 7466 .type = HDA_FIXUP_PINS, 7467 .v.pins = (const struct hda_pintbl[]) { 7468 { 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 7469 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7470 { } 7471 }, 7472 .chained = true, 7473 .chain_id = ALC269_FIXUP_HEADSET_MODE 7474 }, 7475 [ALC292_FIXUP_TPT440_DOCK] = { 7476 .type = HDA_FIXUP_FUNC, 7477 .v.func = alc_fixup_tpt440_dock, 7478 .chained = true, 7479 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST 7480 }, 7481 [ALC292_FIXUP_TPT440] = { 7482 .type = HDA_FIXUP_FUNC, 7483 .v.func = alc_fixup_disable_aamix, 7484 .chained = true, 7485 .chain_id = ALC292_FIXUP_TPT440_DOCK, 7486 }, 7487 [ALC283_FIXUP_HEADSET_MIC] = { 7488 .type = HDA_FIXUP_PINS, 7489 .v.pins = (const struct hda_pintbl[]) { 7490 { 0x19, 0x04a110f0 }, 7491 { }, 7492 }, 7493 }, 7494 [ALC255_FIXUP_MIC_MUTE_LED] = { 7495 .type = HDA_FIXUP_FUNC, 7496 .v.func = alc_fixup_micmute_led, 7497 }, 7498 [ALC282_FIXUP_ASPIRE_V5_PINS] = { 7499 .type = HDA_FIXUP_PINS, 7500 .v.pins = (const struct hda_pintbl[]) { 7501 { 0x12, 0x90a60130 }, 7502 { 0x14, 0x90170110 }, 7503 { 0x17, 0x40000008 }, 7504 { 0x18, 0x411111f0 }, 7505 { 0x19, 0x01a1913c }, 7506 { 0x1a, 0x411111f0 }, 7507 { 0x1b, 0x411111f0 }, 7508 { 0x1d, 0x40f89b2d }, 7509 { 0x1e, 0x411111f0 }, 7510 { 0x21, 0x0321101f }, 7511 { }, 7512 }, 7513 }, 7514 [ALC269VB_FIXUP_ASPIRE_E1_COEF] = { 7515 .type = HDA_FIXUP_FUNC, 7516 .v.func = alc269vb_fixup_aspire_e1_coef, 7517 }, 7518 [ALC280_FIXUP_HP_GPIO4] = { 7519 .type = HDA_FIXUP_FUNC, 7520 .v.func = alc280_fixup_hp_gpio4, 7521 }, 7522 [ALC286_FIXUP_HP_GPIO_LED] = { 7523 .type = HDA_FIXUP_FUNC, 7524 .v.func = alc286_fixup_hp_gpio_led, 7525 }, 7526 [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = { 7527 .type = HDA_FIXUP_FUNC, 7528 .v.func = alc280_fixup_hp_gpio2_mic_hotkey, 7529 }, 7530 [ALC280_FIXUP_HP_DOCK_PINS] = { 7531 .type = HDA_FIXUP_PINS, 7532 .v.pins = (const struct hda_pintbl[]) { 7533 { 0x1b, 0x21011020 }, /* line-out */ 7534 { 0x1a, 0x01a1903c }, /* headset mic */ 7535 { 0x18, 0x2181103f }, /* line-in */ 7536 { }, 7537 }, 7538 .chained = true, 7539 .chain_id = ALC280_FIXUP_HP_GPIO4 7540 }, 7541 [ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = { 7542 .type = HDA_FIXUP_PINS, 7543 .v.pins = (const struct hda_pintbl[]) { 7544 { 0x1b, 0x21011020 }, /* line-out */ 7545 { 0x18, 0x2181103f }, /* line-in */ 7546 { }, 7547 }, 7548 .chained = true, 7549 .chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED 7550 }, 7551 [ALC280_FIXUP_HP_9480M] = { 7552 .type = HDA_FIXUP_FUNC, 7553 .v.func = alc280_fixup_hp_9480m, 7554 }, 7555 [ALC245_FIXUP_HP_X360_AMP] = { 7556 .type = HDA_FIXUP_FUNC, 7557 .v.func = alc245_fixup_hp_x360_amp, 7558 .chained = true, 7559 .chain_id = ALC245_FIXUP_HP_GPIO_LED 7560 }, 7561 [ALC288_FIXUP_DELL_HEADSET_MODE] = { 7562 .type = HDA_FIXUP_FUNC, 7563 .v.func = alc_fixup_headset_mode_dell_alc288, 7564 .chained = true, 7565 .chain_id = ALC255_FIXUP_MIC_MUTE_LED 7566 }, 7567 [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = { 7568 .type = HDA_FIXUP_PINS, 7569 .v.pins = (const struct hda_pintbl[]) { 7570 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7571 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 7572 { } 7573 }, 7574 .chained = true, 7575 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE 7576 }, 7577 [ALC288_FIXUP_DISABLE_AAMIX] = { 7578 .type = HDA_FIXUP_FUNC, 7579 .v.func = alc_fixup_disable_aamix, 7580 .chained = true, 7581 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE 7582 }, 7583 [ALC288_FIXUP_DELL_XPS_13] = { 7584 .type = HDA_FIXUP_FUNC, 7585 .v.func = alc_fixup_dell_xps13, 7586 .chained = true, 7587 .chain_id = ALC288_FIXUP_DISABLE_AAMIX 7588 }, 7589 [ALC292_FIXUP_DISABLE_AAMIX] = { 7590 .type = HDA_FIXUP_FUNC, 7591 .v.func = alc_fixup_disable_aamix, 7592 .chained = true, 7593 .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE 7594 }, 7595 [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = { 7596 .type = HDA_FIXUP_FUNC, 7597 .v.func = alc_fixup_disable_aamix, 7598 .chained = true, 7599 .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE 7600 }, 7601 [ALC292_FIXUP_DELL_E7X_AAMIX] = { 7602 .type = HDA_FIXUP_FUNC, 7603 .v.func = alc_fixup_dell_xps13, 7604 .chained = true, 7605 .chain_id = ALC292_FIXUP_DISABLE_AAMIX 7606 }, 7607 [ALC292_FIXUP_DELL_E7X] = { 7608 .type = HDA_FIXUP_FUNC, 7609 .v.func = alc_fixup_micmute_led, 7610 /* micmute fixup must be applied at last */ 7611 .chained_before = true, 7612 .chain_id = ALC292_FIXUP_DELL_E7X_AAMIX, 7613 }, 7614 [ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE] = { 7615 .type = HDA_FIXUP_PINS, 7616 .v.pins = (const struct hda_pintbl[]) { 7617 { 0x18, 0x01a1913c }, /* headset mic w/o jack detect */ 7618 { } 7619 }, 7620 .chained_before = true, 7621 .chain_id = ALC269_FIXUP_HEADSET_MODE, 7622 }, 7623 [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = { 7624 .type = HDA_FIXUP_PINS, 7625 .v.pins = (const struct hda_pintbl[]) { 7626 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7627 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 7628 { } 7629 }, 7630 .chained = true, 7631 .chain_id = ALC269_FIXUP_HEADSET_MODE 7632 }, 7633 [ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = { 7634 .type = HDA_FIXUP_PINS, 7635 .v.pins = (const struct hda_pintbl[]) { 7636 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7637 { } 7638 }, 7639 .chained = true, 7640 .chain_id = ALC269_FIXUP_HEADSET_MODE 7641 }, 7642 [ALC275_FIXUP_DELL_XPS] = { 7643 .type = HDA_FIXUP_VERBS, 7644 .v.verbs = (const struct hda_verb[]) { 7645 /* Enables internal speaker */ 7646 {0x20, AC_VERB_SET_COEF_INDEX, 0x1f}, 7647 {0x20, AC_VERB_SET_PROC_COEF, 0x00c0}, 7648 {0x20, AC_VERB_SET_COEF_INDEX, 0x30}, 7649 {0x20, AC_VERB_SET_PROC_COEF, 0x00b1}, 7650 {} 7651 } 7652 }, 7653 [ALC293_FIXUP_LENOVO_SPK_NOISE] = { 7654 .type = HDA_FIXUP_FUNC, 7655 .v.func = alc_fixup_disable_aamix, 7656 .chained = true, 7657 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 7658 }, 7659 [ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = { 7660 .type = HDA_FIXUP_FUNC, 7661 .v.func = alc233_fixup_lenovo_line2_mic_hotkey, 7662 }, 7663 [ALC233_FIXUP_INTEL_NUC8_DMIC] = { 7664 .type = HDA_FIXUP_FUNC, 7665 .v.func = alc_fixup_inv_dmic, 7666 .chained = true, 7667 .chain_id = ALC233_FIXUP_INTEL_NUC8_BOOST, 7668 }, 7669 [ALC233_FIXUP_INTEL_NUC8_BOOST] = { 7670 .type = HDA_FIXUP_FUNC, 7671 .v.func = alc269_fixup_limit_int_mic_boost 7672 }, 7673 [ALC255_FIXUP_DELL_SPK_NOISE] = { 7674 .type = HDA_FIXUP_FUNC, 7675 .v.func = alc_fixup_disable_aamix, 7676 .chained = true, 7677 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE 7678 }, 7679 [ALC225_FIXUP_DISABLE_MIC_VREF] = { 7680 .type = HDA_FIXUP_FUNC, 7681 .v.func = alc_fixup_disable_mic_vref, 7682 .chained = true, 7683 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE 7684 }, 7685 [ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = { 7686 .type = HDA_FIXUP_VERBS, 7687 .v.verbs = (const struct hda_verb[]) { 7688 /* Disable pass-through path for FRONT 14h */ 7689 { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 }, 7690 { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 }, 7691 {} 7692 }, 7693 .chained = true, 7694 .chain_id = ALC225_FIXUP_DISABLE_MIC_VREF 7695 }, 7696 [ALC280_FIXUP_HP_HEADSET_MIC] = { 7697 .type = HDA_FIXUP_FUNC, 7698 .v.func = alc_fixup_disable_aamix, 7699 .chained = true, 7700 .chain_id = ALC269_FIXUP_HEADSET_MIC, 7701 }, 7702 [ALC221_FIXUP_HP_FRONT_MIC] = { 7703 .type = HDA_FIXUP_PINS, 7704 .v.pins = (const struct hda_pintbl[]) { 7705 { 0x19, 0x02a19020 }, /* Front Mic */ 7706 { } 7707 }, 7708 }, 7709 [ALC292_FIXUP_TPT460] = { 7710 .type = HDA_FIXUP_FUNC, 7711 .v.func = alc_fixup_tpt440_dock, 7712 .chained = true, 7713 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE, 7714 }, 7715 [ALC298_FIXUP_SPK_VOLUME] = { 7716 .type = HDA_FIXUP_FUNC, 7717 .v.func = alc298_fixup_speaker_volume, 7718 .chained = true, 7719 .chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, 7720 }, 7721 [ALC298_FIXUP_LENOVO_SPK_VOLUME] = { 7722 .type = HDA_FIXUP_FUNC, 7723 .v.func = alc298_fixup_speaker_volume, 7724 }, 7725 [ALC295_FIXUP_DISABLE_DAC3] = { 7726 .type = HDA_FIXUP_FUNC, 7727 .v.func = alc295_fixup_disable_dac3, 7728 }, 7729 [ALC285_FIXUP_SPEAKER2_TO_DAC1] = { 7730 .type = HDA_FIXUP_FUNC, 7731 .v.func = alc285_fixup_speaker2_to_dac1, 7732 .chained = true, 7733 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 7734 }, 7735 [ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = { 7736 .type = HDA_FIXUP_PINS, 7737 .v.pins = (const struct hda_pintbl[]) { 7738 { 0x1b, 0x90170151 }, 7739 { } 7740 }, 7741 .chained = true, 7742 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE 7743 }, 7744 [ALC269_FIXUP_ATIV_BOOK_8] = { 7745 .type = HDA_FIXUP_FUNC, 7746 .v.func = alc_fixup_auto_mute_via_amp, 7747 .chained = true, 7748 .chain_id = ALC269_FIXUP_NO_SHUTUP 7749 }, 7750 [ALC221_FIXUP_HP_MIC_NO_PRESENCE] = { 7751 .type = HDA_FIXUP_PINS, 7752 .v.pins = (const struct hda_pintbl[]) { 7753 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7754 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 7755 { } 7756 }, 7757 .chained = true, 7758 .chain_id = ALC269_FIXUP_HEADSET_MODE 7759 }, 7760 [ALC256_FIXUP_ASUS_HEADSET_MODE] = { 7761 .type = HDA_FIXUP_FUNC, 7762 .v.func = alc_fixup_headset_mode, 7763 }, 7764 [ALC256_FIXUP_ASUS_MIC] = { 7765 .type = HDA_FIXUP_PINS, 7766 .v.pins = (const struct hda_pintbl[]) { 7767 { 0x13, 0x90a60160 }, /* use as internal mic */ 7768 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */ 7769 { } 7770 }, 7771 .chained = true, 7772 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 7773 }, 7774 [ALC256_FIXUP_ASUS_AIO_GPIO2] = { 7775 .type = HDA_FIXUP_FUNC, 7776 /* Set up GPIO2 for the speaker amp */ 7777 .v.func = alc_fixup_gpio4, 7778 }, 7779 [ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = { 7780 .type = HDA_FIXUP_PINS, 7781 .v.pins = (const struct hda_pintbl[]) { 7782 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7783 { } 7784 }, 7785 .chained = true, 7786 .chain_id = ALC269_FIXUP_HEADSET_MIC 7787 }, 7788 [ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = { 7789 .type = HDA_FIXUP_VERBS, 7790 .v.verbs = (const struct hda_verb[]) { 7791 /* Enables internal speaker */ 7792 {0x20, AC_VERB_SET_COEF_INDEX, 0x40}, 7793 {0x20, AC_VERB_SET_PROC_COEF, 0x8800}, 7794 {} 7795 }, 7796 .chained = true, 7797 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE 7798 }, 7799 [ALC233_FIXUP_LENOVO_MULTI_CODECS] = { 7800 .type = HDA_FIXUP_FUNC, 7801 .v.func = alc233_alc662_fixup_lenovo_dual_codecs, 7802 .chained = true, 7803 .chain_id = ALC269_FIXUP_GPIO2 7804 }, 7805 [ALC233_FIXUP_ACER_HEADSET_MIC] = { 7806 .type = HDA_FIXUP_VERBS, 7807 .v.verbs = (const struct hda_verb[]) { 7808 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 }, 7809 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 }, 7810 { } 7811 }, 7812 .chained = true, 7813 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE 7814 }, 7815 [ALC294_FIXUP_LENOVO_MIC_LOCATION] = { 7816 .type = HDA_FIXUP_PINS, 7817 .v.pins = (const struct hda_pintbl[]) { 7818 /* Change the mic location from front to right, otherwise there are 7819 two front mics with the same name, pulseaudio can't handle them. 7820 This is just a temporary workaround, after applying this fixup, 7821 there will be one "Front Mic" and one "Mic" in this machine. 7822 */ 7823 { 0x1a, 0x04a19040 }, 7824 { } 7825 }, 7826 }, 7827 [ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = { 7828 .type = HDA_FIXUP_PINS, 7829 .v.pins = (const struct hda_pintbl[]) { 7830 { 0x16, 0x0101102f }, /* Rear Headset HP */ 7831 { 0x19, 0x02a1913c }, /* use as Front headset mic, without its own jack detect */ 7832 { 0x1a, 0x01a19030 }, /* Rear Headset MIC */ 7833 { 0x1b, 0x02011020 }, 7834 { } 7835 }, 7836 .chained = true, 7837 .chain_id = ALC225_FIXUP_S3_POP_NOISE 7838 }, 7839 [ALC225_FIXUP_S3_POP_NOISE] = { 7840 .type = HDA_FIXUP_FUNC, 7841 .v.func = alc225_fixup_s3_pop_noise, 7842 .chained = true, 7843 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 7844 }, 7845 [ALC700_FIXUP_INTEL_REFERENCE] = { 7846 .type = HDA_FIXUP_VERBS, 7847 .v.verbs = (const struct hda_verb[]) { 7848 /* Enables internal speaker */ 7849 {0x20, AC_VERB_SET_COEF_INDEX, 0x45}, 7850 {0x20, AC_VERB_SET_PROC_COEF, 0x5289}, 7851 {0x20, AC_VERB_SET_COEF_INDEX, 0x4A}, 7852 {0x20, AC_VERB_SET_PROC_COEF, 0x001b}, 7853 {0x58, AC_VERB_SET_COEF_INDEX, 0x00}, 7854 {0x58, AC_VERB_SET_PROC_COEF, 0x3888}, 7855 {0x20, AC_VERB_SET_COEF_INDEX, 0x6f}, 7856 {0x20, AC_VERB_SET_PROC_COEF, 0x2c0b}, 7857 {} 7858 } 7859 }, 7860 [ALC274_FIXUP_DELL_BIND_DACS] = { 7861 .type = HDA_FIXUP_FUNC, 7862 .v.func = alc274_fixup_bind_dacs, 7863 .chained = true, 7864 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE 7865 }, 7866 [ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = { 7867 .type = HDA_FIXUP_PINS, 7868 .v.pins = (const struct hda_pintbl[]) { 7869 { 0x1b, 0x0401102f }, 7870 { } 7871 }, 7872 .chained = true, 7873 .chain_id = ALC274_FIXUP_DELL_BIND_DACS 7874 }, 7875 [ALC298_FIXUP_TPT470_DOCK_FIX] = { 7876 .type = HDA_FIXUP_FUNC, 7877 .v.func = alc_fixup_tpt470_dock, 7878 .chained = true, 7879 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE 7880 }, 7881 [ALC298_FIXUP_TPT470_DOCK] = { 7882 .type = HDA_FIXUP_FUNC, 7883 .v.func = alc_fixup_tpt470_dacs, 7884 .chained = true, 7885 .chain_id = ALC298_FIXUP_TPT470_DOCK_FIX 7886 }, 7887 [ALC255_FIXUP_DUMMY_LINEOUT_VERB] = { 7888 .type = HDA_FIXUP_PINS, 7889 .v.pins = (const struct hda_pintbl[]) { 7890 { 0x14, 0x0201101f }, 7891 { } 7892 }, 7893 .chained = true, 7894 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE 7895 }, 7896 [ALC255_FIXUP_DELL_HEADSET_MIC] = { 7897 .type = HDA_FIXUP_PINS, 7898 .v.pins = (const struct hda_pintbl[]) { 7899 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7900 { } 7901 }, 7902 .chained = true, 7903 .chain_id = ALC269_FIXUP_HEADSET_MIC 7904 }, 7905 [ALC295_FIXUP_HP_X360] = { 7906 .type = HDA_FIXUP_FUNC, 7907 .v.func = alc295_fixup_hp_top_speakers, 7908 .chained = true, 7909 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3 7910 }, 7911 [ALC221_FIXUP_HP_HEADSET_MIC] = { 7912 .type = HDA_FIXUP_PINS, 7913 .v.pins = (const struct hda_pintbl[]) { 7914 { 0x19, 0x0181313f}, 7915 { } 7916 }, 7917 .chained = true, 7918 .chain_id = ALC269_FIXUP_HEADSET_MIC 7919 }, 7920 [ALC285_FIXUP_LENOVO_HEADPHONE_NOISE] = { 7921 .type = HDA_FIXUP_FUNC, 7922 .v.func = alc285_fixup_invalidate_dacs, 7923 .chained = true, 7924 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 7925 }, 7926 [ALC295_FIXUP_HP_AUTO_MUTE] = { 7927 .type = HDA_FIXUP_FUNC, 7928 .v.func = alc_fixup_auto_mute_via_amp, 7929 }, 7930 [ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE] = { 7931 .type = HDA_FIXUP_PINS, 7932 .v.pins = (const struct hda_pintbl[]) { 7933 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7934 { } 7935 }, 7936 .chained = true, 7937 .chain_id = ALC269_FIXUP_HEADSET_MIC 7938 }, 7939 [ALC294_FIXUP_ASUS_MIC] = { 7940 .type = HDA_FIXUP_PINS, 7941 .v.pins = (const struct hda_pintbl[]) { 7942 { 0x13, 0x90a60160 }, /* use as internal mic */ 7943 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */ 7944 { } 7945 }, 7946 .chained = true, 7947 .chain_id = ALC269_FIXUP_HEADSET_MIC 7948 }, 7949 [ALC294_FIXUP_ASUS_HEADSET_MIC] = { 7950 .type = HDA_FIXUP_PINS, 7951 .v.pins = (const struct hda_pintbl[]) { 7952 { 0x19, 0x01a1103c }, /* use as headset mic */ 7953 { } 7954 }, 7955 .chained = true, 7956 .chain_id = ALC269_FIXUP_HEADSET_MIC 7957 }, 7958 [ALC294_FIXUP_ASUS_SPK] = { 7959 .type = HDA_FIXUP_VERBS, 7960 .v.verbs = (const struct hda_verb[]) { 7961 /* Set EAPD high */ 7962 { 0x20, AC_VERB_SET_COEF_INDEX, 0x40 }, 7963 { 0x20, AC_VERB_SET_PROC_COEF, 0x8800 }, 7964 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f }, 7965 { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 }, 7966 { } 7967 }, 7968 .chained = true, 7969 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC 7970 }, 7971 [ALC295_FIXUP_CHROME_BOOK] = { 7972 .type = HDA_FIXUP_FUNC, 7973 .v.func = alc295_fixup_chromebook, 7974 .chained = true, 7975 .chain_id = ALC225_FIXUP_HEADSET_JACK 7976 }, 7977 [ALC225_FIXUP_HEADSET_JACK] = { 7978 .type = HDA_FIXUP_FUNC, 7979 .v.func = alc_fixup_headset_jack, 7980 }, 7981 [ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = { 7982 .type = HDA_FIXUP_PINS, 7983 .v.pins = (const struct hda_pintbl[]) { 7984 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 7985 { } 7986 }, 7987 .chained = true, 7988 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 7989 }, 7990 [ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE] = { 7991 .type = HDA_FIXUP_VERBS, 7992 .v.verbs = (const struct hda_verb[]) { 7993 /* Disable PCBEEP-IN passthrough */ 7994 { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 }, 7995 { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 }, 7996 { } 7997 }, 7998 .chained = true, 7999 .chain_id = ALC285_FIXUP_LENOVO_HEADPHONE_NOISE 8000 }, 8001 [ALC255_FIXUP_ACER_HEADSET_MIC] = { 8002 .type = HDA_FIXUP_PINS, 8003 .v.pins = (const struct hda_pintbl[]) { 8004 { 0x19, 0x03a11130 }, 8005 { 0x1a, 0x90a60140 }, /* use as internal mic */ 8006 { } 8007 }, 8008 .chained = true, 8009 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC 8010 }, 8011 [ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE] = { 8012 .type = HDA_FIXUP_PINS, 8013 .v.pins = (const struct hda_pintbl[]) { 8014 { 0x16, 0x01011020 }, /* Rear Line out */ 8015 { 0x19, 0x01a1913c }, /* use as Front headset mic, without its own jack detect */ 8016 { } 8017 }, 8018 .chained = true, 8019 .chain_id = ALC225_FIXUP_WYSE_AUTO_MUTE 8020 }, 8021 [ALC225_FIXUP_WYSE_AUTO_MUTE] = { 8022 .type = HDA_FIXUP_FUNC, 8023 .v.func = alc_fixup_auto_mute_via_amp, 8024 .chained = true, 8025 .chain_id = ALC225_FIXUP_WYSE_DISABLE_MIC_VREF 8026 }, 8027 [ALC225_FIXUP_WYSE_DISABLE_MIC_VREF] = { 8028 .type = HDA_FIXUP_FUNC, 8029 .v.func = alc_fixup_disable_mic_vref, 8030 .chained = true, 8031 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 8032 }, 8033 [ALC286_FIXUP_ACER_AIO_HEADSET_MIC] = { 8034 .type = HDA_FIXUP_VERBS, 8035 .v.verbs = (const struct hda_verb[]) { 8036 { 0x20, AC_VERB_SET_COEF_INDEX, 0x4f }, 8037 { 0x20, AC_VERB_SET_PROC_COEF, 0x5029 }, 8038 { } 8039 }, 8040 .chained = true, 8041 .chain_id = ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE 8042 }, 8043 [ALC256_FIXUP_ASUS_HEADSET_MIC] = { 8044 .type = HDA_FIXUP_PINS, 8045 .v.pins = (const struct hda_pintbl[]) { 8046 { 0x19, 0x03a11020 }, /* headset mic with jack detect */ 8047 { } 8048 }, 8049 .chained = true, 8050 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 8051 }, 8052 [ALC256_FIXUP_ASUS_MIC_NO_PRESENCE] = { 8053 .type = HDA_FIXUP_PINS, 8054 .v.pins = (const struct hda_pintbl[]) { 8055 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */ 8056 { } 8057 }, 8058 .chained = true, 8059 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 8060 }, 8061 [ALC299_FIXUP_PREDATOR_SPK] = { 8062 .type = HDA_FIXUP_PINS, 8063 .v.pins = (const struct hda_pintbl[]) { 8064 { 0x21, 0x90170150 }, /* use as headset mic, without its own jack detect */ 8065 { } 8066 } 8067 }, 8068 [ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = { 8069 .type = HDA_FIXUP_PINS, 8070 .v.pins = (const struct hda_pintbl[]) { 8071 { 0x19, 0x04a11040 }, 8072 { 0x21, 0x04211020 }, 8073 { } 8074 }, 8075 .chained = true, 8076 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 8077 }, 8078 [ALC289_FIXUP_DELL_SPK2] = { 8079 .type = HDA_FIXUP_PINS, 8080 .v.pins = (const struct hda_pintbl[]) { 8081 { 0x17, 0x90170130 }, /* bass spk */ 8082 { } 8083 }, 8084 .chained = true, 8085 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE 8086 }, 8087 [ALC289_FIXUP_DUAL_SPK] = { 8088 .type = HDA_FIXUP_FUNC, 8089 .v.func = alc285_fixup_speaker2_to_dac1, 8090 .chained = true, 8091 .chain_id = ALC289_FIXUP_DELL_SPK2 8092 }, 8093 [ALC294_FIXUP_SPK2_TO_DAC1] = { 8094 .type = HDA_FIXUP_FUNC, 8095 .v.func = alc285_fixup_speaker2_to_dac1, 8096 .chained = true, 8097 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC 8098 }, 8099 [ALC294_FIXUP_ASUS_DUAL_SPK] = { 8100 .type = HDA_FIXUP_FUNC, 8101 /* The GPIO must be pulled to initialize the AMP */ 8102 .v.func = alc_fixup_gpio4, 8103 .chained = true, 8104 .chain_id = ALC294_FIXUP_SPK2_TO_DAC1 8105 }, 8106 [ALC285_FIXUP_THINKPAD_X1_GEN7] = { 8107 .type = HDA_FIXUP_FUNC, 8108 .v.func = alc285_fixup_thinkpad_x1_gen7, 8109 .chained = true, 8110 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 8111 }, 8112 [ALC285_FIXUP_THINKPAD_HEADSET_JACK] = { 8113 .type = HDA_FIXUP_FUNC, 8114 .v.func = alc_fixup_headset_jack, 8115 .chained = true, 8116 .chain_id = ALC285_FIXUP_THINKPAD_X1_GEN7 8117 }, 8118 [ALC294_FIXUP_ASUS_HPE] = { 8119 .type = HDA_FIXUP_VERBS, 8120 .v.verbs = (const struct hda_verb[]) { 8121 /* Set EAPD high */ 8122 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f }, 8123 { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 }, 8124 { } 8125 }, 8126 .chained = true, 8127 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC 8128 }, 8129 [ALC294_FIXUP_ASUS_GX502_PINS] = { 8130 .type = HDA_FIXUP_PINS, 8131 .v.pins = (const struct hda_pintbl[]) { 8132 { 0x19, 0x03a11050 }, /* front HP mic */ 8133 { 0x1a, 0x01a11830 }, /* rear external mic */ 8134 { 0x21, 0x03211020 }, /* front HP out */ 8135 { } 8136 }, 8137 .chained = true, 8138 .chain_id = ALC294_FIXUP_ASUS_GX502_VERBS 8139 }, 8140 [ALC294_FIXUP_ASUS_GX502_VERBS] = { 8141 .type = HDA_FIXUP_VERBS, 8142 .v.verbs = (const struct hda_verb[]) { 8143 /* set 0x15 to HP-OUT ctrl */ 8144 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 8145 /* unmute the 0x15 amp */ 8146 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 }, 8147 { } 8148 }, 8149 .chained = true, 8150 .chain_id = ALC294_FIXUP_ASUS_GX502_HP 8151 }, 8152 [ALC294_FIXUP_ASUS_GX502_HP] = { 8153 .type = HDA_FIXUP_FUNC, 8154 .v.func = alc294_fixup_gx502_hp, 8155 }, 8156 [ALC294_FIXUP_ASUS_GU502_PINS] = { 8157 .type = HDA_FIXUP_PINS, 8158 .v.pins = (const struct hda_pintbl[]) { 8159 { 0x19, 0x01a11050 }, /* rear HP mic */ 8160 { 0x1a, 0x01a11830 }, /* rear external mic */ 8161 { 0x21, 0x012110f0 }, /* rear HP out */ 8162 { } 8163 }, 8164 .chained = true, 8165 .chain_id = ALC294_FIXUP_ASUS_GU502_VERBS 8166 }, 8167 [ALC294_FIXUP_ASUS_GU502_VERBS] = { 8168 .type = HDA_FIXUP_VERBS, 8169 .v.verbs = (const struct hda_verb[]) { 8170 /* set 0x15 to HP-OUT ctrl */ 8171 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 8172 /* unmute the 0x15 amp */ 8173 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 }, 8174 /* set 0x1b to HP-OUT */ 8175 { 0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 8176 { } 8177 }, 8178 .chained = true, 8179 .chain_id = ALC294_FIXUP_ASUS_GU502_HP 8180 }, 8181 [ALC294_FIXUP_ASUS_GU502_HP] = { 8182 .type = HDA_FIXUP_FUNC, 8183 .v.func = alc294_fixup_gu502_hp, 8184 }, 8185 [ALC294_FIXUP_ASUS_COEF_1B] = { 8186 .type = HDA_FIXUP_VERBS, 8187 .v.verbs = (const struct hda_verb[]) { 8188 /* Set bit 10 to correct noisy output after reboot from 8189 * Windows 10 (due to pop noise reduction?) 8190 */ 8191 { 0x20, AC_VERB_SET_COEF_INDEX, 0x1b }, 8192 { 0x20, AC_VERB_SET_PROC_COEF, 0x4e4b }, 8193 { } 8194 }, 8195 .chained = true, 8196 .chain_id = ALC289_FIXUP_ASUS_GA401, 8197 }, 8198 [ALC285_FIXUP_HP_GPIO_LED] = { 8199 .type = HDA_FIXUP_FUNC, 8200 .v.func = alc285_fixup_hp_gpio_led, 8201 }, 8202 [ALC285_FIXUP_HP_MUTE_LED] = { 8203 .type = HDA_FIXUP_FUNC, 8204 .v.func = alc285_fixup_hp_mute_led, 8205 }, 8206 [ALC236_FIXUP_HP_GPIO_LED] = { 8207 .type = HDA_FIXUP_FUNC, 8208 .v.func = alc236_fixup_hp_gpio_led, 8209 }, 8210 [ALC236_FIXUP_HP_MUTE_LED] = { 8211 .type = HDA_FIXUP_FUNC, 8212 .v.func = alc236_fixup_hp_mute_led, 8213 }, 8214 [ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF] = { 8215 .type = HDA_FIXUP_FUNC, 8216 .v.func = alc236_fixup_hp_mute_led_micmute_vref, 8217 }, 8218 [ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = { 8219 .type = HDA_FIXUP_VERBS, 8220 .v.verbs = (const struct hda_verb[]) { 8221 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc5 }, 8222 { } 8223 }, 8224 }, 8225 [ALC295_FIXUP_ASUS_MIC_NO_PRESENCE] = { 8226 .type = HDA_FIXUP_PINS, 8227 .v.pins = (const struct hda_pintbl[]) { 8228 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8229 { } 8230 }, 8231 .chained = true, 8232 .chain_id = ALC269_FIXUP_HEADSET_MODE 8233 }, 8234 [ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS] = { 8235 .type = HDA_FIXUP_PINS, 8236 .v.pins = (const struct hda_pintbl[]) { 8237 { 0x14, 0x90100120 }, /* use as internal speaker */ 8238 { 0x18, 0x02a111f0 }, /* use as headset mic, without its own jack detect */ 8239 { 0x1a, 0x01011020 }, /* use as line out */ 8240 { }, 8241 }, 8242 .chained = true, 8243 .chain_id = ALC269_FIXUP_HEADSET_MIC 8244 }, 8245 [ALC269VC_FIXUP_ACER_HEADSET_MIC] = { 8246 .type = HDA_FIXUP_PINS, 8247 .v.pins = (const struct hda_pintbl[]) { 8248 { 0x18, 0x02a11030 }, /* use as headset mic */ 8249 { } 8250 }, 8251 .chained = true, 8252 .chain_id = ALC269_FIXUP_HEADSET_MIC 8253 }, 8254 [ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE] = { 8255 .type = HDA_FIXUP_PINS, 8256 .v.pins = (const struct hda_pintbl[]) { 8257 { 0x18, 0x01a11130 }, /* use as headset mic, without its own jack detect */ 8258 { } 8259 }, 8260 .chained = true, 8261 .chain_id = ALC269_FIXUP_HEADSET_MIC 8262 }, 8263 [ALC289_FIXUP_ASUS_GA401] = { 8264 .type = HDA_FIXUP_FUNC, 8265 .v.func = alc289_fixup_asus_ga401, 8266 .chained = true, 8267 .chain_id = ALC289_FIXUP_ASUS_GA502, 8268 }, 8269 [ALC289_FIXUP_ASUS_GA502] = { 8270 .type = HDA_FIXUP_PINS, 8271 .v.pins = (const struct hda_pintbl[]) { 8272 { 0x19, 0x03a11020 }, /* headset mic with jack detect */ 8273 { } 8274 }, 8275 }, 8276 [ALC256_FIXUP_ACER_MIC_NO_PRESENCE] = { 8277 .type = HDA_FIXUP_PINS, 8278 .v.pins = (const struct hda_pintbl[]) { 8279 { 0x19, 0x02a11120 }, /* use as headset mic, without its own jack detect */ 8280 { } 8281 }, 8282 .chained = true, 8283 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE 8284 }, 8285 [ALC285_FIXUP_HP_GPIO_AMP_INIT] = { 8286 .type = HDA_FIXUP_FUNC, 8287 .v.func = alc285_fixup_hp_gpio_amp_init, 8288 .chained = true, 8289 .chain_id = ALC285_FIXUP_HP_GPIO_LED 8290 }, 8291 [ALC269_FIXUP_CZC_B20] = { 8292 .type = HDA_FIXUP_PINS, 8293 .v.pins = (const struct hda_pintbl[]) { 8294 { 0x12, 0x411111f0 }, 8295 { 0x14, 0x90170110 }, /* speaker */ 8296 { 0x15, 0x032f1020 }, /* HP out */ 8297 { 0x17, 0x411111f0 }, 8298 { 0x18, 0x03ab1040 }, /* mic */ 8299 { 0x19, 0xb7a7013f }, 8300 { 0x1a, 0x0181305f }, 8301 { 0x1b, 0x411111f0 }, 8302 { 0x1d, 0x411111f0 }, 8303 { 0x1e, 0x411111f0 }, 8304 { } 8305 }, 8306 .chain_id = ALC269_FIXUP_DMIC, 8307 }, 8308 [ALC269_FIXUP_CZC_TMI] = { 8309 .type = HDA_FIXUP_PINS, 8310 .v.pins = (const struct hda_pintbl[]) { 8311 { 0x12, 0x4000c000 }, 8312 { 0x14, 0x90170110 }, /* speaker */ 8313 { 0x15, 0x0421401f }, /* HP out */ 8314 { 0x17, 0x411111f0 }, 8315 { 0x18, 0x04a19020 }, /* mic */ 8316 { 0x19, 0x411111f0 }, 8317 { 0x1a, 0x411111f0 }, 8318 { 0x1b, 0x411111f0 }, 8319 { 0x1d, 0x40448505 }, 8320 { 0x1e, 0x411111f0 }, 8321 { 0x20, 0x8000ffff }, 8322 { } 8323 }, 8324 .chain_id = ALC269_FIXUP_DMIC, 8325 }, 8326 [ALC269_FIXUP_CZC_L101] = { 8327 .type = HDA_FIXUP_PINS, 8328 .v.pins = (const struct hda_pintbl[]) { 8329 { 0x12, 0x40000000 }, 8330 { 0x14, 0x01014010 }, /* speaker */ 8331 { 0x15, 0x411111f0 }, /* HP out */ 8332 { 0x16, 0x411111f0 }, 8333 { 0x18, 0x01a19020 }, /* mic */ 8334 { 0x19, 0x02a19021 }, 8335 { 0x1a, 0x0181302f }, 8336 { 0x1b, 0x0221401f }, 8337 { 0x1c, 0x411111f0 }, 8338 { 0x1d, 0x4044c601 }, 8339 { 0x1e, 0x411111f0 }, 8340 { } 8341 }, 8342 .chain_id = ALC269_FIXUP_DMIC, 8343 }, 8344 [ALC269_FIXUP_LEMOTE_A1802] = { 8345 .type = HDA_FIXUP_PINS, 8346 .v.pins = (const struct hda_pintbl[]) { 8347 { 0x12, 0x40000000 }, 8348 { 0x14, 0x90170110 }, /* speaker */ 8349 { 0x17, 0x411111f0 }, 8350 { 0x18, 0x03a19040 }, /* mic1 */ 8351 { 0x19, 0x90a70130 }, /* mic2 */ 8352 { 0x1a, 0x411111f0 }, 8353 { 0x1b, 0x411111f0 }, 8354 { 0x1d, 0x40489d2d }, 8355 { 0x1e, 0x411111f0 }, 8356 { 0x20, 0x0003ffff }, 8357 { 0x21, 0x03214020 }, 8358 { } 8359 }, 8360 .chain_id = ALC269_FIXUP_DMIC, 8361 }, 8362 [ALC269_FIXUP_LEMOTE_A190X] = { 8363 .type = HDA_FIXUP_PINS, 8364 .v.pins = (const struct hda_pintbl[]) { 8365 { 0x14, 0x99130110 }, /* speaker */ 8366 { 0x15, 0x0121401f }, /* HP out */ 8367 { 0x18, 0x01a19c20 }, /* rear mic */ 8368 { 0x19, 0x99a3092f }, /* front mic */ 8369 { 0x1b, 0x0201401f }, /* front lineout */ 8370 { } 8371 }, 8372 .chain_id = ALC269_FIXUP_DMIC, 8373 }, 8374 [ALC256_FIXUP_INTEL_NUC8_RUGGED] = { 8375 .type = HDA_FIXUP_PINS, 8376 .v.pins = (const struct hda_pintbl[]) { 8377 { 0x1b, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8378 { } 8379 }, 8380 .chained = true, 8381 .chain_id = ALC269_FIXUP_HEADSET_MODE 8382 }, 8383 [ALC256_FIXUP_INTEL_NUC10] = { 8384 .type = HDA_FIXUP_PINS, 8385 .v.pins = (const struct hda_pintbl[]) { 8386 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8387 { } 8388 }, 8389 .chained = true, 8390 .chain_id = ALC269_FIXUP_HEADSET_MODE 8391 }, 8392 [ALC255_FIXUP_XIAOMI_HEADSET_MIC] = { 8393 .type = HDA_FIXUP_VERBS, 8394 .v.verbs = (const struct hda_verb[]) { 8395 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 }, 8396 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 }, 8397 { } 8398 }, 8399 .chained = true, 8400 .chain_id = ALC289_FIXUP_ASUS_GA502 8401 }, 8402 [ALC274_FIXUP_HP_MIC] = { 8403 .type = HDA_FIXUP_VERBS, 8404 .v.verbs = (const struct hda_verb[]) { 8405 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 }, 8406 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 }, 8407 { } 8408 }, 8409 }, 8410 [ALC274_FIXUP_HP_HEADSET_MIC] = { 8411 .type = HDA_FIXUP_FUNC, 8412 .v.func = alc274_fixup_hp_headset_mic, 8413 .chained = true, 8414 .chain_id = ALC274_FIXUP_HP_MIC 8415 }, 8416 [ALC274_FIXUP_HP_ENVY_GPIO] = { 8417 .type = HDA_FIXUP_FUNC, 8418 .v.func = alc274_fixup_hp_envy_gpio, 8419 }, 8420 [ALC256_FIXUP_ASUS_HPE] = { 8421 .type = HDA_FIXUP_VERBS, 8422 .v.verbs = (const struct hda_verb[]) { 8423 /* Set EAPD high */ 8424 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f }, 8425 { 0x20, AC_VERB_SET_PROC_COEF, 0x7778 }, 8426 { } 8427 }, 8428 .chained = true, 8429 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC 8430 }, 8431 [ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK] = { 8432 .type = HDA_FIXUP_FUNC, 8433 .v.func = alc_fixup_headset_jack, 8434 .chained = true, 8435 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 8436 }, 8437 [ALC287_FIXUP_HP_GPIO_LED] = { 8438 .type = HDA_FIXUP_FUNC, 8439 .v.func = alc287_fixup_hp_gpio_led, 8440 }, 8441 [ALC256_FIXUP_HP_HEADSET_MIC] = { 8442 .type = HDA_FIXUP_FUNC, 8443 .v.func = alc274_fixup_hp_headset_mic, 8444 }, 8445 [ALC236_FIXUP_DELL_AIO_HEADSET_MIC] = { 8446 .type = HDA_FIXUP_FUNC, 8447 .v.func = alc_fixup_no_int_mic, 8448 .chained = true, 8449 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE 8450 }, 8451 [ALC282_FIXUP_ACER_DISABLE_LINEOUT] = { 8452 .type = HDA_FIXUP_PINS, 8453 .v.pins = (const struct hda_pintbl[]) { 8454 { 0x1b, 0x411111f0 }, 8455 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 8456 { }, 8457 }, 8458 .chained = true, 8459 .chain_id = ALC269_FIXUP_HEADSET_MODE 8460 }, 8461 [ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST] = { 8462 .type = HDA_FIXUP_FUNC, 8463 .v.func = alc269_fixup_limit_int_mic_boost, 8464 .chained = true, 8465 .chain_id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, 8466 }, 8467 [ALC256_FIXUP_ACER_HEADSET_MIC] = { 8468 .type = HDA_FIXUP_PINS, 8469 .v.pins = (const struct hda_pintbl[]) { 8470 { 0x19, 0x02a1113c }, /* use as headset mic, without its own jack detect */ 8471 { 0x1a, 0x90a1092f }, /* use as internal mic */ 8472 { } 8473 }, 8474 .chained = true, 8475 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 8476 }, 8477 [ALC285_FIXUP_IDEAPAD_S740_COEF] = { 8478 .type = HDA_FIXUP_FUNC, 8479 .v.func = alc285_fixup_ideapad_s740_coef, 8480 .chained = true, 8481 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 8482 }, 8483 [ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST] = { 8484 .type = HDA_FIXUP_FUNC, 8485 .v.func = alc269_fixup_limit_int_mic_boost, 8486 .chained = true, 8487 .chain_id = ALC285_FIXUP_HP_MUTE_LED, 8488 }, 8489 [ALC295_FIXUP_ASUS_DACS] = { 8490 .type = HDA_FIXUP_FUNC, 8491 .v.func = alc295_fixup_asus_dacs, 8492 }, 8493 [ALC295_FIXUP_HP_OMEN] = { 8494 .type = HDA_FIXUP_PINS, 8495 .v.pins = (const struct hda_pintbl[]) { 8496 { 0x12, 0xb7a60130 }, 8497 { 0x13, 0x40000000 }, 8498 { 0x14, 0x411111f0 }, 8499 { 0x16, 0x411111f0 }, 8500 { 0x17, 0x90170110 }, 8501 { 0x18, 0x411111f0 }, 8502 { 0x19, 0x02a11030 }, 8503 { 0x1a, 0x411111f0 }, 8504 { 0x1b, 0x04a19030 }, 8505 { 0x1d, 0x40600001 }, 8506 { 0x1e, 0x411111f0 }, 8507 { 0x21, 0x03211020 }, 8508 {} 8509 }, 8510 .chained = true, 8511 .chain_id = ALC269_FIXUP_HP_LINE1_MIC1_LED, 8512 }, 8513 [ALC285_FIXUP_HP_SPECTRE_X360] = { 8514 .type = HDA_FIXUP_FUNC, 8515 .v.func = alc285_fixup_hp_spectre_x360, 8516 }, 8517 [ALC285_FIXUP_HP_SPECTRE_X360_EB1] = { 8518 .type = HDA_FIXUP_FUNC, 8519 .v.func = alc285_fixup_hp_spectre_x360_eb1 8520 }, 8521 [ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP] = { 8522 .type = HDA_FIXUP_FUNC, 8523 .v.func = alc285_fixup_ideapad_s740_coef, 8524 .chained = true, 8525 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK, 8526 }, 8527 [ALC623_FIXUP_LENOVO_THINKSTATION_P340] = { 8528 .type = HDA_FIXUP_FUNC, 8529 .v.func = alc_fixup_no_shutup, 8530 .chained = true, 8531 .chain_id = ALC283_FIXUP_HEADSET_MIC, 8532 }, 8533 [ALC255_FIXUP_ACER_HEADPHONE_AND_MIC] = { 8534 .type = HDA_FIXUP_PINS, 8535 .v.pins = (const struct hda_pintbl[]) { 8536 { 0x21, 0x03211030 }, /* Change the Headphone location to Left */ 8537 { } 8538 }, 8539 .chained = true, 8540 .chain_id = ALC255_FIXUP_XIAOMI_HEADSET_MIC 8541 }, 8542 [ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST] = { 8543 .type = HDA_FIXUP_FUNC, 8544 .v.func = alc269_fixup_limit_int_mic_boost, 8545 .chained = true, 8546 .chain_id = ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF, 8547 }, 8548 [ALC285_FIXUP_LEGION_Y9000X_SPEAKERS] = { 8549 .type = HDA_FIXUP_FUNC, 8550 .v.func = alc285_fixup_ideapad_s740_coef, 8551 .chained = true, 8552 .chain_id = ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE, 8553 }, 8554 [ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE] = { 8555 .type = HDA_FIXUP_FUNC, 8556 .v.func = alc287_fixup_legion_15imhg05_speakers, 8557 .chained = true, 8558 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 8559 }, 8560 [ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS] = { 8561 .type = HDA_FIXUP_VERBS, 8562 //.v.verbs = legion_15imhg05_coefs, 8563 .v.verbs = (const struct hda_verb[]) { 8564 // set left speaker Legion 7i. 8565 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 8566 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 }, 8567 8568 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 8569 { 0x20, AC_VERB_SET_PROC_COEF, 0xc }, 8570 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 8571 { 0x20, AC_VERB_SET_PROC_COEF, 0x1a }, 8572 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 8573 8574 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 8575 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 8576 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 8577 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 8578 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 8579 8580 // set right speaker Legion 7i. 8581 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 8582 { 0x20, AC_VERB_SET_PROC_COEF, 0x42 }, 8583 8584 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 8585 { 0x20, AC_VERB_SET_PROC_COEF, 0xc }, 8586 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 8587 { 0x20, AC_VERB_SET_PROC_COEF, 0x2a }, 8588 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 8589 8590 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 8591 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 8592 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 8593 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 8594 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 8595 {} 8596 }, 8597 .chained = true, 8598 .chain_id = ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE, 8599 }, 8600 [ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE] = { 8601 .type = HDA_FIXUP_FUNC, 8602 .v.func = alc287_fixup_legion_15imhg05_speakers, 8603 .chained = true, 8604 .chain_id = ALC269_FIXUP_HEADSET_MODE, 8605 }, 8606 [ALC287_FIXUP_YOGA7_14ITL_SPEAKERS] = { 8607 .type = HDA_FIXUP_VERBS, 8608 .v.verbs = (const struct hda_verb[]) { 8609 // set left speaker Yoga 7i. 8610 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 8611 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 }, 8612 8613 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 8614 { 0x20, AC_VERB_SET_PROC_COEF, 0xc }, 8615 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 8616 { 0x20, AC_VERB_SET_PROC_COEF, 0x1a }, 8617 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 8618 8619 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 8620 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 8621 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 8622 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 8623 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 8624 8625 // set right speaker Yoga 7i. 8626 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 8627 { 0x20, AC_VERB_SET_PROC_COEF, 0x46 }, 8628 8629 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 8630 { 0x20, AC_VERB_SET_PROC_COEF, 0xc }, 8631 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 8632 { 0x20, AC_VERB_SET_PROC_COEF, 0x2a }, 8633 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 8634 8635 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 8636 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 8637 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 8638 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 8639 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 8640 {} 8641 }, 8642 .chained = true, 8643 .chain_id = ALC269_FIXUP_HEADSET_MODE, 8644 }, 8645 [ALC287_FIXUP_13S_GEN2_SPEAKERS] = { 8646 .type = HDA_FIXUP_VERBS, 8647 .v.verbs = (const struct hda_verb[]) { 8648 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 8649 { 0x20, AC_VERB_SET_PROC_COEF, 0x41 }, 8650 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 8651 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 8652 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 8653 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 8654 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 8655 { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, 8656 { 0x20, AC_VERB_SET_PROC_COEF, 0x42 }, 8657 { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, 8658 { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, 8659 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 8660 { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, 8661 { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, 8662 {} 8663 }, 8664 .chained = true, 8665 .chain_id = ALC269_FIXUP_HEADSET_MODE, 8666 }, 8667 [ALC256_FIXUP_SET_COEF_DEFAULTS] = { 8668 .type = HDA_FIXUP_FUNC, 8669 .v.func = alc256_fixup_set_coef_defaults, 8670 }, 8671 [ALC245_FIXUP_HP_GPIO_LED] = { 8672 .type = HDA_FIXUP_FUNC, 8673 .v.func = alc245_fixup_hp_gpio_led, 8674 }, 8675 [ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = { 8676 .type = HDA_FIXUP_PINS, 8677 .v.pins = (const struct hda_pintbl[]) { 8678 { 0x19, 0x03a11120 }, /* use as headset mic, without its own jack detect */ 8679 { } 8680 }, 8681 .chained = true, 8682 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, 8683 }, 8684 [ALC233_FIXUP_NO_AUDIO_JACK] = { 8685 .type = HDA_FIXUP_FUNC, 8686 .v.func = alc233_fixup_no_audio_jack, 8687 }, 8688 [ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME] = { 8689 .type = HDA_FIXUP_FUNC, 8690 .v.func = alc256_fixup_mic_no_presence_and_resume, 8691 .chained = true, 8692 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 8693 }, 8694 [ALC287_FIXUP_LEGION_16ACHG6] = { 8695 .type = HDA_FIXUP_FUNC, 8696 .v.func = alc287_fixup_legion_16achg6_speakers, 8697 }, 8698 [ALC287_FIXUP_CS35L41_I2C_2] = { 8699 .type = HDA_FIXUP_FUNC, 8700 .v.func = cs35l41_fixup_i2c_two, 8701 }, 8702 [ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED] = { 8703 .type = HDA_FIXUP_VERBS, 8704 .v.verbs = (const struct hda_verb[]) { 8705 { 0x20, AC_VERB_SET_COEF_INDEX, 0x19 }, 8706 { 0x20, AC_VERB_SET_PROC_COEF, 0x8e11 }, 8707 { } 8708 }, 8709 .chained = true, 8710 .chain_id = ALC285_FIXUP_HP_MUTE_LED, 8711 }, 8712 }; 8713 8714 static const struct snd_pci_quirk alc269_fixup_tbl[] = { 8715 SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC), 8716 SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC), 8717 SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC), 8718 SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700), 8719 SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC), 8720 SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK), 8721 SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK), 8722 SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572), 8723 SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572), 8724 SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS), 8725 SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC), 8726 SND_PCI_QUIRK(0x1025, 0x0840, "Acer Aspire E1", ALC269VB_FIXUP_ASPIRE_E1_COEF), 8727 SND_PCI_QUIRK(0x1025, 0x101c, "Acer Veriton N2510G", ALC269_FIXUP_LIFEBOOK), 8728 SND_PCI_QUIRK(0x1025, 0x102b, "Acer Aspire C24-860", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE), 8729 SND_PCI_QUIRK(0x1025, 0x1065, "Acer Aspire C20-820", ALC269VC_FIXUP_ACER_HEADSET_MIC), 8730 SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK), 8731 SND_PCI_QUIRK(0x1025, 0x1094, "Acer Aspire E5-575T", ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST), 8732 SND_PCI_QUIRK(0x1025, 0x1099, "Acer Aspire E5-523G", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 8733 SND_PCI_QUIRK(0x1025, 0x110e, "Acer Aspire ES1-432", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 8734 SND_PCI_QUIRK(0x1025, 0x1166, "Acer Veriton N4640G", ALC269_FIXUP_LIFEBOOK), 8735 SND_PCI_QUIRK(0x1025, 0x1167, "Acer Veriton N6640G", ALC269_FIXUP_LIFEBOOK), 8736 SND_PCI_QUIRK(0x1025, 0x1246, "Acer Predator Helios 500", ALC299_FIXUP_PREDATOR_SPK), 8737 SND_PCI_QUIRK(0x1025, 0x1247, "Acer vCopperbox", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS), 8738 SND_PCI_QUIRK(0x1025, 0x1248, "Acer Veriton N4660G", ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE), 8739 SND_PCI_QUIRK(0x1025, 0x1269, "Acer SWIFT SF314-54", ALC256_FIXUP_ACER_HEADSET_MIC), 8740 SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), 8741 SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), 8742 SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), 8743 SND_PCI_QUIRK(0x1025, 0x129c, "Acer SWIFT SF314-55", ALC256_FIXUP_ACER_HEADSET_MIC), 8744 SND_PCI_QUIRK(0x1025, 0x1300, "Acer SWIFT SF314-56", ALC256_FIXUP_ACER_MIC_NO_PRESENCE), 8745 SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC), 8746 SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC), 8747 SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC), 8748 SND_PCI_QUIRK(0x1025, 0x141f, "Acer Spin SP513-54N", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 8749 SND_PCI_QUIRK(0x1025, 0x142b, "Acer Swift SF314-42", ALC255_FIXUP_ACER_MIC_NO_PRESENCE), 8750 SND_PCI_QUIRK(0x1025, 0x1430, "Acer TravelMate B311R-31", ALC256_FIXUP_ACER_MIC_NO_PRESENCE), 8751 SND_PCI_QUIRK(0x1025, 0x1466, "Acer Aspire A515-56", ALC255_FIXUP_ACER_HEADPHONE_AND_MIC), 8752 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z), 8753 SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS), 8754 SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X), 8755 SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X), 8756 SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X), 8757 SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X), 8758 SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER), 8759 SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE), 8760 SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE), 8761 SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE), 8762 SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK), 8763 SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK), 8764 SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X), 8765 SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X), 8766 SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK), 8767 SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 8768 SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 8769 SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13), 8770 SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE), 8771 SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK), 8772 SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE), 8773 SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 8774 SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 8775 SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 8776 SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 8777 SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 8778 SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 8779 SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 8780 SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER), 8781 SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE), 8782 SND_PCI_QUIRK(0x1028, 0x0738, "Dell Precision 5820", ALC269_FIXUP_NO_SHUTUP), 8783 SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME), 8784 SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME), 8785 SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER), 8786 SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3), 8787 SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE), 8788 SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB), 8789 SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB), 8790 SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC), 8791 SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC), 8792 SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB), 8793 SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE), 8794 SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE), 8795 SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB), 8796 SND_PCI_QUIRK(0x1028, 0x097d, "Dell Precision", ALC289_FIXUP_DUAL_SPK), 8797 SND_PCI_QUIRK(0x1028, 0x097e, "Dell Precision", ALC289_FIXUP_DUAL_SPK), 8798 SND_PCI_QUIRK(0x1028, 0x098d, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE), 8799 SND_PCI_QUIRK(0x1028, 0x09bf, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE), 8800 SND_PCI_QUIRK(0x1028, 0x0a2e, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC), 8801 SND_PCI_QUIRK(0x1028, 0x0a30, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC), 8802 SND_PCI_QUIRK(0x1028, 0x0a58, "Dell", ALC255_FIXUP_DELL_HEADSET_MIC), 8803 SND_PCI_QUIRK(0x1028, 0x0a61, "Dell XPS 15 9510", ALC289_FIXUP_DUAL_SPK), 8804 SND_PCI_QUIRK(0x1028, 0x0a62, "Dell Precision 5560", ALC289_FIXUP_DUAL_SPK), 8805 SND_PCI_QUIRK(0x1028, 0x0a9d, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE), 8806 SND_PCI_QUIRK(0x1028, 0x0a9e, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE), 8807 SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 8808 SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 8809 SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2), 8810 SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED), 8811 SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED), 8812 SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8813 SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8814 SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8815 SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 8816 SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC), 8817 SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 8818 SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 8819 SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 8820 SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 8821 SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 8822 SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 8823 SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 8824 SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 8825 SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 8826 SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 8827 SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 8828 SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 8829 SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 8830 SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED), 8831 SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY), 8832 SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8833 SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8834 SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8835 SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8836 SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8837 SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8838 SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8839 SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8840 SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED), 8841 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 8842 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS), 8843 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 8844 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS), 8845 SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 8846 SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8847 SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8848 SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8849 SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8850 SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8851 SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8852 SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8853 SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8854 SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8855 SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8856 SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8857 SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8858 SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8859 SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M), 8860 SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 8861 SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 8862 SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8863 SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8864 SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8865 SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 8866 SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE), 8867 SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE), 8868 SND_PCI_QUIRK(0x103c, 0x8077, "HP", ALC256_FIXUP_HP_HEADSET_MIC), 8869 SND_PCI_QUIRK(0x103c, 0x8158, "HP", ALC256_FIXUP_HP_HEADSET_MIC), 8870 SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3), 8871 SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC), 8872 SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360), 8873 SND_PCI_QUIRK(0x103c, 0x827f, "HP x360", ALC269_FIXUP_HP_MUTE_LED_MIC3), 8874 SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE), 8875 SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE), 8876 SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3), 8877 SND_PCI_QUIRK(0x103c, 0x841c, "HP Pavilion 15-CK0xx", ALC269_FIXUP_HP_MUTE_LED_MIC3), 8878 SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3), 8879 SND_PCI_QUIRK(0x103c, 0x84da, "HP OMEN dc0019-ur", ALC295_FIXUP_HP_OMEN), 8880 SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3), 8881 SND_PCI_QUIRK(0x103c, 0x8519, "HP Spectre x360 15-df0xxx", ALC285_FIXUP_HP_SPECTRE_X360), 8882 SND_PCI_QUIRK(0x103c, 0x860f, "HP ZBook 15 G6", ALC285_FIXUP_HP_GPIO_AMP_INIT), 8883 SND_PCI_QUIRK(0x103c, 0x861f, "HP Elite Dragonfly G1", ALC285_FIXUP_HP_GPIO_AMP_INIT), 8884 SND_PCI_QUIRK(0x103c, 0x869d, "HP", ALC236_FIXUP_HP_MUTE_LED), 8885 SND_PCI_QUIRK(0x103c, 0x86c7, "HP Envy AiO 32", ALC274_FIXUP_HP_ENVY_GPIO), 8886 SND_PCI_QUIRK(0x103c, 0x8716, "HP Elite Dragonfly G2 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT), 8887 SND_PCI_QUIRK(0x103c, 0x8720, "HP EliteBook x360 1040 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT), 8888 SND_PCI_QUIRK(0x103c, 0x8724, "HP EliteBook 850 G7", ALC285_FIXUP_HP_GPIO_LED), 8889 SND_PCI_QUIRK(0x103c, 0x8728, "HP EliteBook 840 G7", ALC285_FIXUP_HP_GPIO_LED), 8890 SND_PCI_QUIRK(0x103c, 0x8729, "HP", ALC285_FIXUP_HP_GPIO_LED), 8891 SND_PCI_QUIRK(0x103c, 0x8730, "HP ProBook 445 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 8892 SND_PCI_QUIRK(0x103c, 0x8735, "HP ProBook 435 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 8893 SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_AMP_INIT), 8894 SND_PCI_QUIRK(0x103c, 0x8760, "HP", ALC285_FIXUP_HP_MUTE_LED), 8895 SND_PCI_QUIRK(0x103c, 0x877a, "HP", ALC285_FIXUP_HP_MUTE_LED), 8896 SND_PCI_QUIRK(0x103c, 0x877d, "HP", ALC236_FIXUP_HP_MUTE_LED), 8897 SND_PCI_QUIRK(0x103c, 0x8780, "HP ZBook Fury 17 G7 Mobile Workstation", 8898 ALC285_FIXUP_HP_GPIO_AMP_INIT), 8899 SND_PCI_QUIRK(0x103c, 0x8783, "HP ZBook Fury 15 G7 Mobile Workstation", 8900 ALC285_FIXUP_HP_GPIO_AMP_INIT), 8901 SND_PCI_QUIRK(0x103c, 0x8788, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED), 8902 SND_PCI_QUIRK(0x103c, 0x87c8, "HP", ALC287_FIXUP_HP_GPIO_LED), 8903 SND_PCI_QUIRK(0x103c, 0x87e5, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 8904 SND_PCI_QUIRK(0x103c, 0x87e7, "HP ProBook 450 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 8905 SND_PCI_QUIRK(0x103c, 0x87f1, "HP ProBook 630 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 8906 SND_PCI_QUIRK(0x103c, 0x87f2, "HP ProBook 640 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 8907 SND_PCI_QUIRK(0x103c, 0x87f4, "HP", ALC287_FIXUP_HP_GPIO_LED), 8908 SND_PCI_QUIRK(0x103c, 0x87f5, "HP", ALC287_FIXUP_HP_GPIO_LED), 8909 SND_PCI_QUIRK(0x103c, 0x87f6, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP), 8910 SND_PCI_QUIRK(0x103c, 0x87f7, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP), 8911 SND_PCI_QUIRK(0x103c, 0x8805, "HP ProBook 650 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED), 8912 SND_PCI_QUIRK(0x103c, 0x880d, "HP EliteBook 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED), 8913 SND_PCI_QUIRK(0x103c, 0x8811, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1), 8914 SND_PCI_QUIRK(0x103c, 0x8812, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1), 8915 SND_PCI_QUIRK(0x103c, 0x8846, "HP EliteBook 850 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED), 8916 SND_PCI_QUIRK(0x103c, 0x8847, "HP EliteBook x360 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED), 8917 SND_PCI_QUIRK(0x103c, 0x884b, "HP EliteBook 840 Aero G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED), 8918 SND_PCI_QUIRK(0x103c, 0x884c, "HP EliteBook 840 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED), 8919 SND_PCI_QUIRK(0x103c, 0x8862, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST), 8920 SND_PCI_QUIRK(0x103c, 0x8863, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST), 8921 SND_PCI_QUIRK(0x103c, 0x886d, "HP ZBook Fury 17.3 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT), 8922 SND_PCI_QUIRK(0x103c, 0x8870, "HP ZBook Fury 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT), 8923 SND_PCI_QUIRK(0x103c, 0x8873, "HP ZBook Studio 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT), 8924 SND_PCI_QUIRK(0x103c, 0x888d, "HP ZBook Power 15.6 inch G8 Mobile Workstation PC", ALC236_FIXUP_HP_GPIO_LED), 8925 SND_PCI_QUIRK(0x103c, 0x8895, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED), 8926 SND_PCI_QUIRK(0x103c, 0x8896, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_MUTE_LED), 8927 SND_PCI_QUIRK(0x103c, 0x8898, "HP EliteBook 845 G8 Notebook PC", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST), 8928 SND_PCI_QUIRK(0x103c, 0x88d0, "HP Pavilion 15-eh1xxx (mainboard 88D0)", ALC287_FIXUP_HP_GPIO_LED), 8929 SND_PCI_QUIRK(0x103c, 0x89c3, "HP", ALC285_FIXUP_HP_GPIO_LED), 8930 SND_PCI_QUIRK(0x103c, 0x89ca, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF), 8931 SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC), 8932 SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300), 8933 SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 8934 SND_PCI_QUIRK(0x1043, 0x10a1, "ASUS UX391UA", ALC294_FIXUP_ASUS_SPK), 8935 SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC), 8936 SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE), 8937 SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 8938 SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE), 8939 SND_PCI_QUIRK(0x1043, 0x125e, "ASUS Q524UQK", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE), 8940 SND_PCI_QUIRK(0x1043, 0x1271, "ASUS X430UN", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE), 8941 SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE), 8942 SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE), 8943 SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC), 8944 SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC), 8945 SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC), 8946 SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK), 8947 SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A), 8948 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC), 8949 SND_PCI_QUIRK(0x1043, 0x1740, "ASUS UX430UA", ALC295_FIXUP_ASUS_DACS), 8950 SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_DUAL_SPK), 8951 SND_PCI_QUIRK(0x1043, 0x1662, "ASUS GV301QH", ALC294_FIXUP_ASUS_DUAL_SPK), 8952 SND_PCI_QUIRK(0x1043, 0x1881, "ASUS Zephyrus S/M", ALC294_FIXUP_ASUS_GX502_PINS), 8953 SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC), 8954 SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC), 8955 SND_PCI_QUIRK(0x1043, 0x194e, "ASUS UX563FD", ALC294_FIXUP_ASUS_HPE), 8956 SND_PCI_QUIRK(0x1043, 0x1970, "ASUS UX550VE", ALC289_FIXUP_ASUS_GA401), 8957 SND_PCI_QUIRK(0x1043, 0x1982, "ASUS B1400CEPE", ALC256_FIXUP_ASUS_HPE), 8958 SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE), 8959 SND_PCI_QUIRK(0x1043, 0x19e1, "ASUS UX581LV", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE), 8960 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW), 8961 SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC), 8962 SND_PCI_QUIRK(0x1043, 0x1b11, "ASUS UX431DA", ALC294_FIXUP_ASUS_COEF_1B), 8963 SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC), 8964 SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE), 8965 SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 8966 SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC), 8967 SND_PCI_QUIRK(0x1043, 0x1d4e, "ASUS TM420", ALC256_FIXUP_ASUS_HPE), 8968 SND_PCI_QUIRK(0x1043, 0x1e11, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA502), 8969 SND_PCI_QUIRK(0x1043, 0x1e51, "ASUS Zephyrus M15", ALC294_FIXUP_ASUS_GU502_PINS), 8970 SND_PCI_QUIRK(0x1043, 0x1e8e, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA401), 8971 SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401), 8972 SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2), 8973 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC), 8974 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC), 8975 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC), 8976 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC), 8977 SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101), 8978 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2), 8979 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ), 8980 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ), 8981 SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX), 8982 SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE), 8983 SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE), 8984 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK), 8985 SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT), 8986 SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN), 8987 SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC), 8988 SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN), 8989 SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC), 8990 SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE), 8991 SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE), 8992 SND_PCI_QUIRK(0x10ec, 0x1230, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 8993 SND_PCI_QUIRK(0x10ec, 0x1252, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 8994 SND_PCI_QUIRK(0x10ec, 0x1254, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), 8995 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_HEADSET_MODE), 8996 SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC), 8997 SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), 8998 SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), 8999 SND_PCI_QUIRK(0x144d, 0xc189, "Samsung Galaxy Flex Book (NT950QCG-X716)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), 9000 SND_PCI_QUIRK(0x144d, 0xc18a, "Samsung Galaxy Book Ion (NP930XCJ-K01US)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), 9001 SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8), 9002 SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), 9003 SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET), 9004 SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC), 9005 SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC), 9006 SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC), 9007 SND_PCI_QUIRK(0x152d, 0x1082, "Quanta NL3", ALC269_FIXUP_LIFEBOOK), 9008 SND_PCI_QUIRK(0x1558, 0x1323, "Clevo N130ZU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9009 SND_PCI_QUIRK(0x1558, 0x1325, "Clevo N15[01][CW]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9010 SND_PCI_QUIRK(0x1558, 0x1401, "Clevo L140[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9011 SND_PCI_QUIRK(0x1558, 0x1403, "Clevo N140CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9012 SND_PCI_QUIRK(0x1558, 0x1404, "Clevo N150CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9013 SND_PCI_QUIRK(0x1558, 0x14a1, "Clevo L141MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9014 SND_PCI_QUIRK(0x1558, 0x4018, "Clevo NV40M[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9015 SND_PCI_QUIRK(0x1558, 0x4019, "Clevo NV40MZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9016 SND_PCI_QUIRK(0x1558, 0x4020, "Clevo NV40MB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9017 SND_PCI_QUIRK(0x1558, 0x40a1, "Clevo NL40GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9018 SND_PCI_QUIRK(0x1558, 0x40c1, "Clevo NL40[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9019 SND_PCI_QUIRK(0x1558, 0x40d1, "Clevo NL41DU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9020 SND_PCI_QUIRK(0x1558, 0x5015, "Clevo NH5[58]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9021 SND_PCI_QUIRK(0x1558, 0x5017, "Clevo NH7[79]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9022 SND_PCI_QUIRK(0x1558, 0x50a3, "Clevo NJ51GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9023 SND_PCI_QUIRK(0x1558, 0x50b3, "Clevo NK50S[BEZ]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9024 SND_PCI_QUIRK(0x1558, 0x50b6, "Clevo NK50S5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9025 SND_PCI_QUIRK(0x1558, 0x50b8, "Clevo NK50SZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9026 SND_PCI_QUIRK(0x1558, 0x50d5, "Clevo NP50D5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9027 SND_PCI_QUIRK(0x1558, 0x50e1, "Clevo NH5[58]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9028 SND_PCI_QUIRK(0x1558, 0x50e2, "Clevo NH7[79]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9029 SND_PCI_QUIRK(0x1558, 0x50f0, "Clevo NH50A[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9030 SND_PCI_QUIRK(0x1558, 0x50f2, "Clevo NH50E[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9031 SND_PCI_QUIRK(0x1558, 0x50f3, "Clevo NH58DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9032 SND_PCI_QUIRK(0x1558, 0x50f5, "Clevo NH55EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9033 SND_PCI_QUIRK(0x1558, 0x50f6, "Clevo NH55DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9034 SND_PCI_QUIRK(0x1558, 0x5101, "Clevo S510WU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9035 SND_PCI_QUIRK(0x1558, 0x5157, "Clevo W517GU1", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9036 SND_PCI_QUIRK(0x1558, 0x51a1, "Clevo NS50MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9037 SND_PCI_QUIRK(0x1558, 0x70a1, "Clevo NB70T[HJK]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9038 SND_PCI_QUIRK(0x1558, 0x70b3, "Clevo NK70SB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9039 SND_PCI_QUIRK(0x1558, 0x70f2, "Clevo NH79EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9040 SND_PCI_QUIRK(0x1558, 0x70f3, "Clevo NH77DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9041 SND_PCI_QUIRK(0x1558, 0x70f4, "Clevo NH77EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9042 SND_PCI_QUIRK(0x1558, 0x70f6, "Clevo NH77DPQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9043 SND_PCI_QUIRK(0x1558, 0x8228, "Clevo NR40BU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9044 SND_PCI_QUIRK(0x1558, 0x8520, "Clevo NH50D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9045 SND_PCI_QUIRK(0x1558, 0x8521, "Clevo NH77D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9046 SND_PCI_QUIRK(0x1558, 0x8535, "Clevo NH50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9047 SND_PCI_QUIRK(0x1558, 0x8536, "Clevo NH79D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9048 SND_PCI_QUIRK(0x1558, 0x8550, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9049 SND_PCI_QUIRK(0x1558, 0x8551, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9050 SND_PCI_QUIRK(0x1558, 0x8560, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC), 9051 SND_PCI_QUIRK(0x1558, 0x8561, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC), 9052 SND_PCI_QUIRK(0x1558, 0x8562, "Clevo NH[57][0-9]RZ[Q]", ALC269_FIXUP_DMIC), 9053 SND_PCI_QUIRK(0x1558, 0x8668, "Clevo NP50B[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9054 SND_PCI_QUIRK(0x1558, 0x8680, "Clevo NJ50LU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9055 SND_PCI_QUIRK(0x1558, 0x8686, "Clevo NH50[CZ]U", ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME), 9056 SND_PCI_QUIRK(0x1558, 0x8a20, "Clevo NH55DCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9057 SND_PCI_QUIRK(0x1558, 0x8a51, "Clevo NH70RCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9058 SND_PCI_QUIRK(0x1558, 0x8d50, "Clevo NH55RCQ-M", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9059 SND_PCI_QUIRK(0x1558, 0x951d, "Clevo N950T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9060 SND_PCI_QUIRK(0x1558, 0x9600, "Clevo N960K[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9061 SND_PCI_QUIRK(0x1558, 0x961d, "Clevo N960S[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9062 SND_PCI_QUIRK(0x1558, 0x971d, "Clevo N970T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9063 SND_PCI_QUIRK(0x1558, 0xa500, "Clevo NL5[03]RU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9064 SND_PCI_QUIRK(0x1558, 0xa600, "Clevo NL50NU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9065 SND_PCI_QUIRK(0x1558, 0xb018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9066 SND_PCI_QUIRK(0x1558, 0xb019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9067 SND_PCI_QUIRK(0x1558, 0xb022, "Clevo NH77D[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9068 SND_PCI_QUIRK(0x1558, 0xc018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9069 SND_PCI_QUIRK(0x1558, 0xc019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9070 SND_PCI_QUIRK(0x1558, 0xc022, "Clevo NH77[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE), 9071 SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS), 9072 SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340), 9073 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE), 9074 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE), 9075 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE), 9076 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE), 9077 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE), 9078 SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK), 9079 SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST), 9080 SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK), 9081 SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK), 9082 SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK), 9083 SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK), 9084 SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440), 9085 SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK), 9086 SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK), 9087 SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK), 9088 SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK), 9089 SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK), 9090 SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 9091 SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK), 9092 SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK), 9093 SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK), 9094 SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 9095 SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 9096 SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460), 9097 SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460), 9098 SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK), 9099 SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 9100 SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 9101 SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460), 9102 SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 9103 SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 9104 SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 9105 SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 9106 SND_PCI_QUIRK(0x17aa, 0x2292, "Thinkpad X1 Carbon 7th", ALC285_FIXUP_THINKPAD_HEADSET_JACK), 9107 SND_PCI_QUIRK(0x17aa, 0x22be, "Thinkpad X1 Carbon 8th", ALC285_FIXUP_THINKPAD_HEADSET_JACK), 9108 SND_PCI_QUIRK(0x17aa, 0x22c1, "Thinkpad P1 Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK), 9109 SND_PCI_QUIRK(0x17aa, 0x22c2, "Thinkpad X1 Extreme Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK), 9110 SND_PCI_QUIRK(0x17aa, 0x22f1, "Thinkpad", ALC287_FIXUP_CS35L41_I2C_2), 9111 SND_PCI_QUIRK(0x17aa, 0x22f2, "Thinkpad", ALC287_FIXUP_CS35L41_I2C_2), 9112 SND_PCI_QUIRK(0x17aa, 0x22f3, "Thinkpad", ALC287_FIXUP_CS35L41_I2C_2), 9113 SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY), 9114 SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY), 9115 SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 9116 SND_PCI_QUIRK(0x17aa, 0x3111, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 9117 SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 9118 SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 9119 SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION), 9120 SND_PCI_QUIRK(0x17aa, 0x3151, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC), 9121 SND_PCI_QUIRK(0x17aa, 0x3176, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC), 9122 SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC), 9123 SND_PCI_QUIRK(0x17aa, 0x31af, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340), 9124 SND_PCI_QUIRK(0x17aa, 0x3813, "Legion 7i 15IMHG05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS), 9125 SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940", ALC298_FIXUP_LENOVO_SPK_VOLUME), 9126 SND_PCI_QUIRK(0x17aa, 0x3819, "Lenovo 13s Gen2 ITL", ALC287_FIXUP_13S_GEN2_SPEAKERS), 9127 SND_PCI_QUIRK(0x17aa, 0x3824, "Legion Y9000X 2020", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS), 9128 SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF), 9129 SND_PCI_QUIRK(0x17aa, 0x3834, "Lenovo IdeaPad Slim 9i 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS), 9130 SND_PCI_QUIRK(0x17aa, 0x3843, "Yoga 9i", ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP), 9131 SND_PCI_QUIRK(0x17aa, 0x3847, "Legion 7 16ACHG6", ALC287_FIXUP_LEGION_16ACHG6), 9132 SND_PCI_QUIRK(0x17aa, 0x384a, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS), 9133 SND_PCI_QUIRK(0x17aa, 0x3852, "Lenovo Yoga 7 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS), 9134 SND_PCI_QUIRK(0x17aa, 0x3853, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS), 9135 SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI), 9136 SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC), 9137 SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI), 9138 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K), 9139 SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 9140 SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC), 9141 SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK), 9142 SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 9143 SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK), 9144 SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK), 9145 SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK), 9146 SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK), 9147 SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE), 9148 SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460), 9149 SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460), 9150 SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460), 9151 SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 9152 SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 9153 SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 9154 SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 9155 SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 9156 SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK), 9157 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD), 9158 SND_PCI_QUIRK(0x1849, 0x1233, "ASRock NUC Box 1100", ALC233_FIXUP_NO_AUDIO_JACK), 9159 SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS), 9160 SND_PCI_QUIRK(0x1b35, 0x1235, "CZC B20", ALC269_FIXUP_CZC_B20), 9161 SND_PCI_QUIRK(0x1b35, 0x1236, "CZC TMI", ALC269_FIXUP_CZC_TMI), 9162 SND_PCI_QUIRK(0x1b35, 0x1237, "CZC L101", ALC269_FIXUP_CZC_L101), 9163 SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */ 9164 SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802), 9165 SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X), 9166 SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_SET_COEF_DEFAULTS), 9167 SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC), 9168 SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE), 9169 SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC), 9170 SND_PCI_QUIRK(0x1d72, 0x1947, "RedmiBook Air", ALC255_FIXUP_XIAOMI_HEADSET_MIC), 9171 SND_PCI_QUIRK(0x8086, 0x2074, "Intel NUC 8", ALC233_FIXUP_INTEL_NUC8_DMIC), 9172 SND_PCI_QUIRK(0x8086, 0x2080, "Intel NUC 8 Rugged", ALC256_FIXUP_INTEL_NUC8_RUGGED), 9173 SND_PCI_QUIRK(0x8086, 0x2081, "Intel NUC 10", ALC256_FIXUP_INTEL_NUC10), 9174 9175 #if 0 9176 /* Below is a quirk table taken from the old code. 9177 * Basically the device should work as is without the fixup table. 9178 * If BIOS doesn't give a proper info, enable the corresponding 9179 * fixup entry. 9180 */ 9181 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A", 9182 ALC269_FIXUP_AMIC), 9183 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC), 9184 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC), 9185 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC), 9186 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC), 9187 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC), 9188 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC), 9189 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC), 9190 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC), 9191 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC), 9192 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC), 9193 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC), 9194 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC), 9195 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC), 9196 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC), 9197 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC), 9198 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC), 9199 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC), 9200 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC), 9201 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC), 9202 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC), 9203 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC), 9204 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC), 9205 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC), 9206 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC), 9207 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC), 9208 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC), 9209 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC), 9210 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC), 9211 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC), 9212 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC), 9213 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC), 9214 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC), 9215 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC), 9216 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC), 9217 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC), 9218 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC), 9219 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC), 9220 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC), 9221 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC), 9222 #endif 9223 {} 9224 }; 9225 9226 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = { 9227 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC), 9228 SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED), 9229 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO), 9230 SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI), 9231 SND_PCI_QUIRK_VENDOR(0x19e5, "Huawei Matebook", ALC255_FIXUP_MIC_MUTE_LED), 9232 {} 9233 }; 9234 9235 static const struct hda_model_fixup alc269_fixup_models[] = { 9236 {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"}, 9237 {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"}, 9238 {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"}, 9239 {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"}, 9240 {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"}, 9241 {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"}, 9242 {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"}, 9243 {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"}, 9244 {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"}, 9245 {.id = ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, .name = "lenovo-dock-limit-boost"}, 9246 {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"}, 9247 {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"}, 9248 {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"}, 9249 {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"}, 9250 {.id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, .name = "dell-headset3"}, 9251 {.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, .name = "dell-headset4"}, 9252 {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"}, 9253 {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"}, 9254 {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"}, 9255 {.id = ALC292_FIXUP_TPT440, .name = "tpt440"}, 9256 {.id = ALC292_FIXUP_TPT460, .name = "tpt460"}, 9257 {.id = ALC298_FIXUP_TPT470_DOCK_FIX, .name = "tpt470-dock-fix"}, 9258 {.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"}, 9259 {.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"}, 9260 {.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"}, 9261 {.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"}, 9262 {.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"}, 9263 {.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"}, 9264 {.id = ALC269_FIXUP_LENOVO_EAPD, .name = "lenovo-eapd"}, 9265 {.id = ALC275_FIXUP_SONY_HWEQ, .name = "sony-hweq"}, 9266 {.id = ALC269_FIXUP_PCM_44K, .name = "pcm44k"}, 9267 {.id = ALC269_FIXUP_LIFEBOOK, .name = "lifebook"}, 9268 {.id = ALC269_FIXUP_LIFEBOOK_EXTMIC, .name = "lifebook-extmic"}, 9269 {.id = ALC269_FIXUP_LIFEBOOK_HP_PIN, .name = "lifebook-hp-pin"}, 9270 {.id = ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, .name = "lifebook-u7x7"}, 9271 {.id = ALC269VB_FIXUP_AMIC, .name = "alc269vb-amic"}, 9272 {.id = ALC269VB_FIXUP_DMIC, .name = "alc269vb-dmic"}, 9273 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC1, .name = "hp-mute-led-mic1"}, 9274 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC2, .name = "hp-mute-led-mic2"}, 9275 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC3, .name = "hp-mute-led-mic3"}, 9276 {.id = ALC269_FIXUP_HP_GPIO_MIC1_LED, .name = "hp-gpio-mic1"}, 9277 {.id = ALC269_FIXUP_HP_LINE1_MIC1_LED, .name = "hp-line1-mic1"}, 9278 {.id = ALC269_FIXUP_NO_SHUTUP, .name = "noshutup"}, 9279 {.id = ALC286_FIXUP_SONY_MIC_NO_PRESENCE, .name = "sony-nomic"}, 9280 {.id = ALC269_FIXUP_ASPIRE_HEADSET_MIC, .name = "aspire-headset-mic"}, 9281 {.id = ALC269_FIXUP_ASUS_X101, .name = "asus-x101"}, 9282 {.id = ALC271_FIXUP_HP_GATE_MIC_JACK, .name = "acer-ao7xx"}, 9283 {.id = ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, .name = "acer-aspire-e1"}, 9284 {.id = ALC269_FIXUP_ACER_AC700, .name = "acer-ac700"}, 9285 {.id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, .name = "limit-mic-boost"}, 9286 {.id = ALC269VB_FIXUP_ASUS_ZENBOOK, .name = "asus-zenbook"}, 9287 {.id = ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, .name = "asus-zenbook-ux31a"}, 9288 {.id = ALC269VB_FIXUP_ORDISSIMO_EVE2, .name = "ordissimo"}, 9289 {.id = ALC282_FIXUP_ASUS_TX300, .name = "asus-tx300"}, 9290 {.id = ALC283_FIXUP_INT_MIC, .name = "alc283-int-mic"}, 9291 {.id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, .name = "mono-speakers"}, 9292 {.id = ALC290_FIXUP_SUBWOOFER_HSJACK, .name = "alc290-subwoofer"}, 9293 {.id = ALC269_FIXUP_THINKPAD_ACPI, .name = "thinkpad"}, 9294 {.id = ALC269_FIXUP_DMIC_THINKPAD_ACPI, .name = "dmic-thinkpad"}, 9295 {.id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, .name = "alc255-acer"}, 9296 {.id = ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc255-asus"}, 9297 {.id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc255-dell1"}, 9298 {.id = ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "alc255-dell2"}, 9299 {.id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc293-dell1"}, 9300 {.id = ALC283_FIXUP_HEADSET_MIC, .name = "alc283-headset"}, 9301 {.id = ALC255_FIXUP_MIC_MUTE_LED, .name = "alc255-dell-mute"}, 9302 {.id = ALC282_FIXUP_ASPIRE_V5_PINS, .name = "aspire-v5"}, 9303 {.id = ALC269VB_FIXUP_ASPIRE_E1_COEF, .name = "aspire-e1-coef"}, 9304 {.id = ALC280_FIXUP_HP_GPIO4, .name = "hp-gpio4"}, 9305 {.id = ALC286_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"}, 9306 {.id = ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, .name = "hp-gpio2-hotkey"}, 9307 {.id = ALC280_FIXUP_HP_DOCK_PINS, .name = "hp-dock-pins"}, 9308 {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic"}, 9309 {.id = ALC280_FIXUP_HP_9480M, .name = "hp-9480m"}, 9310 {.id = ALC288_FIXUP_DELL_HEADSET_MODE, .name = "alc288-dell-headset"}, 9311 {.id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc288-dell1"}, 9312 {.id = ALC288_FIXUP_DELL_XPS_13, .name = "alc288-dell-xps13"}, 9313 {.id = ALC292_FIXUP_DELL_E7X, .name = "dell-e7x"}, 9314 {.id = ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, .name = "alc293-dell"}, 9315 {.id = ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc298-dell1"}, 9316 {.id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, .name = "alc298-dell-aio"}, 9317 {.id = ALC275_FIXUP_DELL_XPS, .name = "alc275-dell-xps"}, 9318 {.id = ALC293_FIXUP_LENOVO_SPK_NOISE, .name = "lenovo-spk-noise"}, 9319 {.id = ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, .name = "lenovo-hotkey"}, 9320 {.id = ALC255_FIXUP_DELL_SPK_NOISE, .name = "dell-spk-noise"}, 9321 {.id = ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc225-dell1"}, 9322 {.id = ALC295_FIXUP_DISABLE_DAC3, .name = "alc295-disable-dac3"}, 9323 {.id = ALC285_FIXUP_SPEAKER2_TO_DAC1, .name = "alc285-speaker2-to-dac1"}, 9324 {.id = ALC280_FIXUP_HP_HEADSET_MIC, .name = "alc280-hp-headset"}, 9325 {.id = ALC221_FIXUP_HP_FRONT_MIC, .name = "alc221-hp-mic"}, 9326 {.id = ALC298_FIXUP_SPK_VOLUME, .name = "alc298-spk-volume"}, 9327 {.id = ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, .name = "dell-inspiron-7559"}, 9328 {.id = ALC269_FIXUP_ATIV_BOOK_8, .name = "ativ-book"}, 9329 {.id = ALC221_FIXUP_HP_MIC_NO_PRESENCE, .name = "alc221-hp-mic"}, 9330 {.id = ALC256_FIXUP_ASUS_HEADSET_MODE, .name = "alc256-asus-headset"}, 9331 {.id = ALC256_FIXUP_ASUS_MIC, .name = "alc256-asus-mic"}, 9332 {.id = ALC256_FIXUP_ASUS_AIO_GPIO2, .name = "alc256-asus-aio"}, 9333 {.id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc233-asus"}, 9334 {.id = ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, .name = "alc233-eapd"}, 9335 {.id = ALC294_FIXUP_LENOVO_MIC_LOCATION, .name = "alc294-lenovo-mic"}, 9336 {.id = ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, .name = "alc225-wyse"}, 9337 {.id = ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, .name = "alc274-dell-aio"}, 9338 {.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"}, 9339 {.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"}, 9340 {.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"}, 9341 {.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"}, 9342 {.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"}, 9343 {.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"}, 9344 {.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"}, 9345 {.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"}, 9346 {.id = ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc298-samsung-headphone"}, 9347 {.id = ALC255_FIXUP_XIAOMI_HEADSET_MIC, .name = "alc255-xiaomi-headset"}, 9348 {.id = ALC274_FIXUP_HP_MIC, .name = "alc274-hp-mic-detect"}, 9349 {.id = ALC245_FIXUP_HP_X360_AMP, .name = "alc245-hp-x360-amp"}, 9350 {.id = ALC295_FIXUP_HP_OMEN, .name = "alc295-hp-omen"}, 9351 {.id = ALC285_FIXUP_HP_SPECTRE_X360, .name = "alc285-hp-spectre-x360"}, 9352 {.id = ALC285_FIXUP_HP_SPECTRE_X360_EB1, .name = "alc285-hp-spectre-x360-eb1"}, 9353 {.id = ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, .name = "alc287-ideapad-bass-spk-amp"}, 9354 {.id = ALC623_FIXUP_LENOVO_THINKSTATION_P340, .name = "alc623-lenovo-thinkstation-p340"}, 9355 {.id = ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, .name = "alc255-acer-headphone-and-mic"}, 9356 {.id = ALC285_FIXUP_HP_GPIO_AMP_INIT, .name = "alc285-hp-amp-init"}, 9357 {} 9358 }; 9359 #define ALC225_STANDARD_PINS \ 9360 {0x21, 0x04211020} 9361 9362 #define ALC256_STANDARD_PINS \ 9363 {0x12, 0x90a60140}, \ 9364 {0x14, 0x90170110}, \ 9365 {0x21, 0x02211020} 9366 9367 #define ALC282_STANDARD_PINS \ 9368 {0x14, 0x90170110} 9369 9370 #define ALC290_STANDARD_PINS \ 9371 {0x12, 0x99a30130} 9372 9373 #define ALC292_STANDARD_PINS \ 9374 {0x14, 0x90170110}, \ 9375 {0x15, 0x0221401f} 9376 9377 #define ALC295_STANDARD_PINS \ 9378 {0x12, 0xb7a60130}, \ 9379 {0x14, 0x90170110}, \ 9380 {0x21, 0x04211020} 9381 9382 #define ALC298_STANDARD_PINS \ 9383 {0x12, 0x90a60130}, \ 9384 {0x21, 0x03211020} 9385 9386 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = { 9387 SND_HDA_PIN_QUIRK(0x10ec0221, 0x103c, "HP Workstation", ALC221_FIXUP_HP_HEADSET_MIC, 9388 {0x14, 0x01014020}, 9389 {0x17, 0x90170110}, 9390 {0x18, 0x02a11030}, 9391 {0x19, 0x0181303F}, 9392 {0x21, 0x0221102f}), 9393 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE, 9394 {0x12, 0x90a601c0}, 9395 {0x14, 0x90171120}, 9396 {0x21, 0x02211030}), 9397 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, 9398 {0x14, 0x90170110}, 9399 {0x1b, 0x90a70130}, 9400 {0x21, 0x03211020}), 9401 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, 9402 {0x1a, 0x90a70130}, 9403 {0x1b, 0x90170110}, 9404 {0x21, 0x03211020}), 9405 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 9406 ALC225_STANDARD_PINS, 9407 {0x12, 0xb7a60130}, 9408 {0x14, 0x901701a0}), 9409 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 9410 ALC225_STANDARD_PINS, 9411 {0x12, 0xb7a60130}, 9412 {0x14, 0x901701b0}), 9413 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 9414 ALC225_STANDARD_PINS, 9415 {0x12, 0xb7a60150}, 9416 {0x14, 0x901701a0}), 9417 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 9418 ALC225_STANDARD_PINS, 9419 {0x12, 0xb7a60150}, 9420 {0x14, 0x901701b0}), 9421 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, 9422 ALC225_STANDARD_PINS, 9423 {0x12, 0xb7a60130}, 9424 {0x1b, 0x90170110}), 9425 SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 9426 {0x1b, 0x01111010}, 9427 {0x1e, 0x01451130}, 9428 {0x21, 0x02211020}), 9429 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, 9430 {0x12, 0x90a60140}, 9431 {0x14, 0x90170110}, 9432 {0x19, 0x02a11030}, 9433 {0x21, 0x02211020}), 9434 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION, 9435 {0x14, 0x90170110}, 9436 {0x19, 0x02a11030}, 9437 {0x1a, 0x02a11040}, 9438 {0x1b, 0x01014020}, 9439 {0x21, 0x0221101f}), 9440 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION, 9441 {0x14, 0x90170110}, 9442 {0x19, 0x02a11030}, 9443 {0x1a, 0x02a11040}, 9444 {0x1b, 0x01011020}, 9445 {0x21, 0x0221101f}), 9446 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION, 9447 {0x14, 0x90170110}, 9448 {0x19, 0x02a11020}, 9449 {0x1a, 0x02a11030}, 9450 {0x21, 0x0221101f}), 9451 SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC, 9452 {0x21, 0x02211010}), 9453 SND_HDA_PIN_QUIRK(0x10ec0236, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC, 9454 {0x14, 0x90170110}, 9455 {0x19, 0x02a11020}, 9456 {0x21, 0x02211030}), 9457 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, 9458 {0x14, 0x90170110}, 9459 {0x21, 0x02211020}), 9460 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9461 {0x14, 0x90170130}, 9462 {0x21, 0x02211040}), 9463 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9464 {0x12, 0x90a60140}, 9465 {0x14, 0x90170110}, 9466 {0x21, 0x02211020}), 9467 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9468 {0x12, 0x90a60160}, 9469 {0x14, 0x90170120}, 9470 {0x21, 0x02211030}), 9471 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9472 {0x14, 0x90170110}, 9473 {0x1b, 0x02011020}, 9474 {0x21, 0x0221101f}), 9475 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9476 {0x14, 0x90170110}, 9477 {0x1b, 0x01011020}, 9478 {0x21, 0x0221101f}), 9479 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9480 {0x14, 0x90170130}, 9481 {0x1b, 0x01014020}, 9482 {0x21, 0x0221103f}), 9483 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9484 {0x14, 0x90170130}, 9485 {0x1b, 0x01011020}, 9486 {0x21, 0x0221103f}), 9487 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9488 {0x14, 0x90170130}, 9489 {0x1b, 0x02011020}, 9490 {0x21, 0x0221103f}), 9491 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9492 {0x14, 0x90170150}, 9493 {0x1b, 0x02011020}, 9494 {0x21, 0x0221105f}), 9495 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9496 {0x14, 0x90170110}, 9497 {0x1b, 0x01014020}, 9498 {0x21, 0x0221101f}), 9499 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9500 {0x12, 0x90a60160}, 9501 {0x14, 0x90170120}, 9502 {0x17, 0x90170140}, 9503 {0x21, 0x0321102f}), 9504 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9505 {0x12, 0x90a60160}, 9506 {0x14, 0x90170130}, 9507 {0x21, 0x02211040}), 9508 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9509 {0x12, 0x90a60160}, 9510 {0x14, 0x90170140}, 9511 {0x21, 0x02211050}), 9512 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9513 {0x12, 0x90a60170}, 9514 {0x14, 0x90170120}, 9515 {0x21, 0x02211030}), 9516 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9517 {0x12, 0x90a60170}, 9518 {0x14, 0x90170130}, 9519 {0x21, 0x02211040}), 9520 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9521 {0x12, 0x90a60170}, 9522 {0x14, 0x90171130}, 9523 {0x21, 0x02211040}), 9524 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9525 {0x12, 0x90a60170}, 9526 {0x14, 0x90170140}, 9527 {0x21, 0x02211050}), 9528 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9529 {0x12, 0x90a60180}, 9530 {0x14, 0x90170130}, 9531 {0x21, 0x02211040}), 9532 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9533 {0x12, 0x90a60180}, 9534 {0x14, 0x90170120}, 9535 {0x21, 0x02211030}), 9536 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9537 {0x1b, 0x01011020}, 9538 {0x21, 0x02211010}), 9539 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC, 9540 {0x14, 0x90170110}, 9541 {0x1b, 0x90a70130}, 9542 {0x21, 0x04211020}), 9543 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC, 9544 {0x14, 0x90170110}, 9545 {0x1b, 0x90a70130}, 9546 {0x21, 0x03211020}), 9547 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE, 9548 {0x12, 0x90a60130}, 9549 {0x14, 0x90170110}, 9550 {0x21, 0x03211020}), 9551 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE, 9552 {0x12, 0x90a60130}, 9553 {0x14, 0x90170110}, 9554 {0x21, 0x04211020}), 9555 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE, 9556 {0x1a, 0x90a70130}, 9557 {0x1b, 0x90170110}, 9558 {0x21, 0x03211020}), 9559 SND_HDA_PIN_QUIRK(0x10ec0256, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC, 9560 {0x14, 0x90170110}, 9561 {0x19, 0x02a11020}, 9562 {0x21, 0x0221101f}), 9563 SND_HDA_PIN_QUIRK(0x10ec0274, 0x103c, "HP", ALC274_FIXUP_HP_HEADSET_MIC, 9564 {0x17, 0x90170110}, 9565 {0x19, 0x03a11030}, 9566 {0x21, 0x03211020}), 9567 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4, 9568 {0x12, 0x90a60130}, 9569 {0x14, 0x90170110}, 9570 {0x15, 0x0421101f}, 9571 {0x1a, 0x04a11020}), 9572 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED, 9573 {0x12, 0x90a60140}, 9574 {0x14, 0x90170110}, 9575 {0x15, 0x0421101f}, 9576 {0x18, 0x02811030}, 9577 {0x1a, 0x04a1103f}, 9578 {0x1b, 0x02011020}), 9579 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1, 9580 ALC282_STANDARD_PINS, 9581 {0x12, 0x99a30130}, 9582 {0x19, 0x03a11020}, 9583 {0x21, 0x0321101f}), 9584 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 9585 ALC282_STANDARD_PINS, 9586 {0x12, 0x99a30130}, 9587 {0x19, 0x03a11020}, 9588 {0x21, 0x03211040}), 9589 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 9590 ALC282_STANDARD_PINS, 9591 {0x12, 0x99a30130}, 9592 {0x19, 0x03a11030}, 9593 {0x21, 0x03211020}), 9594 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 9595 ALC282_STANDARD_PINS, 9596 {0x12, 0x99a30130}, 9597 {0x19, 0x04a11020}, 9598 {0x21, 0x0421101f}), 9599 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED, 9600 ALC282_STANDARD_PINS, 9601 {0x12, 0x90a60140}, 9602 {0x19, 0x04a11030}, 9603 {0x21, 0x04211020}), 9604 SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT, 9605 ALC282_STANDARD_PINS, 9606 {0x12, 0x90a609c0}, 9607 {0x18, 0x03a11830}, 9608 {0x19, 0x04a19831}, 9609 {0x1a, 0x0481303f}, 9610 {0x1b, 0x04211020}, 9611 {0x21, 0x0321101f}), 9612 SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT, 9613 ALC282_STANDARD_PINS, 9614 {0x12, 0x90a60940}, 9615 {0x18, 0x03a11830}, 9616 {0x19, 0x04a19831}, 9617 {0x1a, 0x0481303f}, 9618 {0x1b, 0x04211020}, 9619 {0x21, 0x0321101f}), 9620 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 9621 ALC282_STANDARD_PINS, 9622 {0x12, 0x90a60130}, 9623 {0x21, 0x0321101f}), 9624 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 9625 {0x12, 0x90a60160}, 9626 {0x14, 0x90170120}, 9627 {0x21, 0x02211030}), 9628 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 9629 ALC282_STANDARD_PINS, 9630 {0x12, 0x90a60130}, 9631 {0x19, 0x03a11020}, 9632 {0x21, 0x0321101f}), 9633 SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE, 9634 {0x12, 0x90a60130}, 9635 {0x14, 0x90170110}, 9636 {0x19, 0x04a11040}, 9637 {0x21, 0x04211020}), 9638 SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE, 9639 {0x14, 0x90170110}, 9640 {0x19, 0x04a11040}, 9641 {0x1d, 0x40600001}, 9642 {0x21, 0x04211020}), 9643 SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK, 9644 {0x14, 0x90170110}, 9645 {0x19, 0x04a11040}, 9646 {0x21, 0x04211020}), 9647 SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_HEADSET_JACK, 9648 {0x14, 0x90170110}, 9649 {0x17, 0x90170111}, 9650 {0x19, 0x03a11030}, 9651 {0x21, 0x03211020}), 9652 SND_HDA_PIN_QUIRK(0x10ec0286, 0x1025, "Acer", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE, 9653 {0x12, 0x90a60130}, 9654 {0x17, 0x90170110}, 9655 {0x21, 0x02211020}), 9656 SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, 9657 {0x12, 0x90a60120}, 9658 {0x14, 0x90170110}, 9659 {0x21, 0x0321101f}), 9660 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 9661 ALC290_STANDARD_PINS, 9662 {0x15, 0x04211040}, 9663 {0x18, 0x90170112}, 9664 {0x1a, 0x04a11020}), 9665 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 9666 ALC290_STANDARD_PINS, 9667 {0x15, 0x04211040}, 9668 {0x18, 0x90170110}, 9669 {0x1a, 0x04a11020}), 9670 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 9671 ALC290_STANDARD_PINS, 9672 {0x15, 0x0421101f}, 9673 {0x1a, 0x04a11020}), 9674 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 9675 ALC290_STANDARD_PINS, 9676 {0x15, 0x04211020}, 9677 {0x1a, 0x04a11040}), 9678 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 9679 ALC290_STANDARD_PINS, 9680 {0x14, 0x90170110}, 9681 {0x15, 0x04211020}, 9682 {0x1a, 0x04a11040}), 9683 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 9684 ALC290_STANDARD_PINS, 9685 {0x14, 0x90170110}, 9686 {0x15, 0x04211020}, 9687 {0x1a, 0x04a11020}), 9688 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 9689 ALC290_STANDARD_PINS, 9690 {0x14, 0x90170110}, 9691 {0x15, 0x0421101f}, 9692 {0x1a, 0x04a11020}), 9693 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, 9694 ALC292_STANDARD_PINS, 9695 {0x12, 0x90a60140}, 9696 {0x16, 0x01014020}, 9697 {0x19, 0x01a19030}), 9698 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, 9699 ALC292_STANDARD_PINS, 9700 {0x12, 0x90a60140}, 9701 {0x16, 0x01014020}, 9702 {0x18, 0x02a19031}, 9703 {0x19, 0x01a1903e}), 9704 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, 9705 ALC292_STANDARD_PINS, 9706 {0x12, 0x90a60140}), 9707 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, 9708 ALC292_STANDARD_PINS, 9709 {0x13, 0x90a60140}, 9710 {0x16, 0x21014020}, 9711 {0x19, 0x21a19030}), 9712 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, 9713 ALC292_STANDARD_PINS, 9714 {0x13, 0x90a60140}), 9715 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_HPE, 9716 {0x17, 0x90170110}, 9717 {0x21, 0x04211020}), 9718 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC, 9719 {0x14, 0x90170110}, 9720 {0x1b, 0x90a70130}, 9721 {0x21, 0x04211020}), 9722 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK, 9723 {0x12, 0x90a60130}, 9724 {0x17, 0x90170110}, 9725 {0x21, 0x03211020}), 9726 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK, 9727 {0x12, 0x90a60130}, 9728 {0x17, 0x90170110}, 9729 {0x21, 0x04211020}), 9730 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK, 9731 {0x12, 0x90a60130}, 9732 {0x17, 0x90170110}, 9733 {0x21, 0x03211020}), 9734 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, 9735 {0x12, 0x90a60120}, 9736 {0x17, 0x90170110}, 9737 {0x21, 0x04211030}), 9738 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, 9739 {0x12, 0x90a60130}, 9740 {0x17, 0x90170110}, 9741 {0x21, 0x03211020}), 9742 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE, 9743 {0x12, 0x90a60130}, 9744 {0x17, 0x90170110}, 9745 {0x21, 0x03211020}), 9746 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 9747 {0x14, 0x90170110}, 9748 {0x21, 0x04211020}), 9749 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 9750 {0x14, 0x90170110}, 9751 {0x21, 0x04211030}), 9752 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 9753 ALC295_STANDARD_PINS, 9754 {0x17, 0x21014020}, 9755 {0x18, 0x21a19030}), 9756 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 9757 ALC295_STANDARD_PINS, 9758 {0x17, 0x21014040}, 9759 {0x18, 0x21a19050}), 9760 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 9761 ALC295_STANDARD_PINS), 9762 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 9763 ALC298_STANDARD_PINS, 9764 {0x17, 0x90170110}), 9765 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 9766 ALC298_STANDARD_PINS, 9767 {0x17, 0x90170140}), 9768 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 9769 ALC298_STANDARD_PINS, 9770 {0x17, 0x90170150}), 9771 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME, 9772 {0x12, 0xb7a60140}, 9773 {0x13, 0xb7a60150}, 9774 {0x17, 0x90170110}, 9775 {0x1a, 0x03011020}, 9776 {0x21, 0x03211030}), 9777 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE, 9778 {0x12, 0xb7a60140}, 9779 {0x17, 0x90170110}, 9780 {0x1a, 0x03a11030}, 9781 {0x21, 0x03211020}), 9782 SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 9783 ALC225_STANDARD_PINS, 9784 {0x12, 0xb7a60130}, 9785 {0x17, 0x90170110}), 9786 SND_HDA_PIN_QUIRK(0x10ec0623, 0x17aa, "Lenovo", ALC283_FIXUP_HEADSET_MIC, 9787 {0x14, 0x01014010}, 9788 {0x17, 0x90170120}, 9789 {0x18, 0x02a11030}, 9790 {0x19, 0x02a1103f}, 9791 {0x21, 0x0221101f}), 9792 {} 9793 }; 9794 9795 /* This is the fallback pin_fixup_tbl for alc269 family, to make the tbl match 9796 * more machines, don't need to match all valid pins, just need to match 9797 * all the pins defined in the tbl. Just because of this reason, it is possible 9798 * that a single machine matches multiple tbls, so there is one limitation: 9799 * at most one tbl is allowed to define for the same vendor and same codec 9800 */ 9801 static const struct snd_hda_pin_quirk alc269_fallback_pin_fixup_tbl[] = { 9802 SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, 9803 {0x19, 0x40000000}, 9804 {0x1b, 0x40000000}), 9805 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9806 {0x19, 0x40000000}, 9807 {0x1a, 0x40000000}), 9808 SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 9809 {0x19, 0x40000000}, 9810 {0x1a, 0x40000000}), 9811 SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, 9812 {0x19, 0x40000000}, 9813 {0x1a, 0x40000000}), 9814 {} 9815 }; 9816 9817 static void alc269_fill_coef(struct hda_codec *codec) 9818 { 9819 struct alc_spec *spec = codec->spec; 9820 int val; 9821 9822 if (spec->codec_variant != ALC269_TYPE_ALC269VB) 9823 return; 9824 9825 if ((alc_get_coef0(codec) & 0x00ff) < 0x015) { 9826 alc_write_coef_idx(codec, 0xf, 0x960b); 9827 alc_write_coef_idx(codec, 0xe, 0x8817); 9828 } 9829 9830 if ((alc_get_coef0(codec) & 0x00ff) == 0x016) { 9831 alc_write_coef_idx(codec, 0xf, 0x960b); 9832 alc_write_coef_idx(codec, 0xe, 0x8814); 9833 } 9834 9835 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) { 9836 /* Power up output pin */ 9837 alc_update_coef_idx(codec, 0x04, 0, 1<<11); 9838 } 9839 9840 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) { 9841 val = alc_read_coef_idx(codec, 0xd); 9842 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) { 9843 /* Capless ramp up clock control */ 9844 alc_write_coef_idx(codec, 0xd, val | (1<<10)); 9845 } 9846 val = alc_read_coef_idx(codec, 0x17); 9847 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) { 9848 /* Class D power on reset */ 9849 alc_write_coef_idx(codec, 0x17, val | (1<<7)); 9850 } 9851 } 9852 9853 /* HP */ 9854 alc_update_coef_idx(codec, 0x4, 0, 1<<11); 9855 } 9856 9857 /* 9858 */ 9859 static int patch_alc269(struct hda_codec *codec) 9860 { 9861 struct alc_spec *spec; 9862 int err; 9863 9864 err = alc_alloc_spec(codec, 0x0b); 9865 if (err < 0) 9866 return err; 9867 9868 spec = codec->spec; 9869 spec->gen.shared_mic_vref_pin = 0x18; 9870 codec->power_save_node = 0; 9871 9872 #ifdef CONFIG_PM 9873 codec->patch_ops.suspend = alc269_suspend; 9874 codec->patch_ops.resume = alc269_resume; 9875 #endif 9876 spec->shutup = alc_default_shutup; 9877 spec->init_hook = alc_default_init; 9878 9879 switch (codec->core.vendor_id) { 9880 case 0x10ec0269: 9881 spec->codec_variant = ALC269_TYPE_ALC269VA; 9882 switch (alc_get_coef0(codec) & 0x00f0) { 9883 case 0x0010: 9884 if (codec->bus->pci && 9885 codec->bus->pci->subsystem_vendor == 0x1025 && 9886 spec->cdefine.platform_type == 1) 9887 err = alc_codec_rename(codec, "ALC271X"); 9888 spec->codec_variant = ALC269_TYPE_ALC269VB; 9889 break; 9890 case 0x0020: 9891 if (codec->bus->pci && 9892 codec->bus->pci->subsystem_vendor == 0x17aa && 9893 codec->bus->pci->subsystem_device == 0x21f3) 9894 err = alc_codec_rename(codec, "ALC3202"); 9895 spec->codec_variant = ALC269_TYPE_ALC269VC; 9896 break; 9897 case 0x0030: 9898 spec->codec_variant = ALC269_TYPE_ALC269VD; 9899 break; 9900 default: 9901 alc_fix_pll_init(codec, 0x20, 0x04, 15); 9902 } 9903 if (err < 0) 9904 goto error; 9905 spec->shutup = alc269_shutup; 9906 spec->init_hook = alc269_fill_coef; 9907 alc269_fill_coef(codec); 9908 break; 9909 9910 case 0x10ec0280: 9911 case 0x10ec0290: 9912 spec->codec_variant = ALC269_TYPE_ALC280; 9913 break; 9914 case 0x10ec0282: 9915 spec->codec_variant = ALC269_TYPE_ALC282; 9916 spec->shutup = alc282_shutup; 9917 spec->init_hook = alc282_init; 9918 break; 9919 case 0x10ec0233: 9920 case 0x10ec0283: 9921 spec->codec_variant = ALC269_TYPE_ALC283; 9922 spec->shutup = alc283_shutup; 9923 spec->init_hook = alc283_init; 9924 break; 9925 case 0x10ec0284: 9926 case 0x10ec0292: 9927 spec->codec_variant = ALC269_TYPE_ALC284; 9928 break; 9929 case 0x10ec0293: 9930 spec->codec_variant = ALC269_TYPE_ALC293; 9931 break; 9932 case 0x10ec0286: 9933 case 0x10ec0288: 9934 spec->codec_variant = ALC269_TYPE_ALC286; 9935 break; 9936 case 0x10ec0298: 9937 spec->codec_variant = ALC269_TYPE_ALC298; 9938 break; 9939 case 0x10ec0235: 9940 case 0x10ec0255: 9941 spec->codec_variant = ALC269_TYPE_ALC255; 9942 spec->shutup = alc256_shutup; 9943 spec->init_hook = alc256_init; 9944 break; 9945 case 0x10ec0230: 9946 case 0x10ec0236: 9947 case 0x10ec0256: 9948 spec->codec_variant = ALC269_TYPE_ALC256; 9949 spec->shutup = alc256_shutup; 9950 spec->init_hook = alc256_init; 9951 spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */ 9952 break; 9953 case 0x10ec0257: 9954 spec->codec_variant = ALC269_TYPE_ALC257; 9955 spec->shutup = alc256_shutup; 9956 spec->init_hook = alc256_init; 9957 spec->gen.mixer_nid = 0; 9958 break; 9959 case 0x10ec0215: 9960 case 0x10ec0245: 9961 case 0x10ec0285: 9962 case 0x10ec0289: 9963 spec->codec_variant = ALC269_TYPE_ALC215; 9964 spec->shutup = alc225_shutup; 9965 spec->init_hook = alc225_init; 9966 spec->gen.mixer_nid = 0; 9967 break; 9968 case 0x10ec0225: 9969 case 0x10ec0295: 9970 case 0x10ec0299: 9971 spec->codec_variant = ALC269_TYPE_ALC225; 9972 spec->shutup = alc225_shutup; 9973 spec->init_hook = alc225_init; 9974 spec->gen.mixer_nid = 0; /* no loopback on ALC225, ALC295 and ALC299 */ 9975 break; 9976 case 0x10ec0287: 9977 spec->codec_variant = ALC269_TYPE_ALC287; 9978 spec->shutup = alc225_shutup; 9979 spec->init_hook = alc225_init; 9980 spec->gen.mixer_nid = 0; /* no loopback on ALC287 */ 9981 break; 9982 case 0x10ec0234: 9983 case 0x10ec0274: 9984 case 0x10ec0294: 9985 spec->codec_variant = ALC269_TYPE_ALC294; 9986 spec->gen.mixer_nid = 0; /* ALC2x4 does not have any loopback mixer path */ 9987 alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3)); /* UAJ MIC Vref control by verb */ 9988 spec->init_hook = alc294_init; 9989 break; 9990 case 0x10ec0300: 9991 spec->codec_variant = ALC269_TYPE_ALC300; 9992 spec->gen.mixer_nid = 0; /* no loopback on ALC300 */ 9993 break; 9994 case 0x10ec0623: 9995 spec->codec_variant = ALC269_TYPE_ALC623; 9996 break; 9997 case 0x10ec0700: 9998 case 0x10ec0701: 9999 case 0x10ec0703: 10000 case 0x10ec0711: 10001 spec->codec_variant = ALC269_TYPE_ALC700; 10002 spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */ 10003 alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */ 10004 spec->init_hook = alc294_init; 10005 break; 10006 10007 } 10008 10009 if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) { 10010 spec->has_alc5505_dsp = 1; 10011 spec->init_hook = alc5505_dsp_init; 10012 } 10013 10014 alc_pre_init(codec); 10015 10016 snd_hda_pick_fixup(codec, alc269_fixup_models, 10017 alc269_fixup_tbl, alc269_fixups); 10018 /* FIXME: both TX300 and ROG Strix G17 have the same SSID, and 10019 * the quirk breaks the latter (bko#214101). 10020 * Clear the wrong entry. 10021 */ 10022 if (codec->fixup_id == ALC282_FIXUP_ASUS_TX300 && 10023 codec->core.vendor_id == 0x10ec0294) { 10024 codec_dbg(codec, "Clear wrong fixup for ASUS ROG Strix G17\n"); 10025 codec->fixup_id = HDA_FIXUP_ID_NOT_SET; 10026 } 10027 10028 snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups, true); 10029 snd_hda_pick_pin_fixup(codec, alc269_fallback_pin_fixup_tbl, alc269_fixups, false); 10030 snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl, 10031 alc269_fixups); 10032 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 10033 10034 alc_auto_parse_customize_define(codec); 10035 10036 if (has_cdefine_beep(codec)) 10037 spec->gen.beep_nid = 0x01; 10038 10039 /* automatic parse from the BIOS config */ 10040 err = alc269_parse_auto_config(codec); 10041 if (err < 0) 10042 goto error; 10043 10044 if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) { 10045 err = set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT); 10046 if (err < 0) 10047 goto error; 10048 } 10049 10050 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 10051 10052 return 0; 10053 10054 error: 10055 alc_free(codec); 10056 return err; 10057 } 10058 10059 /* 10060 * ALC861 10061 */ 10062 10063 static int alc861_parse_auto_config(struct hda_codec *codec) 10064 { 10065 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 }; 10066 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 }; 10067 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids); 10068 } 10069 10070 /* Pin config fixes */ 10071 enum { 10072 ALC861_FIXUP_FSC_AMILO_PI1505, 10073 ALC861_FIXUP_AMP_VREF_0F, 10074 ALC861_FIXUP_NO_JACK_DETECT, 10075 ALC861_FIXUP_ASUS_A6RP, 10076 ALC660_FIXUP_ASUS_W7J, 10077 }; 10078 10079 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */ 10080 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec, 10081 const struct hda_fixup *fix, int action) 10082 { 10083 struct alc_spec *spec = codec->spec; 10084 unsigned int val; 10085 10086 if (action != HDA_FIXUP_ACT_INIT) 10087 return; 10088 val = snd_hda_codec_get_pin_target(codec, 0x0f); 10089 if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))) 10090 val |= AC_PINCTL_IN_EN; 10091 val |= AC_PINCTL_VREF_50; 10092 snd_hda_set_pin_ctl(codec, 0x0f, val); 10093 spec->gen.keep_vref_in_automute = 1; 10094 } 10095 10096 /* suppress the jack-detection */ 10097 static void alc_fixup_no_jack_detect(struct hda_codec *codec, 10098 const struct hda_fixup *fix, int action) 10099 { 10100 if (action == HDA_FIXUP_ACT_PRE_PROBE) 10101 codec->no_jack_detect = 1; 10102 } 10103 10104 static const struct hda_fixup alc861_fixups[] = { 10105 [ALC861_FIXUP_FSC_AMILO_PI1505] = { 10106 .type = HDA_FIXUP_PINS, 10107 .v.pins = (const struct hda_pintbl[]) { 10108 { 0x0b, 0x0221101f }, /* HP */ 10109 { 0x0f, 0x90170310 }, /* speaker */ 10110 { } 10111 } 10112 }, 10113 [ALC861_FIXUP_AMP_VREF_0F] = { 10114 .type = HDA_FIXUP_FUNC, 10115 .v.func = alc861_fixup_asus_amp_vref_0f, 10116 }, 10117 [ALC861_FIXUP_NO_JACK_DETECT] = { 10118 .type = HDA_FIXUP_FUNC, 10119 .v.func = alc_fixup_no_jack_detect, 10120 }, 10121 [ALC861_FIXUP_ASUS_A6RP] = { 10122 .type = HDA_FIXUP_FUNC, 10123 .v.func = alc861_fixup_asus_amp_vref_0f, 10124 .chained = true, 10125 .chain_id = ALC861_FIXUP_NO_JACK_DETECT, 10126 }, 10127 [ALC660_FIXUP_ASUS_W7J] = { 10128 .type = HDA_FIXUP_VERBS, 10129 .v.verbs = (const struct hda_verb[]) { 10130 /* ASUS W7J needs a magic pin setup on unused NID 0x10 10131 * for enabling outputs 10132 */ 10133 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 10134 { } 10135 }, 10136 } 10137 }; 10138 10139 static const struct snd_pci_quirk alc861_fixup_tbl[] = { 10140 SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J), 10141 SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J), 10142 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP), 10143 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F), 10144 SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT), 10145 SND_PCI_QUIRK_VENDOR(0x1584, "Haier/Uniwill", ALC861_FIXUP_AMP_VREF_0F), 10146 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505), 10147 {} 10148 }; 10149 10150 /* 10151 */ 10152 static int patch_alc861(struct hda_codec *codec) 10153 { 10154 struct alc_spec *spec; 10155 int err; 10156 10157 err = alc_alloc_spec(codec, 0x15); 10158 if (err < 0) 10159 return err; 10160 10161 spec = codec->spec; 10162 if (has_cdefine_beep(codec)) 10163 spec->gen.beep_nid = 0x23; 10164 10165 #ifdef CONFIG_PM 10166 spec->power_hook = alc_power_eapd; 10167 #endif 10168 10169 alc_pre_init(codec); 10170 10171 snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups); 10172 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 10173 10174 /* automatic parse from the BIOS config */ 10175 err = alc861_parse_auto_config(codec); 10176 if (err < 0) 10177 goto error; 10178 10179 if (!spec->gen.no_analog) { 10180 err = set_beep_amp(spec, 0x23, 0, HDA_OUTPUT); 10181 if (err < 0) 10182 goto error; 10183 } 10184 10185 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 10186 10187 return 0; 10188 10189 error: 10190 alc_free(codec); 10191 return err; 10192 } 10193 10194 /* 10195 * ALC861-VD support 10196 * 10197 * Based on ALC882 10198 * 10199 * In addition, an independent DAC 10200 */ 10201 static int alc861vd_parse_auto_config(struct hda_codec *codec) 10202 { 10203 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 }; 10204 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 10205 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids); 10206 } 10207 10208 enum { 10209 ALC660VD_FIX_ASUS_GPIO1, 10210 ALC861VD_FIX_DALLAS, 10211 }; 10212 10213 /* exclude VREF80 */ 10214 static void alc861vd_fixup_dallas(struct hda_codec *codec, 10215 const struct hda_fixup *fix, int action) 10216 { 10217 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 10218 snd_hda_override_pin_caps(codec, 0x18, 0x00000734); 10219 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c); 10220 } 10221 } 10222 10223 /* reset GPIO1 */ 10224 static void alc660vd_fixup_asus_gpio1(struct hda_codec *codec, 10225 const struct hda_fixup *fix, int action) 10226 { 10227 struct alc_spec *spec = codec->spec; 10228 10229 if (action == HDA_FIXUP_ACT_PRE_PROBE) 10230 spec->gpio_mask |= 0x02; 10231 alc_fixup_gpio(codec, action, 0x01); 10232 } 10233 10234 static const struct hda_fixup alc861vd_fixups[] = { 10235 [ALC660VD_FIX_ASUS_GPIO1] = { 10236 .type = HDA_FIXUP_FUNC, 10237 .v.func = alc660vd_fixup_asus_gpio1, 10238 }, 10239 [ALC861VD_FIX_DALLAS] = { 10240 .type = HDA_FIXUP_FUNC, 10241 .v.func = alc861vd_fixup_dallas, 10242 }, 10243 }; 10244 10245 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = { 10246 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS), 10247 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1), 10248 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS), 10249 {} 10250 }; 10251 10252 /* 10253 */ 10254 static int patch_alc861vd(struct hda_codec *codec) 10255 { 10256 struct alc_spec *spec; 10257 int err; 10258 10259 err = alc_alloc_spec(codec, 0x0b); 10260 if (err < 0) 10261 return err; 10262 10263 spec = codec->spec; 10264 if (has_cdefine_beep(codec)) 10265 spec->gen.beep_nid = 0x23; 10266 10267 spec->shutup = alc_eapd_shutup; 10268 10269 alc_pre_init(codec); 10270 10271 snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups); 10272 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 10273 10274 /* automatic parse from the BIOS config */ 10275 err = alc861vd_parse_auto_config(codec); 10276 if (err < 0) 10277 goto error; 10278 10279 if (!spec->gen.no_analog) { 10280 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 10281 if (err < 0) 10282 goto error; 10283 } 10284 10285 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 10286 10287 return 0; 10288 10289 error: 10290 alc_free(codec); 10291 return err; 10292 } 10293 10294 /* 10295 * ALC662 support 10296 * 10297 * ALC662 is almost identical with ALC880 but has cleaner and more flexible 10298 * configuration. Each pin widget can choose any input DACs and a mixer. 10299 * Each ADC is connected from a mixer of all inputs. This makes possible 10300 * 6-channel independent captures. 10301 * 10302 * In addition, an independent DAC for the multi-playback (not used in this 10303 * driver yet). 10304 */ 10305 10306 /* 10307 * BIOS auto configuration 10308 */ 10309 10310 static int alc662_parse_auto_config(struct hda_codec *codec) 10311 { 10312 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 }; 10313 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 }; 10314 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 10315 const hda_nid_t *ssids; 10316 10317 if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 || 10318 codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 || 10319 codec->core.vendor_id == 0x10ec0671) 10320 ssids = alc663_ssids; 10321 else 10322 ssids = alc662_ssids; 10323 return alc_parse_auto_config(codec, alc662_ignore, ssids); 10324 } 10325 10326 static void alc272_fixup_mario(struct hda_codec *codec, 10327 const struct hda_fixup *fix, int action) 10328 { 10329 if (action != HDA_FIXUP_ACT_PRE_PROBE) 10330 return; 10331 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT, 10332 (0x3b << AC_AMPCAP_OFFSET_SHIFT) | 10333 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) | 10334 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) | 10335 (0 << AC_AMPCAP_MUTE_SHIFT))) 10336 codec_warn(codec, "failed to override amp caps for NID 0x2\n"); 10337 } 10338 10339 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = { 10340 { .channels = 2, 10341 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } }, 10342 { .channels = 4, 10343 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, 10344 SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */ 10345 { } 10346 }; 10347 10348 /* override the 2.1 chmap */ 10349 static void alc_fixup_bass_chmap(struct hda_codec *codec, 10350 const struct hda_fixup *fix, int action) 10351 { 10352 if (action == HDA_FIXUP_ACT_BUILD) { 10353 struct alc_spec *spec = codec->spec; 10354 spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps; 10355 } 10356 } 10357 10358 /* avoid D3 for keeping GPIO up */ 10359 static unsigned int gpio_led_power_filter(struct hda_codec *codec, 10360 hda_nid_t nid, 10361 unsigned int power_state) 10362 { 10363 struct alc_spec *spec = codec->spec; 10364 if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_data) 10365 return AC_PWRST_D0; 10366 return power_state; 10367 } 10368 10369 static void alc662_fixup_led_gpio1(struct hda_codec *codec, 10370 const struct hda_fixup *fix, int action) 10371 { 10372 struct alc_spec *spec = codec->spec; 10373 10374 alc_fixup_hp_gpio_led(codec, action, 0x01, 0); 10375 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 10376 spec->mute_led_polarity = 1; 10377 codec->power_filter = gpio_led_power_filter; 10378 } 10379 } 10380 10381 static void alc662_usi_automute_hook(struct hda_codec *codec, 10382 struct hda_jack_callback *jack) 10383 { 10384 struct alc_spec *spec = codec->spec; 10385 int vref; 10386 msleep(200); 10387 snd_hda_gen_hp_automute(codec, jack); 10388 10389 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0; 10390 msleep(100); 10391 snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 10392 vref); 10393 } 10394 10395 static void alc662_fixup_usi_headset_mic(struct hda_codec *codec, 10396 const struct hda_fixup *fix, int action) 10397 { 10398 struct alc_spec *spec = codec->spec; 10399 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 10400 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 10401 spec->gen.hp_automute_hook = alc662_usi_automute_hook; 10402 } 10403 } 10404 10405 static void alc662_aspire_ethos_mute_speakers(struct hda_codec *codec, 10406 struct hda_jack_callback *cb) 10407 { 10408 /* surround speakers at 0x1b already get muted automatically when 10409 * headphones are plugged in, but we have to mute/unmute the remaining 10410 * channels manually: 10411 * 0x15 - front left/front right 10412 * 0x18 - front center/ LFE 10413 */ 10414 if (snd_hda_jack_detect_state(codec, 0x1b) == HDA_JACK_PRESENT) { 10415 snd_hda_set_pin_ctl_cache(codec, 0x15, 0); 10416 snd_hda_set_pin_ctl_cache(codec, 0x18, 0); 10417 } else { 10418 snd_hda_set_pin_ctl_cache(codec, 0x15, PIN_OUT); 10419 snd_hda_set_pin_ctl_cache(codec, 0x18, PIN_OUT); 10420 } 10421 } 10422 10423 static void alc662_fixup_aspire_ethos_hp(struct hda_codec *codec, 10424 const struct hda_fixup *fix, int action) 10425 { 10426 /* Pin 0x1b: shared headphones jack and surround speakers */ 10427 if (!is_jack_detectable(codec, 0x1b)) 10428 return; 10429 10430 switch (action) { 10431 case HDA_FIXUP_ACT_PRE_PROBE: 10432 snd_hda_jack_detect_enable_callback(codec, 0x1b, 10433 alc662_aspire_ethos_mute_speakers); 10434 /* subwoofer needs an extra GPIO setting to become audible */ 10435 alc_setup_gpio(codec, 0x02); 10436 break; 10437 case HDA_FIXUP_ACT_INIT: 10438 /* Make sure to start in a correct state, i.e. if 10439 * headphones have been plugged in before powering up the system 10440 */ 10441 alc662_aspire_ethos_mute_speakers(codec, NULL); 10442 break; 10443 } 10444 } 10445 10446 static void alc671_fixup_hp_headset_mic2(struct hda_codec *codec, 10447 const struct hda_fixup *fix, int action) 10448 { 10449 struct alc_spec *spec = codec->spec; 10450 10451 static const struct hda_pintbl pincfgs[] = { 10452 { 0x19, 0x02a11040 }, /* use as headset mic, with its own jack detect */ 10453 { 0x1b, 0x0181304f }, 10454 { } 10455 }; 10456 10457 switch (action) { 10458 case HDA_FIXUP_ACT_PRE_PROBE: 10459 spec->gen.mixer_nid = 0; 10460 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 10461 snd_hda_apply_pincfgs(codec, pincfgs); 10462 break; 10463 case HDA_FIXUP_ACT_INIT: 10464 alc_write_coef_idx(codec, 0x19, 0xa054); 10465 break; 10466 } 10467 } 10468 10469 static void alc897_hp_automute_hook(struct hda_codec *codec, 10470 struct hda_jack_callback *jack) 10471 { 10472 struct alc_spec *spec = codec->spec; 10473 int vref; 10474 10475 snd_hda_gen_hp_automute(codec, jack); 10476 vref = spec->gen.hp_jack_present ? (PIN_HP | AC_PINCTL_VREF_100) : PIN_HP; 10477 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 10478 vref); 10479 } 10480 10481 static void alc897_fixup_lenovo_headset_mic(struct hda_codec *codec, 10482 const struct hda_fixup *fix, int action) 10483 { 10484 struct alc_spec *spec = codec->spec; 10485 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 10486 spec->gen.hp_automute_hook = alc897_hp_automute_hook; 10487 } 10488 } 10489 10490 static const struct coef_fw alc668_coefs[] = { 10491 WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03, 0x0), 10492 WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06, 0x0), WRITE_COEF(0x07, 0x0f80), 10493 WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b, 0x0), 10494 WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f), 10495 WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001), 10496 WRITE_COEF(0x13, 0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940), 10497 WRITE_COEF(0x19, 0x0), WRITE_COEF(0x1a, 0x0), WRITE_COEF(0x1b, 0x0), 10498 WRITE_COEF(0x1c, 0x0), WRITE_COEF(0x1d, 0x0), WRITE_COEF(0x1e, 0x7418), 10499 WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468), 10500 WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418), 10501 WRITE_COEF(0x27, 0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00), 10502 WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000), 10503 WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac, 0x0), 10504 WRITE_COEF(0xad, 0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480), 10505 WRITE_COEF(0xb0, 0x0), WRITE_COEF(0xb1, 0x0), WRITE_COEF(0xb2, 0x0), 10506 WRITE_COEF(0xb3, 0x0), WRITE_COEF(0xb4, 0x0), WRITE_COEF(0xb5, 0x1040), 10507 WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697), 10508 WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab), 10509 WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02), 10510 WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6), 10511 {} 10512 }; 10513 10514 static void alc668_restore_default_value(struct hda_codec *codec) 10515 { 10516 alc_process_coef_fw(codec, alc668_coefs); 10517 } 10518 10519 enum { 10520 ALC662_FIXUP_ASPIRE, 10521 ALC662_FIXUP_LED_GPIO1, 10522 ALC662_FIXUP_IDEAPAD, 10523 ALC272_FIXUP_MARIO, 10524 ALC662_FIXUP_CZC_ET26, 10525 ALC662_FIXUP_CZC_P10T, 10526 ALC662_FIXUP_SKU_IGNORE, 10527 ALC662_FIXUP_HP_RP5800, 10528 ALC662_FIXUP_ASUS_MODE1, 10529 ALC662_FIXUP_ASUS_MODE2, 10530 ALC662_FIXUP_ASUS_MODE3, 10531 ALC662_FIXUP_ASUS_MODE4, 10532 ALC662_FIXUP_ASUS_MODE5, 10533 ALC662_FIXUP_ASUS_MODE6, 10534 ALC662_FIXUP_ASUS_MODE7, 10535 ALC662_FIXUP_ASUS_MODE8, 10536 ALC662_FIXUP_NO_JACK_DETECT, 10537 ALC662_FIXUP_ZOTAC_Z68, 10538 ALC662_FIXUP_INV_DMIC, 10539 ALC662_FIXUP_DELL_MIC_NO_PRESENCE, 10540 ALC668_FIXUP_DELL_MIC_NO_PRESENCE, 10541 ALC662_FIXUP_HEADSET_MODE, 10542 ALC668_FIXUP_HEADSET_MODE, 10543 ALC662_FIXUP_BASS_MODE4_CHMAP, 10544 ALC662_FIXUP_BASS_16, 10545 ALC662_FIXUP_BASS_1A, 10546 ALC662_FIXUP_BASS_CHMAP, 10547 ALC668_FIXUP_AUTO_MUTE, 10548 ALC668_FIXUP_DELL_DISABLE_AAMIX, 10549 ALC668_FIXUP_DELL_XPS13, 10550 ALC662_FIXUP_ASUS_Nx50, 10551 ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE, 10552 ALC668_FIXUP_ASUS_Nx51, 10553 ALC668_FIXUP_MIC_COEF, 10554 ALC668_FIXUP_ASUS_G751, 10555 ALC891_FIXUP_HEADSET_MODE, 10556 ALC891_FIXUP_DELL_MIC_NO_PRESENCE, 10557 ALC662_FIXUP_ACER_VERITON, 10558 ALC892_FIXUP_ASROCK_MOBO, 10559 ALC662_FIXUP_USI_FUNC, 10560 ALC662_FIXUP_USI_HEADSET_MODE, 10561 ALC662_FIXUP_LENOVO_MULTI_CODECS, 10562 ALC669_FIXUP_ACER_ASPIRE_ETHOS, 10563 ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET, 10564 ALC671_FIXUP_HP_HEADSET_MIC2, 10565 ALC662_FIXUP_ACER_X2660G_HEADSET_MODE, 10566 ALC662_FIXUP_ACER_NITRO_HEADSET_MODE, 10567 ALC668_FIXUP_ASUS_NO_HEADSET_MIC, 10568 ALC668_FIXUP_HEADSET_MIC, 10569 ALC668_FIXUP_MIC_DET_COEF, 10570 ALC897_FIXUP_LENOVO_HEADSET_MIC, 10571 ALC897_FIXUP_HEADSET_MIC_PIN, 10572 }; 10573 10574 static const struct hda_fixup alc662_fixups[] = { 10575 [ALC662_FIXUP_ASPIRE] = { 10576 .type = HDA_FIXUP_PINS, 10577 .v.pins = (const struct hda_pintbl[]) { 10578 { 0x15, 0x99130112 }, /* subwoofer */ 10579 { } 10580 } 10581 }, 10582 [ALC662_FIXUP_LED_GPIO1] = { 10583 .type = HDA_FIXUP_FUNC, 10584 .v.func = alc662_fixup_led_gpio1, 10585 }, 10586 [ALC662_FIXUP_IDEAPAD] = { 10587 .type = HDA_FIXUP_PINS, 10588 .v.pins = (const struct hda_pintbl[]) { 10589 { 0x17, 0x99130112 }, /* subwoofer */ 10590 { } 10591 }, 10592 .chained = true, 10593 .chain_id = ALC662_FIXUP_LED_GPIO1, 10594 }, 10595 [ALC272_FIXUP_MARIO] = { 10596 .type = HDA_FIXUP_FUNC, 10597 .v.func = alc272_fixup_mario, 10598 }, 10599 [ALC662_FIXUP_CZC_ET26] = { 10600 .type = HDA_FIXUP_PINS, 10601 .v.pins = (const struct hda_pintbl[]) { 10602 {0x12, 0x403cc000}, 10603 {0x14, 0x90170110}, /* speaker */ 10604 {0x15, 0x411111f0}, 10605 {0x16, 0x411111f0}, 10606 {0x18, 0x01a19030}, /* mic */ 10607 {0x19, 0x90a7013f}, /* int-mic */ 10608 {0x1a, 0x01014020}, 10609 {0x1b, 0x0121401f}, 10610 {0x1c, 0x411111f0}, 10611 {0x1d, 0x411111f0}, 10612 {0x1e, 0x40478e35}, 10613 {} 10614 }, 10615 .chained = true, 10616 .chain_id = ALC662_FIXUP_SKU_IGNORE 10617 }, 10618 [ALC662_FIXUP_CZC_P10T] = { 10619 .type = HDA_FIXUP_VERBS, 10620 .v.verbs = (const struct hda_verb[]) { 10621 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0}, 10622 {} 10623 } 10624 }, 10625 [ALC662_FIXUP_SKU_IGNORE] = { 10626 .type = HDA_FIXUP_FUNC, 10627 .v.func = alc_fixup_sku_ignore, 10628 }, 10629 [ALC662_FIXUP_HP_RP5800] = { 10630 .type = HDA_FIXUP_PINS, 10631 .v.pins = (const struct hda_pintbl[]) { 10632 { 0x14, 0x0221201f }, /* HP out */ 10633 { } 10634 }, 10635 .chained = true, 10636 .chain_id = ALC662_FIXUP_SKU_IGNORE 10637 }, 10638 [ALC662_FIXUP_ASUS_MODE1] = { 10639 .type = HDA_FIXUP_PINS, 10640 .v.pins = (const struct hda_pintbl[]) { 10641 { 0x14, 0x99130110 }, /* speaker */ 10642 { 0x18, 0x01a19c20 }, /* mic */ 10643 { 0x19, 0x99a3092f }, /* int-mic */ 10644 { 0x21, 0x0121401f }, /* HP out */ 10645 { } 10646 }, 10647 .chained = true, 10648 .chain_id = ALC662_FIXUP_SKU_IGNORE 10649 }, 10650 [ALC662_FIXUP_ASUS_MODE2] = { 10651 .type = HDA_FIXUP_PINS, 10652 .v.pins = (const struct hda_pintbl[]) { 10653 { 0x14, 0x99130110 }, /* speaker */ 10654 { 0x18, 0x01a19820 }, /* mic */ 10655 { 0x19, 0x99a3092f }, /* int-mic */ 10656 { 0x1b, 0x0121401f }, /* HP out */ 10657 { } 10658 }, 10659 .chained = true, 10660 .chain_id = ALC662_FIXUP_SKU_IGNORE 10661 }, 10662 [ALC662_FIXUP_ASUS_MODE3] = { 10663 .type = HDA_FIXUP_PINS, 10664 .v.pins = (const struct hda_pintbl[]) { 10665 { 0x14, 0x99130110 }, /* speaker */ 10666 { 0x15, 0x0121441f }, /* HP */ 10667 { 0x18, 0x01a19840 }, /* mic */ 10668 { 0x19, 0x99a3094f }, /* int-mic */ 10669 { 0x21, 0x01211420 }, /* HP2 */ 10670 { } 10671 }, 10672 .chained = true, 10673 .chain_id = ALC662_FIXUP_SKU_IGNORE 10674 }, 10675 [ALC662_FIXUP_ASUS_MODE4] = { 10676 .type = HDA_FIXUP_PINS, 10677 .v.pins = (const struct hda_pintbl[]) { 10678 { 0x14, 0x99130110 }, /* speaker */ 10679 { 0x16, 0x99130111 }, /* speaker */ 10680 { 0x18, 0x01a19840 }, /* mic */ 10681 { 0x19, 0x99a3094f }, /* int-mic */ 10682 { 0x21, 0x0121441f }, /* HP */ 10683 { } 10684 }, 10685 .chained = true, 10686 .chain_id = ALC662_FIXUP_SKU_IGNORE 10687 }, 10688 [ALC662_FIXUP_ASUS_MODE5] = { 10689 .type = HDA_FIXUP_PINS, 10690 .v.pins = (const struct hda_pintbl[]) { 10691 { 0x14, 0x99130110 }, /* speaker */ 10692 { 0x15, 0x0121441f }, /* HP */ 10693 { 0x16, 0x99130111 }, /* speaker */ 10694 { 0x18, 0x01a19840 }, /* mic */ 10695 { 0x19, 0x99a3094f }, /* int-mic */ 10696 { } 10697 }, 10698 .chained = true, 10699 .chain_id = ALC662_FIXUP_SKU_IGNORE 10700 }, 10701 [ALC662_FIXUP_ASUS_MODE6] = { 10702 .type = HDA_FIXUP_PINS, 10703 .v.pins = (const struct hda_pintbl[]) { 10704 { 0x14, 0x99130110 }, /* speaker */ 10705 { 0x15, 0x01211420 }, /* HP2 */ 10706 { 0x18, 0x01a19840 }, /* mic */ 10707 { 0x19, 0x99a3094f }, /* int-mic */ 10708 { 0x1b, 0x0121441f }, /* HP */ 10709 { } 10710 }, 10711 .chained = true, 10712 .chain_id = ALC662_FIXUP_SKU_IGNORE 10713 }, 10714 [ALC662_FIXUP_ASUS_MODE7] = { 10715 .type = HDA_FIXUP_PINS, 10716 .v.pins = (const struct hda_pintbl[]) { 10717 { 0x14, 0x99130110 }, /* speaker */ 10718 { 0x17, 0x99130111 }, /* speaker */ 10719 { 0x18, 0x01a19840 }, /* mic */ 10720 { 0x19, 0x99a3094f }, /* int-mic */ 10721 { 0x1b, 0x01214020 }, /* HP */ 10722 { 0x21, 0x0121401f }, /* HP */ 10723 { } 10724 }, 10725 .chained = true, 10726 .chain_id = ALC662_FIXUP_SKU_IGNORE 10727 }, 10728 [ALC662_FIXUP_ASUS_MODE8] = { 10729 .type = HDA_FIXUP_PINS, 10730 .v.pins = (const struct hda_pintbl[]) { 10731 { 0x14, 0x99130110 }, /* speaker */ 10732 { 0x12, 0x99a30970 }, /* int-mic */ 10733 { 0x15, 0x01214020 }, /* HP */ 10734 { 0x17, 0x99130111 }, /* speaker */ 10735 { 0x18, 0x01a19840 }, /* mic */ 10736 { 0x21, 0x0121401f }, /* HP */ 10737 { } 10738 }, 10739 .chained = true, 10740 .chain_id = ALC662_FIXUP_SKU_IGNORE 10741 }, 10742 [ALC662_FIXUP_NO_JACK_DETECT] = { 10743 .type = HDA_FIXUP_FUNC, 10744 .v.func = alc_fixup_no_jack_detect, 10745 }, 10746 [ALC662_FIXUP_ZOTAC_Z68] = { 10747 .type = HDA_FIXUP_PINS, 10748 .v.pins = (const struct hda_pintbl[]) { 10749 { 0x1b, 0x02214020 }, /* Front HP */ 10750 { } 10751 } 10752 }, 10753 [ALC662_FIXUP_INV_DMIC] = { 10754 .type = HDA_FIXUP_FUNC, 10755 .v.func = alc_fixup_inv_dmic, 10756 }, 10757 [ALC668_FIXUP_DELL_XPS13] = { 10758 .type = HDA_FIXUP_FUNC, 10759 .v.func = alc_fixup_dell_xps13, 10760 .chained = true, 10761 .chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX 10762 }, 10763 [ALC668_FIXUP_DELL_DISABLE_AAMIX] = { 10764 .type = HDA_FIXUP_FUNC, 10765 .v.func = alc_fixup_disable_aamix, 10766 .chained = true, 10767 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE 10768 }, 10769 [ALC668_FIXUP_AUTO_MUTE] = { 10770 .type = HDA_FIXUP_FUNC, 10771 .v.func = alc_fixup_auto_mute_via_amp, 10772 .chained = true, 10773 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE 10774 }, 10775 [ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = { 10776 .type = HDA_FIXUP_PINS, 10777 .v.pins = (const struct hda_pintbl[]) { 10778 { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */ 10779 /* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */ 10780 { } 10781 }, 10782 .chained = true, 10783 .chain_id = ALC662_FIXUP_HEADSET_MODE 10784 }, 10785 [ALC662_FIXUP_HEADSET_MODE] = { 10786 .type = HDA_FIXUP_FUNC, 10787 .v.func = alc_fixup_headset_mode_alc662, 10788 }, 10789 [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = { 10790 .type = HDA_FIXUP_PINS, 10791 .v.pins = (const struct hda_pintbl[]) { 10792 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */ 10793 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */ 10794 { } 10795 }, 10796 .chained = true, 10797 .chain_id = ALC668_FIXUP_HEADSET_MODE 10798 }, 10799 [ALC668_FIXUP_HEADSET_MODE] = { 10800 .type = HDA_FIXUP_FUNC, 10801 .v.func = alc_fixup_headset_mode_alc668, 10802 }, 10803 [ALC662_FIXUP_BASS_MODE4_CHMAP] = { 10804 .type = HDA_FIXUP_FUNC, 10805 .v.func = alc_fixup_bass_chmap, 10806 .chained = true, 10807 .chain_id = ALC662_FIXUP_ASUS_MODE4 10808 }, 10809 [ALC662_FIXUP_BASS_16] = { 10810 .type = HDA_FIXUP_PINS, 10811 .v.pins = (const struct hda_pintbl[]) { 10812 {0x16, 0x80106111}, /* bass speaker */ 10813 {} 10814 }, 10815 .chained = true, 10816 .chain_id = ALC662_FIXUP_BASS_CHMAP, 10817 }, 10818 [ALC662_FIXUP_BASS_1A] = { 10819 .type = HDA_FIXUP_PINS, 10820 .v.pins = (const struct hda_pintbl[]) { 10821 {0x1a, 0x80106111}, /* bass speaker */ 10822 {} 10823 }, 10824 .chained = true, 10825 .chain_id = ALC662_FIXUP_BASS_CHMAP, 10826 }, 10827 [ALC662_FIXUP_BASS_CHMAP] = { 10828 .type = HDA_FIXUP_FUNC, 10829 .v.func = alc_fixup_bass_chmap, 10830 }, 10831 [ALC662_FIXUP_ASUS_Nx50] = { 10832 .type = HDA_FIXUP_FUNC, 10833 .v.func = alc_fixup_auto_mute_via_amp, 10834 .chained = true, 10835 .chain_id = ALC662_FIXUP_BASS_1A 10836 }, 10837 [ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = { 10838 .type = HDA_FIXUP_FUNC, 10839 .v.func = alc_fixup_headset_mode_alc668, 10840 .chain_id = ALC662_FIXUP_BASS_CHMAP 10841 }, 10842 [ALC668_FIXUP_ASUS_Nx51] = { 10843 .type = HDA_FIXUP_PINS, 10844 .v.pins = (const struct hda_pintbl[]) { 10845 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */ 10846 { 0x1a, 0x90170151 }, /* bass speaker */ 10847 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */ 10848 {} 10849 }, 10850 .chained = true, 10851 .chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE, 10852 }, 10853 [ALC668_FIXUP_MIC_COEF] = { 10854 .type = HDA_FIXUP_VERBS, 10855 .v.verbs = (const struct hda_verb[]) { 10856 { 0x20, AC_VERB_SET_COEF_INDEX, 0xc3 }, 10857 { 0x20, AC_VERB_SET_PROC_COEF, 0x4000 }, 10858 {} 10859 }, 10860 }, 10861 [ALC668_FIXUP_ASUS_G751] = { 10862 .type = HDA_FIXUP_PINS, 10863 .v.pins = (const struct hda_pintbl[]) { 10864 { 0x16, 0x0421101f }, /* HP */ 10865 {} 10866 }, 10867 .chained = true, 10868 .chain_id = ALC668_FIXUP_MIC_COEF 10869 }, 10870 [ALC891_FIXUP_HEADSET_MODE] = { 10871 .type = HDA_FIXUP_FUNC, 10872 .v.func = alc_fixup_headset_mode, 10873 }, 10874 [ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = { 10875 .type = HDA_FIXUP_PINS, 10876 .v.pins = (const struct hda_pintbl[]) { 10877 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */ 10878 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */ 10879 { } 10880 }, 10881 .chained = true, 10882 .chain_id = ALC891_FIXUP_HEADSET_MODE 10883 }, 10884 [ALC662_FIXUP_ACER_VERITON] = { 10885 .type = HDA_FIXUP_PINS, 10886 .v.pins = (const struct hda_pintbl[]) { 10887 { 0x15, 0x50170120 }, /* no internal speaker */ 10888 { } 10889 } 10890 }, 10891 [ALC892_FIXUP_ASROCK_MOBO] = { 10892 .type = HDA_FIXUP_PINS, 10893 .v.pins = (const struct hda_pintbl[]) { 10894 { 0x15, 0x40f000f0 }, /* disabled */ 10895 { 0x16, 0x40f000f0 }, /* disabled */ 10896 { } 10897 } 10898 }, 10899 [ALC662_FIXUP_USI_FUNC] = { 10900 .type = HDA_FIXUP_FUNC, 10901 .v.func = alc662_fixup_usi_headset_mic, 10902 }, 10903 [ALC662_FIXUP_USI_HEADSET_MODE] = { 10904 .type = HDA_FIXUP_PINS, 10905 .v.pins = (const struct hda_pintbl[]) { 10906 { 0x19, 0x02a1913c }, /* use as headset mic, without its own jack detect */ 10907 { 0x18, 0x01a1903d }, 10908 { } 10909 }, 10910 .chained = true, 10911 .chain_id = ALC662_FIXUP_USI_FUNC 10912 }, 10913 [ALC662_FIXUP_LENOVO_MULTI_CODECS] = { 10914 .type = HDA_FIXUP_FUNC, 10915 .v.func = alc233_alc662_fixup_lenovo_dual_codecs, 10916 }, 10917 [ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET] = { 10918 .type = HDA_FIXUP_FUNC, 10919 .v.func = alc662_fixup_aspire_ethos_hp, 10920 }, 10921 [ALC669_FIXUP_ACER_ASPIRE_ETHOS] = { 10922 .type = HDA_FIXUP_PINS, 10923 .v.pins = (const struct hda_pintbl[]) { 10924 { 0x15, 0x92130110 }, /* front speakers */ 10925 { 0x18, 0x99130111 }, /* center/subwoofer */ 10926 { 0x1b, 0x11130012 }, /* surround plus jack for HP */ 10927 { } 10928 }, 10929 .chained = true, 10930 .chain_id = ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET 10931 }, 10932 [ALC671_FIXUP_HP_HEADSET_MIC2] = { 10933 .type = HDA_FIXUP_FUNC, 10934 .v.func = alc671_fixup_hp_headset_mic2, 10935 }, 10936 [ALC662_FIXUP_ACER_X2660G_HEADSET_MODE] = { 10937 .type = HDA_FIXUP_PINS, 10938 .v.pins = (const struct hda_pintbl[]) { 10939 { 0x1a, 0x02a1113c }, /* use as headset mic, without its own jack detect */ 10940 { } 10941 }, 10942 .chained = true, 10943 .chain_id = ALC662_FIXUP_USI_FUNC 10944 }, 10945 [ALC662_FIXUP_ACER_NITRO_HEADSET_MODE] = { 10946 .type = HDA_FIXUP_PINS, 10947 .v.pins = (const struct hda_pintbl[]) { 10948 { 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */ 10949 { 0x1b, 0x0221144f }, 10950 { } 10951 }, 10952 .chained = true, 10953 .chain_id = ALC662_FIXUP_USI_FUNC 10954 }, 10955 [ALC668_FIXUP_ASUS_NO_HEADSET_MIC] = { 10956 .type = HDA_FIXUP_PINS, 10957 .v.pins = (const struct hda_pintbl[]) { 10958 { 0x1b, 0x04a1112c }, 10959 { } 10960 }, 10961 .chained = true, 10962 .chain_id = ALC668_FIXUP_HEADSET_MIC 10963 }, 10964 [ALC668_FIXUP_HEADSET_MIC] = { 10965 .type = HDA_FIXUP_FUNC, 10966 .v.func = alc269_fixup_headset_mic, 10967 .chained = true, 10968 .chain_id = ALC668_FIXUP_MIC_DET_COEF 10969 }, 10970 [ALC668_FIXUP_MIC_DET_COEF] = { 10971 .type = HDA_FIXUP_VERBS, 10972 .v.verbs = (const struct hda_verb[]) { 10973 { 0x20, AC_VERB_SET_COEF_INDEX, 0x15 }, 10974 { 0x20, AC_VERB_SET_PROC_COEF, 0x0d60 }, 10975 {} 10976 }, 10977 }, 10978 [ALC897_FIXUP_LENOVO_HEADSET_MIC] = { 10979 .type = HDA_FIXUP_FUNC, 10980 .v.func = alc897_fixup_lenovo_headset_mic, 10981 }, 10982 [ALC897_FIXUP_HEADSET_MIC_PIN] = { 10983 .type = HDA_FIXUP_PINS, 10984 .v.pins = (const struct hda_pintbl[]) { 10985 { 0x1a, 0x03a11050 }, 10986 { } 10987 }, 10988 .chained = true, 10989 .chain_id = ALC897_FIXUP_LENOVO_HEADSET_MIC 10990 }, 10991 }; 10992 10993 static const struct snd_pci_quirk alc662_fixup_tbl[] = { 10994 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2), 10995 SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC), 10996 SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC), 10997 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE), 10998 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE), 10999 SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC), 11000 SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC), 11001 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE), 11002 SND_PCI_QUIRK(0x1025, 0x0566, "Acer Aspire Ethos 8951G", ALC669_FIXUP_ACER_ASPIRE_ETHOS), 11003 SND_PCI_QUIRK(0x1025, 0x123c, "Acer Nitro N50-600", ALC662_FIXUP_ACER_NITRO_HEADSET_MODE), 11004 SND_PCI_QUIRK(0x1025, 0x124e, "Acer 2660G", ALC662_FIXUP_ACER_X2660G_HEADSET_MODE), 11005 SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 11006 SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 11007 SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13), 11008 SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13), 11009 SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13), 11010 SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 11011 SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 11012 SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 11013 SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 11014 SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 11015 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800), 11016 SND_PCI_QUIRK(0x103c, 0x873e, "HP", ALC671_FIXUP_HP_HEADSET_MIC2), 11017 SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE), 11018 SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50), 11019 SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50), 11020 SND_PCI_QUIRK(0x1043, 0x12ff, "ASUS G751", ALC668_FIXUP_ASUS_G751), 11021 SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A), 11022 SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP), 11023 SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16), 11024 SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51), 11025 SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51), 11026 SND_PCI_QUIRK(0x1043, 0x185d, "ASUS G551JW", ALC668_FIXUP_ASUS_NO_HEADSET_MIC), 11027 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8), 11028 SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16), 11029 SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP), 11030 SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT), 11031 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2), 11032 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD), 11033 SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE), 11034 SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS), 11035 SND_PCI_QUIRK(0x17aa, 0x32ca, "Lenovo ThinkCentre M80", ALC897_FIXUP_HEADSET_MIC_PIN), 11036 SND_PCI_QUIRK(0x17aa, 0x32cb, "Lenovo ThinkCentre M70", ALC897_FIXUP_HEADSET_MIC_PIN), 11037 SND_PCI_QUIRK(0x17aa, 0x32cf, "Lenovo ThinkCentre M950", ALC897_FIXUP_HEADSET_MIC_PIN), 11038 SND_PCI_QUIRK(0x17aa, 0x32f7, "Lenovo ThinkCentre M90", ALC897_FIXUP_HEADSET_MIC_PIN), 11039 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD), 11040 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD), 11041 SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO), 11042 SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68), 11043 SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON), 11044 SND_PCI_QUIRK(0x1b35, 0x1234, "CZC ET26", ALC662_FIXUP_CZC_ET26), 11045 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T), 11046 11047 #if 0 11048 /* Below is a quirk table taken from the old code. 11049 * Basically the device should work as is without the fixup table. 11050 * If BIOS doesn't give a proper info, enable the corresponding 11051 * fixup entry. 11052 */ 11053 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1), 11054 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3), 11055 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1), 11056 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3), 11057 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 11058 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 11059 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 11060 SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1), 11061 SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1), 11062 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 11063 SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7), 11064 SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7), 11065 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8), 11066 SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3), 11067 SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1), 11068 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 11069 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2), 11070 SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1), 11071 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 11072 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6), 11073 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6), 11074 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 11075 SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1), 11076 SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3), 11077 SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2), 11078 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 11079 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5), 11080 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6), 11081 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 11082 SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1), 11083 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 11084 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 11085 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3), 11086 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3), 11087 SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1), 11088 SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1), 11089 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1), 11090 SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1), 11091 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1), 11092 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 11093 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2), 11094 SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1), 11095 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 11096 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3), 11097 SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1), 11098 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1), 11099 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1), 11100 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2), 11101 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 11102 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4), 11103 #endif 11104 {} 11105 }; 11106 11107 static const struct hda_model_fixup alc662_fixup_models[] = { 11108 {.id = ALC662_FIXUP_ASPIRE, .name = "aspire"}, 11109 {.id = ALC662_FIXUP_IDEAPAD, .name = "ideapad"}, 11110 {.id = ALC272_FIXUP_MARIO, .name = "mario"}, 11111 {.id = ALC662_FIXUP_HP_RP5800, .name = "hp-rp5800"}, 11112 {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"}, 11113 {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"}, 11114 {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"}, 11115 {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"}, 11116 {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"}, 11117 {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"}, 11118 {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"}, 11119 {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"}, 11120 {.id = ALC662_FIXUP_ZOTAC_Z68, .name = "zotac-z68"}, 11121 {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"}, 11122 {.id = ALC662_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc662-headset-multi"}, 11123 {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"}, 11124 {.id = ALC662_FIXUP_HEADSET_MODE, .name = "alc662-headset"}, 11125 {.id = ALC668_FIXUP_HEADSET_MODE, .name = "alc668-headset"}, 11126 {.id = ALC662_FIXUP_BASS_16, .name = "bass16"}, 11127 {.id = ALC662_FIXUP_BASS_1A, .name = "bass1a"}, 11128 {.id = ALC668_FIXUP_AUTO_MUTE, .name = "automute"}, 11129 {.id = ALC668_FIXUP_DELL_XPS13, .name = "dell-xps13"}, 11130 {.id = ALC662_FIXUP_ASUS_Nx50, .name = "asus-nx50"}, 11131 {.id = ALC668_FIXUP_ASUS_Nx51, .name = "asus-nx51"}, 11132 {.id = ALC668_FIXUP_ASUS_G751, .name = "asus-g751"}, 11133 {.id = ALC891_FIXUP_HEADSET_MODE, .name = "alc891-headset"}, 11134 {.id = ALC891_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc891-headset-multi"}, 11135 {.id = ALC662_FIXUP_ACER_VERITON, .name = "acer-veriton"}, 11136 {.id = ALC892_FIXUP_ASROCK_MOBO, .name = "asrock-mobo"}, 11137 {.id = ALC662_FIXUP_USI_HEADSET_MODE, .name = "usi-headset"}, 11138 {.id = ALC662_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"}, 11139 {.id = ALC669_FIXUP_ACER_ASPIRE_ETHOS, .name = "aspire-ethos"}, 11140 {} 11141 }; 11142 11143 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = { 11144 SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE, 11145 {0x17, 0x02211010}, 11146 {0x18, 0x01a19030}, 11147 {0x1a, 0x01813040}, 11148 {0x21, 0x01014020}), 11149 SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE, 11150 {0x16, 0x01813030}, 11151 {0x17, 0x02211010}, 11152 {0x18, 0x01a19040}, 11153 {0x21, 0x01014020}), 11154 SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE, 11155 {0x14, 0x01014010}, 11156 {0x18, 0x01a19020}, 11157 {0x1a, 0x0181302f}, 11158 {0x1b, 0x0221401f}), 11159 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE, 11160 {0x12, 0x99a30130}, 11161 {0x14, 0x90170110}, 11162 {0x15, 0x0321101f}, 11163 {0x16, 0x03011020}), 11164 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE, 11165 {0x12, 0x99a30140}, 11166 {0x14, 0x90170110}, 11167 {0x15, 0x0321101f}, 11168 {0x16, 0x03011020}), 11169 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE, 11170 {0x12, 0x99a30150}, 11171 {0x14, 0x90170110}, 11172 {0x15, 0x0321101f}, 11173 {0x16, 0x03011020}), 11174 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE, 11175 {0x14, 0x90170110}, 11176 {0x15, 0x0321101f}, 11177 {0x16, 0x03011020}), 11178 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE, 11179 {0x12, 0x90a60130}, 11180 {0x14, 0x90170110}, 11181 {0x15, 0x0321101f}), 11182 SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2, 11183 {0x14, 0x01014010}, 11184 {0x17, 0x90170150}, 11185 {0x19, 0x02a11060}, 11186 {0x1b, 0x01813030}, 11187 {0x21, 0x02211020}), 11188 SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2, 11189 {0x14, 0x01014010}, 11190 {0x18, 0x01a19040}, 11191 {0x1b, 0x01813030}, 11192 {0x21, 0x02211020}), 11193 SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2, 11194 {0x14, 0x01014020}, 11195 {0x17, 0x90170110}, 11196 {0x18, 0x01a19050}, 11197 {0x1b, 0x01813040}, 11198 {0x21, 0x02211030}), 11199 {} 11200 }; 11201 11202 /* 11203 */ 11204 static int patch_alc662(struct hda_codec *codec) 11205 { 11206 struct alc_spec *spec; 11207 int err; 11208 11209 err = alc_alloc_spec(codec, 0x0b); 11210 if (err < 0) 11211 return err; 11212 11213 spec = codec->spec; 11214 11215 spec->shutup = alc_eapd_shutup; 11216 11217 /* handle multiple HPs as is */ 11218 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 11219 11220 alc_fix_pll_init(codec, 0x20, 0x04, 15); 11221 11222 switch (codec->core.vendor_id) { 11223 case 0x10ec0668: 11224 spec->init_hook = alc668_restore_default_value; 11225 break; 11226 } 11227 11228 alc_pre_init(codec); 11229 11230 snd_hda_pick_fixup(codec, alc662_fixup_models, 11231 alc662_fixup_tbl, alc662_fixups); 11232 snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups, true); 11233 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 11234 11235 alc_auto_parse_customize_define(codec); 11236 11237 if (has_cdefine_beep(codec)) 11238 spec->gen.beep_nid = 0x01; 11239 11240 if ((alc_get_coef0(codec) & (1 << 14)) && 11241 codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 && 11242 spec->cdefine.platform_type == 1) { 11243 err = alc_codec_rename(codec, "ALC272X"); 11244 if (err < 0) 11245 goto error; 11246 } 11247 11248 /* automatic parse from the BIOS config */ 11249 err = alc662_parse_auto_config(codec); 11250 if (err < 0) 11251 goto error; 11252 11253 if (!spec->gen.no_analog && spec->gen.beep_nid) { 11254 switch (codec->core.vendor_id) { 11255 case 0x10ec0662: 11256 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 11257 break; 11258 case 0x10ec0272: 11259 case 0x10ec0663: 11260 case 0x10ec0665: 11261 case 0x10ec0668: 11262 err = set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT); 11263 break; 11264 case 0x10ec0273: 11265 err = set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT); 11266 break; 11267 } 11268 if (err < 0) 11269 goto error; 11270 } 11271 11272 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 11273 11274 return 0; 11275 11276 error: 11277 alc_free(codec); 11278 return err; 11279 } 11280 11281 /* 11282 * ALC680 support 11283 */ 11284 11285 static int alc680_parse_auto_config(struct hda_codec *codec) 11286 { 11287 return alc_parse_auto_config(codec, NULL, NULL); 11288 } 11289 11290 /* 11291 */ 11292 static int patch_alc680(struct hda_codec *codec) 11293 { 11294 int err; 11295 11296 /* ALC680 has no aa-loopback mixer */ 11297 err = alc_alloc_spec(codec, 0); 11298 if (err < 0) 11299 return err; 11300 11301 /* automatic parse from the BIOS config */ 11302 err = alc680_parse_auto_config(codec); 11303 if (err < 0) { 11304 alc_free(codec); 11305 return err; 11306 } 11307 11308 return 0; 11309 } 11310 11311 /* 11312 * patch entries 11313 */ 11314 static const struct hda_device_id snd_hda_id_realtek[] = { 11315 HDA_CODEC_ENTRY(0x10ec0215, "ALC215", patch_alc269), 11316 HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269), 11317 HDA_CODEC_ENTRY(0x10ec0222, "ALC222", patch_alc269), 11318 HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269), 11319 HDA_CODEC_ENTRY(0x10ec0230, "ALC236", patch_alc269), 11320 HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269), 11321 HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269), 11322 HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269), 11323 HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269), 11324 HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269), 11325 HDA_CODEC_ENTRY(0x10ec0245, "ALC245", patch_alc269), 11326 HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269), 11327 HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269), 11328 HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269), 11329 HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260), 11330 HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262), 11331 HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268), 11332 HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268), 11333 HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269), 11334 HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269), 11335 HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662), 11336 HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269), 11337 HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269), 11338 HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269), 11339 HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269), 11340 HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269), 11341 HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269), 11342 HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269), 11343 HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269), 11344 HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269), 11345 HDA_CODEC_ENTRY(0x10ec0287, "ALC287", patch_alc269), 11346 HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269), 11347 HDA_CODEC_ENTRY(0x10ec0289, "ALC289", patch_alc269), 11348 HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269), 11349 HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269), 11350 HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269), 11351 HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269), 11352 HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269), 11353 HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269), 11354 HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269), 11355 HDA_CODEC_ENTRY(0x10ec0300, "ALC300", patch_alc269), 11356 HDA_CODEC_ENTRY(0x10ec0623, "ALC623", patch_alc269), 11357 HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861), 11358 HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd), 11359 HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861), 11360 HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd), 11361 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882), 11362 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662), 11363 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662), 11364 HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662), 11365 HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662), 11366 HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662), 11367 HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662), 11368 HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662), 11369 HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662), 11370 HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680), 11371 HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269), 11372 HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269), 11373 HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269), 11374 HDA_CODEC_ENTRY(0x10ec0711, "ALC711", patch_alc269), 11375 HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662), 11376 HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880), 11377 HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882), 11378 HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882), 11379 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882), 11380 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882), 11381 HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882), 11382 HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882), 11383 HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882), 11384 HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882), 11385 HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882), 11386 HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662), 11387 HDA_CODEC_ENTRY(0x10ec0897, "ALC897", patch_alc662), 11388 HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882), 11389 HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882), 11390 HDA_CODEC_ENTRY(0x10ec0b00, "ALCS1200A", patch_alc882), 11391 HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882), 11392 HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882), 11393 {} /* terminator */ 11394 }; 11395 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek); 11396 11397 MODULE_LICENSE("GPL"); 11398 MODULE_DESCRIPTION("Realtek HD-audio codec"); 11399 11400 static struct hda_codec_driver realtek_driver = { 11401 .id = snd_hda_id_realtek, 11402 }; 11403 11404 module_hda_codec_driver(realtek_driver); 11405