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