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