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