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