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