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