1 /* 2 * Universal Interface for Intel High Definition Audio Codec 3 * 4 * HD audio interface patch for Realtek ALC codecs 5 * 6 * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw> 7 * PeiSen Hou <pshou@realtek.com.tw> 8 * Takashi Iwai <tiwai@suse.de> 9 * Jonathan Woithe <jwoithe@just42.net> 10 * 11 * This driver is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License as published by 13 * the Free Software Foundation; either version 2 of the License, or 14 * (at your option) any later version. 15 * 16 * This driver is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 * GNU General Public License for more details. 20 * 21 * You should have received a copy of the GNU General Public License 22 * along with this program; if not, write to the Free Software 23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 24 */ 25 26 #include <linux/init.h> 27 #include <linux/delay.h> 28 #include <linux/slab.h> 29 #include <linux/pci.h> 30 #include <linux/dmi.h> 31 #include <linux/module.h> 32 #include <linux/input.h> 33 #include <sound/core.h> 34 #include <sound/jack.h> 35 #include "hda_codec.h" 36 #include "hda_local.h" 37 #include "hda_auto_parser.h" 38 #include "hda_jack.h" 39 #include "hda_generic.h" 40 41 /* keep halting ALC5505 DSP, for power saving */ 42 #define HALT_REALTEK_ALC5505 43 44 /* for GPIO Poll */ 45 #define GPIO_MASK 0x03 46 47 /* extra amp-initialization sequence types */ 48 enum { 49 ALC_INIT_NONE, 50 ALC_INIT_DEFAULT, 51 ALC_INIT_GPIO1, 52 ALC_INIT_GPIO2, 53 ALC_INIT_GPIO3, 54 }; 55 56 enum { 57 ALC_HEADSET_MODE_UNKNOWN, 58 ALC_HEADSET_MODE_UNPLUGGED, 59 ALC_HEADSET_MODE_HEADSET, 60 ALC_HEADSET_MODE_MIC, 61 ALC_HEADSET_MODE_HEADPHONE, 62 }; 63 64 enum { 65 ALC_HEADSET_TYPE_UNKNOWN, 66 ALC_HEADSET_TYPE_CTIA, 67 ALC_HEADSET_TYPE_OMTP, 68 }; 69 70 enum { 71 ALC_KEY_MICMUTE_INDEX, 72 }; 73 74 struct alc_customize_define { 75 unsigned int sku_cfg; 76 unsigned char port_connectivity; 77 unsigned char check_sum; 78 unsigned char customization; 79 unsigned char external_amp; 80 unsigned int enable_pcbeep:1; 81 unsigned int platform_type:1; 82 unsigned int swap:1; 83 unsigned int override:1; 84 unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */ 85 }; 86 87 struct alc_spec { 88 struct hda_gen_spec gen; /* must be at head */ 89 90 /* codec parameterization */ 91 const struct snd_kcontrol_new *mixers[5]; /* mixer arrays */ 92 unsigned int num_mixers; 93 unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */ 94 95 struct alc_customize_define cdefine; 96 unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */ 97 98 /* mute LED for HP laptops, see alc269_fixup_mic_mute_hook() */ 99 int mute_led_polarity; 100 hda_nid_t mute_led_nid; 101 hda_nid_t cap_mute_led_nid; 102 103 unsigned int gpio_led; /* used for alc269_fixup_hp_gpio_led() */ 104 unsigned int gpio_mute_led_mask; 105 unsigned int gpio_mic_led_mask; 106 107 hda_nid_t headset_mic_pin; 108 hda_nid_t headphone_mic_pin; 109 int current_headset_mode; 110 int current_headset_type; 111 112 /* hooks */ 113 void (*init_hook)(struct hda_codec *codec); 114 #ifdef CONFIG_PM 115 void (*power_hook)(struct hda_codec *codec); 116 #endif 117 void (*shutup)(struct hda_codec *codec); 118 void (*reboot_notify)(struct hda_codec *codec); 119 120 int init_amp; 121 int codec_variant; /* flag for other variants */ 122 unsigned int has_alc5505_dsp:1; 123 unsigned int no_depop_delay:1; 124 125 /* for PLL fix */ 126 hda_nid_t pll_nid; 127 unsigned int pll_coef_idx, pll_coef_bit; 128 unsigned int coef0; 129 struct input_dev *kb_dev; 130 u8 alc_mute_keycode_map[1]; 131 }; 132 133 /* 134 * COEF access helper functions 135 */ 136 137 static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid, 138 unsigned int coef_idx) 139 { 140 unsigned int val; 141 142 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx); 143 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0); 144 return val; 145 } 146 147 #define alc_read_coef_idx(codec, coef_idx) \ 148 alc_read_coefex_idx(codec, 0x20, coef_idx) 149 150 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid, 151 unsigned int coef_idx, unsigned int coef_val) 152 { 153 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx); 154 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val); 155 } 156 157 #define alc_write_coef_idx(codec, coef_idx, coef_val) \ 158 alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val) 159 160 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid, 161 unsigned int coef_idx, unsigned int mask, 162 unsigned int bits_set) 163 { 164 unsigned int val = alc_read_coefex_idx(codec, nid, coef_idx); 165 166 if (val != -1) 167 alc_write_coefex_idx(codec, nid, coef_idx, 168 (val & ~mask) | bits_set); 169 } 170 171 #define alc_update_coef_idx(codec, coef_idx, mask, bits_set) \ 172 alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set) 173 174 /* a special bypass for COEF 0; read the cached value at the second time */ 175 static unsigned int alc_get_coef0(struct hda_codec *codec) 176 { 177 struct alc_spec *spec = codec->spec; 178 179 if (!spec->coef0) 180 spec->coef0 = alc_read_coef_idx(codec, 0); 181 return spec->coef0; 182 } 183 184 /* coef writes/updates batch */ 185 struct coef_fw { 186 unsigned char nid; 187 unsigned char idx; 188 unsigned short mask; 189 unsigned short val; 190 }; 191 192 #define UPDATE_COEFEX(_nid, _idx, _mask, _val) \ 193 { .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) } 194 #define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val) 195 #define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val) 196 #define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val) 197 198 static void alc_process_coef_fw(struct hda_codec *codec, 199 const struct coef_fw *fw) 200 { 201 for (; fw->nid; fw++) { 202 if (fw->mask == (unsigned short)-1) 203 alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val); 204 else 205 alc_update_coefex_idx(codec, fw->nid, fw->idx, 206 fw->mask, fw->val); 207 } 208 } 209 210 /* 211 * Append the given mixer and verb elements for the later use 212 * The mixer array is referred in build_controls(), and init_verbs are 213 * called in init(). 214 */ 215 static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix) 216 { 217 if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers))) 218 return; 219 spec->mixers[spec->num_mixers++] = mix; 220 } 221 222 /* 223 * GPIO setup tables, used in initialization 224 */ 225 /* Enable GPIO mask and set output */ 226 static const struct hda_verb alc_gpio1_init_verbs[] = { 227 {0x01, AC_VERB_SET_GPIO_MASK, 0x01}, 228 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, 229 {0x01, AC_VERB_SET_GPIO_DATA, 0x01}, 230 { } 231 }; 232 233 static const struct hda_verb alc_gpio2_init_verbs[] = { 234 {0x01, AC_VERB_SET_GPIO_MASK, 0x02}, 235 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02}, 236 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, 237 { } 238 }; 239 240 static const struct hda_verb alc_gpio3_init_verbs[] = { 241 {0x01, AC_VERB_SET_GPIO_MASK, 0x03}, 242 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03}, 243 {0x01, AC_VERB_SET_GPIO_DATA, 0x03}, 244 { } 245 }; 246 247 /* 248 * Fix hardware PLL issue 249 * On some codecs, the analog PLL gating control must be off while 250 * the default value is 1. 251 */ 252 static void alc_fix_pll(struct hda_codec *codec) 253 { 254 struct alc_spec *spec = codec->spec; 255 256 if (spec->pll_nid) 257 alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx, 258 1 << spec->pll_coef_bit, 0); 259 } 260 261 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid, 262 unsigned int coef_idx, unsigned int coef_bit) 263 { 264 struct alc_spec *spec = codec->spec; 265 spec->pll_nid = nid; 266 spec->pll_coef_idx = coef_idx; 267 spec->pll_coef_bit = coef_bit; 268 alc_fix_pll(codec); 269 } 270 271 /* update the master volume per volume-knob's unsol event */ 272 static void alc_update_knob_master(struct hda_codec *codec, 273 struct hda_jack_callback *jack) 274 { 275 unsigned int val; 276 struct snd_kcontrol *kctl; 277 struct snd_ctl_elem_value *uctl; 278 279 kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume"); 280 if (!kctl) 281 return; 282 uctl = kzalloc(sizeof(*uctl), GFP_KERNEL); 283 if (!uctl) 284 return; 285 val = snd_hda_codec_read(codec, jack->tbl->nid, 0, 286 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0); 287 val &= HDA_AMP_VOLMASK; 288 uctl->value.integer.value[0] = val; 289 uctl->value.integer.value[1] = val; 290 kctl->put(kctl, uctl); 291 kfree(uctl); 292 } 293 294 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res) 295 { 296 /* For some reason, the res given from ALC880 is broken. 297 Here we adjust it properly. */ 298 snd_hda_jack_unsol_event(codec, res >> 2); 299 } 300 301 /* Change EAPD to verb control */ 302 static void alc_fill_eapd_coef(struct hda_codec *codec) 303 { 304 int coef; 305 306 coef = alc_get_coef0(codec); 307 308 switch (codec->core.vendor_id) { 309 case 0x10ec0262: 310 alc_update_coef_idx(codec, 0x7, 0, 1<<5); 311 break; 312 case 0x10ec0267: 313 case 0x10ec0268: 314 alc_update_coef_idx(codec, 0x7, 0, 1<<13); 315 break; 316 case 0x10ec0269: 317 if ((coef & 0x00f0) == 0x0010) 318 alc_update_coef_idx(codec, 0xd, 0, 1<<14); 319 if ((coef & 0x00f0) == 0x0020) 320 alc_update_coef_idx(codec, 0x4, 1<<15, 0); 321 if ((coef & 0x00f0) == 0x0030) 322 alc_update_coef_idx(codec, 0x10, 1<<9, 0); 323 break; 324 case 0x10ec0280: 325 case 0x10ec0284: 326 case 0x10ec0290: 327 case 0x10ec0292: 328 alc_update_coef_idx(codec, 0x4, 1<<15, 0); 329 break; 330 case 0x10ec0233: 331 case 0x10ec0255: 332 case 0x10ec0256: 333 case 0x10ec0282: 334 case 0x10ec0283: 335 case 0x10ec0286: 336 case 0x10ec0288: 337 case 0x10ec0298: 338 alc_update_coef_idx(codec, 0x10, 1<<9, 0); 339 break; 340 case 0x10ec0285: 341 case 0x10ec0293: 342 alc_update_coef_idx(codec, 0xa, 1<<13, 0); 343 break; 344 case 0x10ec0662: 345 if ((coef & 0x00f0) == 0x0030) 346 alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */ 347 break; 348 case 0x10ec0272: 349 case 0x10ec0273: 350 case 0x10ec0663: 351 case 0x10ec0665: 352 case 0x10ec0670: 353 case 0x10ec0671: 354 case 0x10ec0672: 355 alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */ 356 break; 357 case 0x10ec0668: 358 alc_update_coef_idx(codec, 0x7, 3<<13, 0); 359 break; 360 case 0x10ec0867: 361 alc_update_coef_idx(codec, 0x4, 1<<10, 0); 362 break; 363 case 0x10ec0888: 364 if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030) 365 alc_update_coef_idx(codec, 0x7, 1<<5, 0); 366 break; 367 case 0x10ec0892: 368 alc_update_coef_idx(codec, 0x7, 1<<5, 0); 369 break; 370 case 0x10ec0899: 371 case 0x10ec0900: 372 alc_update_coef_idx(codec, 0x7, 1<<1, 0); 373 break; 374 } 375 } 376 377 /* additional initialization for ALC888 variants */ 378 static void alc888_coef_init(struct hda_codec *codec) 379 { 380 switch (alc_get_coef0(codec) & 0x00f0) { 381 /* alc888-VA */ 382 case 0x00: 383 /* alc888-VB */ 384 case 0x10: 385 alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */ 386 break; 387 } 388 } 389 390 /* turn on/off EAPD control (only if available) */ 391 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on) 392 { 393 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN) 394 return; 395 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD) 396 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE, 397 on ? 2 : 0); 398 } 399 400 /* turn on/off EAPD controls of the codec */ 401 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on) 402 { 403 /* We currently only handle front, HP */ 404 static hda_nid_t pins[] = { 405 0x0f, 0x10, 0x14, 0x15, 0x17, 0 406 }; 407 hda_nid_t *p; 408 for (p = pins; *p; p++) 409 set_eapd(codec, *p, on); 410 } 411 412 /* generic shutup callback; 413 * just turning off EPAD and a little pause for avoiding pop-noise 414 */ 415 static void alc_eapd_shutup(struct hda_codec *codec) 416 { 417 struct alc_spec *spec = codec->spec; 418 419 alc_auto_setup_eapd(codec, false); 420 if (!spec->no_depop_delay) 421 msleep(200); 422 snd_hda_shutup_pins(codec); 423 } 424 425 /* generic EAPD initialization */ 426 static void alc_auto_init_amp(struct hda_codec *codec, int type) 427 { 428 alc_fill_eapd_coef(codec); 429 alc_auto_setup_eapd(codec, true); 430 switch (type) { 431 case ALC_INIT_GPIO1: 432 snd_hda_sequence_write(codec, alc_gpio1_init_verbs); 433 break; 434 case ALC_INIT_GPIO2: 435 snd_hda_sequence_write(codec, alc_gpio2_init_verbs); 436 break; 437 case ALC_INIT_GPIO3: 438 snd_hda_sequence_write(codec, alc_gpio3_init_verbs); 439 break; 440 case ALC_INIT_DEFAULT: 441 switch (codec->core.vendor_id) { 442 case 0x10ec0260: 443 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010); 444 break; 445 case 0x10ec0880: 446 case 0x10ec0882: 447 case 0x10ec0883: 448 case 0x10ec0885: 449 alc_update_coef_idx(codec, 7, 0, 0x2030); 450 break; 451 case 0x10ec0888: 452 alc888_coef_init(codec); 453 break; 454 } 455 break; 456 } 457 } 458 459 460 /* 461 * Realtek SSID verification 462 */ 463 464 /* Could be any non-zero and even value. When used as fixup, tells 465 * the driver to ignore any present sku defines. 466 */ 467 #define ALC_FIXUP_SKU_IGNORE (2) 468 469 static void alc_fixup_sku_ignore(struct hda_codec *codec, 470 const struct hda_fixup *fix, int action) 471 { 472 struct alc_spec *spec = codec->spec; 473 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 474 spec->cdefine.fixup = 1; 475 spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE; 476 } 477 } 478 479 static void alc_fixup_no_depop_delay(struct hda_codec *codec, 480 const struct hda_fixup *fix, int action) 481 { 482 struct alc_spec *spec = codec->spec; 483 484 if (action == HDA_FIXUP_ACT_PROBE) { 485 spec->no_depop_delay = 1; 486 codec->depop_delay = 0; 487 } 488 } 489 490 static int alc_auto_parse_customize_define(struct hda_codec *codec) 491 { 492 unsigned int ass, tmp, i; 493 unsigned nid = 0; 494 struct alc_spec *spec = codec->spec; 495 496 spec->cdefine.enable_pcbeep = 1; /* assume always enabled */ 497 498 if (spec->cdefine.fixup) { 499 ass = spec->cdefine.sku_cfg; 500 if (ass == ALC_FIXUP_SKU_IGNORE) 501 return -1; 502 goto do_sku; 503 } 504 505 if (!codec->bus->pci) 506 return -1; 507 ass = codec->core.subsystem_id & 0xffff; 508 if (ass != codec->bus->pci->subsystem_device && (ass & 1)) 509 goto do_sku; 510 511 nid = 0x1d; 512 if (codec->core.vendor_id == 0x10ec0260) 513 nid = 0x17; 514 ass = snd_hda_codec_get_pincfg(codec, nid); 515 516 if (!(ass & 1)) { 517 codec_info(codec, "%s: SKU not ready 0x%08x\n", 518 codec->core.chip_name, ass); 519 return -1; 520 } 521 522 /* check sum */ 523 tmp = 0; 524 for (i = 1; i < 16; i++) { 525 if ((ass >> i) & 1) 526 tmp++; 527 } 528 if (((ass >> 16) & 0xf) != tmp) 529 return -1; 530 531 spec->cdefine.port_connectivity = ass >> 30; 532 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20; 533 spec->cdefine.check_sum = (ass >> 16) & 0xf; 534 spec->cdefine.customization = ass >> 8; 535 do_sku: 536 spec->cdefine.sku_cfg = ass; 537 spec->cdefine.external_amp = (ass & 0x38) >> 3; 538 spec->cdefine.platform_type = (ass & 0x4) >> 2; 539 spec->cdefine.swap = (ass & 0x2) >> 1; 540 spec->cdefine.override = ass & 0x1; 541 542 codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n", 543 nid, spec->cdefine.sku_cfg); 544 codec_dbg(codec, "SKU: port_connectivity=0x%x\n", 545 spec->cdefine.port_connectivity); 546 codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep); 547 codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum); 548 codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization); 549 codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp); 550 codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type); 551 codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap); 552 codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override); 553 554 return 0; 555 } 556 557 /* return the position of NID in the list, or -1 if not found */ 558 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums) 559 { 560 int i; 561 for (i = 0; i < nums; i++) 562 if (list[i] == nid) 563 return i; 564 return -1; 565 } 566 /* return true if the given NID is found in the list */ 567 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums) 568 { 569 return find_idx_in_nid_list(nid, list, nums) >= 0; 570 } 571 572 /* check subsystem ID and set up device-specific initialization; 573 * return 1 if initialized, 0 if invalid SSID 574 */ 575 /* 32-bit subsystem ID for BIOS loading in HD Audio codec. 576 * 31 ~ 16 : Manufacture ID 577 * 15 ~ 8 : SKU ID 578 * 7 ~ 0 : Assembly ID 579 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36 580 */ 581 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports) 582 { 583 unsigned int ass, tmp, i; 584 unsigned nid; 585 struct alc_spec *spec = codec->spec; 586 587 if (spec->cdefine.fixup) { 588 ass = spec->cdefine.sku_cfg; 589 if (ass == ALC_FIXUP_SKU_IGNORE) 590 return 0; 591 goto do_sku; 592 } 593 594 ass = codec->core.subsystem_id & 0xffff; 595 if (codec->bus->pci && 596 ass != codec->bus->pci->subsystem_device && (ass & 1)) 597 goto do_sku; 598 599 /* invalid SSID, check the special NID pin defcfg instead */ 600 /* 601 * 31~30 : port connectivity 602 * 29~21 : reserve 603 * 20 : PCBEEP input 604 * 19~16 : Check sum (15:1) 605 * 15~1 : Custom 606 * 0 : override 607 */ 608 nid = 0x1d; 609 if (codec->core.vendor_id == 0x10ec0260) 610 nid = 0x17; 611 ass = snd_hda_codec_get_pincfg(codec, nid); 612 codec_dbg(codec, 613 "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n", 614 ass, nid); 615 if (!(ass & 1)) 616 return 0; 617 if ((ass >> 30) != 1) /* no physical connection */ 618 return 0; 619 620 /* check sum */ 621 tmp = 0; 622 for (i = 1; i < 16; i++) { 623 if ((ass >> i) & 1) 624 tmp++; 625 } 626 if (((ass >> 16) & 0xf) != tmp) 627 return 0; 628 do_sku: 629 codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n", 630 ass & 0xffff, codec->core.vendor_id); 631 /* 632 * 0 : override 633 * 1 : Swap Jack 634 * 2 : 0 --> Desktop, 1 --> Laptop 635 * 3~5 : External Amplifier control 636 * 7~6 : Reserved 637 */ 638 tmp = (ass & 0x38) >> 3; /* external Amp control */ 639 switch (tmp) { 640 case 1: 641 spec->init_amp = ALC_INIT_GPIO1; 642 break; 643 case 3: 644 spec->init_amp = ALC_INIT_GPIO2; 645 break; 646 case 7: 647 spec->init_amp = ALC_INIT_GPIO3; 648 break; 649 case 5: 650 default: 651 spec->init_amp = ALC_INIT_DEFAULT; 652 break; 653 } 654 655 /* is laptop or Desktop and enable the function "Mute internal speaker 656 * when the external headphone out jack is plugged" 657 */ 658 if (!(ass & 0x8000)) 659 return 1; 660 /* 661 * 10~8 : Jack location 662 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered 663 * 14~13: Resvered 664 * 15 : 1 --> enable the function "Mute internal speaker 665 * when the external headphone out jack is plugged" 666 */ 667 if (!spec->gen.autocfg.hp_pins[0] && 668 !(spec->gen.autocfg.line_out_pins[0] && 669 spec->gen.autocfg.line_out_type == AUTO_PIN_HP_OUT)) { 670 hda_nid_t nid; 671 tmp = (ass >> 11) & 0x3; /* HP to chassis */ 672 nid = ports[tmp]; 673 if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins, 674 spec->gen.autocfg.line_outs)) 675 return 1; 676 spec->gen.autocfg.hp_pins[0] = nid; 677 } 678 return 1; 679 } 680 681 /* Check the validity of ALC subsystem-id 682 * ports contains an array of 4 pin NIDs for port-A, E, D and I */ 683 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports) 684 { 685 if (!alc_subsystem_id(codec, ports)) { 686 struct alc_spec *spec = codec->spec; 687 codec_dbg(codec, 688 "realtek: Enable default setup for auto mode as fallback\n"); 689 spec->init_amp = ALC_INIT_DEFAULT; 690 } 691 } 692 693 /* 694 */ 695 696 static void alc_fixup_inv_dmic(struct hda_codec *codec, 697 const struct hda_fixup *fix, int action) 698 { 699 struct alc_spec *spec = codec->spec; 700 701 spec->gen.inv_dmic_split = 1; 702 } 703 704 705 #ifdef CONFIG_SND_HDA_INPUT_BEEP 706 /* additional beep mixers; the actual parameters are overwritten at build */ 707 static const struct snd_kcontrol_new alc_beep_mixer[] = { 708 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT), 709 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT), 710 { } /* end */ 711 }; 712 #endif 713 714 static int alc_build_controls(struct hda_codec *codec) 715 { 716 struct alc_spec *spec = codec->spec; 717 int i, err; 718 719 err = snd_hda_gen_build_controls(codec); 720 if (err < 0) 721 return err; 722 723 for (i = 0; i < spec->num_mixers; i++) { 724 err = snd_hda_add_new_ctls(codec, spec->mixers[i]); 725 if (err < 0) 726 return err; 727 } 728 729 #ifdef CONFIG_SND_HDA_INPUT_BEEP 730 /* create beep controls if needed */ 731 if (spec->beep_amp) { 732 const struct snd_kcontrol_new *knew; 733 for (knew = alc_beep_mixer; knew->name; knew++) { 734 struct snd_kcontrol *kctl; 735 kctl = snd_ctl_new1(knew, codec); 736 if (!kctl) 737 return -ENOMEM; 738 kctl->private_value = spec->beep_amp; 739 err = snd_hda_ctl_add(codec, 0, kctl); 740 if (err < 0) 741 return err; 742 } 743 } 744 #endif 745 746 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD); 747 return 0; 748 } 749 750 751 /* 752 * Common callbacks 753 */ 754 755 static int alc_init(struct hda_codec *codec) 756 { 757 struct alc_spec *spec = codec->spec; 758 759 if (spec->init_hook) 760 spec->init_hook(codec); 761 762 alc_fix_pll(codec); 763 alc_auto_init_amp(codec, spec->init_amp); 764 765 snd_hda_gen_init(codec); 766 767 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT); 768 769 return 0; 770 } 771 772 static inline void alc_shutup(struct hda_codec *codec) 773 { 774 struct alc_spec *spec = codec->spec; 775 776 if (spec && spec->shutup) 777 spec->shutup(codec); 778 else 779 snd_hda_shutup_pins(codec); 780 } 781 782 static void alc_reboot_notify(struct hda_codec *codec) 783 { 784 struct alc_spec *spec = codec->spec; 785 786 if (spec && spec->reboot_notify) 787 spec->reboot_notify(codec); 788 else 789 alc_shutup(codec); 790 } 791 792 /* power down codec to D3 at reboot/shutdown; set as reboot_notify ops */ 793 static void alc_d3_at_reboot(struct hda_codec *codec) 794 { 795 snd_hda_codec_set_power_to_all(codec, codec->core.afg, AC_PWRST_D3); 796 snd_hda_codec_write(codec, codec->core.afg, 0, 797 AC_VERB_SET_POWER_STATE, AC_PWRST_D3); 798 msleep(10); 799 } 800 801 #define alc_free snd_hda_gen_free 802 803 #ifdef CONFIG_PM 804 static void alc_power_eapd(struct hda_codec *codec) 805 { 806 alc_auto_setup_eapd(codec, false); 807 } 808 809 static int alc_suspend(struct hda_codec *codec) 810 { 811 struct alc_spec *spec = codec->spec; 812 alc_shutup(codec); 813 if (spec && spec->power_hook) 814 spec->power_hook(codec); 815 return 0; 816 } 817 #endif 818 819 #ifdef CONFIG_PM 820 static int alc_resume(struct hda_codec *codec) 821 { 822 struct alc_spec *spec = codec->spec; 823 824 if (!spec->no_depop_delay) 825 msleep(150); /* to avoid pop noise */ 826 codec->patch_ops.init(codec); 827 regcache_sync(codec->core.regmap); 828 hda_call_check_power_status(codec, 0x01); 829 return 0; 830 } 831 #endif 832 833 /* 834 */ 835 static const struct hda_codec_ops alc_patch_ops = { 836 .build_controls = alc_build_controls, 837 .build_pcms = snd_hda_gen_build_pcms, 838 .init = alc_init, 839 .free = alc_free, 840 .unsol_event = snd_hda_jack_unsol_event, 841 #ifdef CONFIG_PM 842 .resume = alc_resume, 843 .suspend = alc_suspend, 844 .check_power_status = snd_hda_gen_check_power_status, 845 #endif 846 .reboot_notify = alc_reboot_notify, 847 }; 848 849 850 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name) 851 852 /* 853 * Rename codecs appropriately from COEF value or subvendor id 854 */ 855 struct alc_codec_rename_table { 856 unsigned int vendor_id; 857 unsigned short coef_mask; 858 unsigned short coef_bits; 859 const char *name; 860 }; 861 862 struct alc_codec_rename_pci_table { 863 unsigned int codec_vendor_id; 864 unsigned short pci_subvendor; 865 unsigned short pci_subdevice; 866 const char *name; 867 }; 868 869 static struct alc_codec_rename_table rename_tbl[] = { 870 { 0x10ec0221, 0xf00f, 0x1003, "ALC231" }, 871 { 0x10ec0269, 0xfff0, 0x3010, "ALC277" }, 872 { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" }, 873 { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" }, 874 { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" }, 875 { 0x10ec0269, 0xffff, 0xa023, "ALC259" }, 876 { 0x10ec0269, 0xffff, 0x6023, "ALC281X" }, 877 { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" }, 878 { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" }, 879 { 0x10ec0662, 0xffff, 0x4020, "ALC656" }, 880 { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" }, 881 { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" }, 882 { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" }, 883 { 0x10ec0899, 0x2000, 0x2000, "ALC899" }, 884 { 0x10ec0892, 0xffff, 0x8020, "ALC661" }, 885 { 0x10ec0892, 0xffff, 0x8011, "ALC661" }, 886 { 0x10ec0892, 0xffff, 0x4011, "ALC656" }, 887 { } /* terminator */ 888 }; 889 890 static struct alc_codec_rename_pci_table rename_pci_tbl[] = { 891 { 0x10ec0280, 0x1028, 0, "ALC3220" }, 892 { 0x10ec0282, 0x1028, 0, "ALC3221" }, 893 { 0x10ec0283, 0x1028, 0, "ALC3223" }, 894 { 0x10ec0288, 0x1028, 0, "ALC3263" }, 895 { 0x10ec0292, 0x1028, 0, "ALC3226" }, 896 { 0x10ec0293, 0x1028, 0, "ALC3235" }, 897 { 0x10ec0255, 0x1028, 0, "ALC3234" }, 898 { 0x10ec0668, 0x1028, 0, "ALC3661" }, 899 { 0x10ec0275, 0x1028, 0, "ALC3260" }, 900 { 0x10ec0899, 0x1028, 0, "ALC3861" }, 901 { 0x10ec0298, 0x1028, 0, "ALC3266" }, 902 { 0x10ec0256, 0x1028, 0, "ALC3246" }, 903 { 0x10ec0670, 0x1025, 0, "ALC669X" }, 904 { 0x10ec0676, 0x1025, 0, "ALC679X" }, 905 { 0x10ec0282, 0x1043, 0, "ALC3229" }, 906 { 0x10ec0233, 0x1043, 0, "ALC3236" }, 907 { 0x10ec0280, 0x103c, 0, "ALC3228" }, 908 { 0x10ec0282, 0x103c, 0, "ALC3227" }, 909 { 0x10ec0286, 0x103c, 0, "ALC3242" }, 910 { 0x10ec0290, 0x103c, 0, "ALC3241" }, 911 { 0x10ec0668, 0x103c, 0, "ALC3662" }, 912 { 0x10ec0283, 0x17aa, 0, "ALC3239" }, 913 { 0x10ec0292, 0x17aa, 0, "ALC3232" }, 914 { } /* terminator */ 915 }; 916 917 static int alc_codec_rename_from_preset(struct hda_codec *codec) 918 { 919 const struct alc_codec_rename_table *p; 920 const struct alc_codec_rename_pci_table *q; 921 922 for (p = rename_tbl; p->vendor_id; p++) { 923 if (p->vendor_id != codec->core.vendor_id) 924 continue; 925 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits) 926 return alc_codec_rename(codec, p->name); 927 } 928 929 if (!codec->bus->pci) 930 return 0; 931 for (q = rename_pci_tbl; q->codec_vendor_id; q++) { 932 if (q->codec_vendor_id != codec->core.vendor_id) 933 continue; 934 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor) 935 continue; 936 if (!q->pci_subdevice || 937 q->pci_subdevice == codec->bus->pci->subsystem_device) 938 return alc_codec_rename(codec, q->name); 939 } 940 941 return 0; 942 } 943 944 945 /* 946 * Digital-beep handlers 947 */ 948 #ifdef CONFIG_SND_HDA_INPUT_BEEP 949 #define set_beep_amp(spec, nid, idx, dir) \ 950 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir)) 951 952 static const struct snd_pci_quirk beep_white_list[] = { 953 SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1), 954 SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1), 955 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1), 956 SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1), 957 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1), 958 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1), 959 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1), 960 SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1), 961 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1), 962 {} 963 }; 964 965 static inline int has_cdefine_beep(struct hda_codec *codec) 966 { 967 struct alc_spec *spec = codec->spec; 968 const struct snd_pci_quirk *q; 969 q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list); 970 if (q) 971 return q->value; 972 return spec->cdefine.enable_pcbeep; 973 } 974 #else 975 #define set_beep_amp(spec, nid, idx, dir) /* NOP */ 976 #define has_cdefine_beep(codec) 0 977 #endif 978 979 /* parse the BIOS configuration and set up the alc_spec */ 980 /* return 1 if successful, 0 if the proper config is not found, 981 * or a negative error code 982 */ 983 static int alc_parse_auto_config(struct hda_codec *codec, 984 const hda_nid_t *ignore_nids, 985 const hda_nid_t *ssid_nids) 986 { 987 struct alc_spec *spec = codec->spec; 988 struct auto_pin_cfg *cfg = &spec->gen.autocfg; 989 int err; 990 991 err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids, 992 spec->parse_flags); 993 if (err < 0) 994 return err; 995 996 if (ssid_nids) 997 alc_ssid_check(codec, ssid_nids); 998 999 err = snd_hda_gen_parse_auto_config(codec, cfg); 1000 if (err < 0) 1001 return err; 1002 1003 return 1; 1004 } 1005 1006 /* common preparation job for alc_spec */ 1007 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid) 1008 { 1009 struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL); 1010 int err; 1011 1012 if (!spec) 1013 return -ENOMEM; 1014 codec->spec = spec; 1015 snd_hda_gen_spec_init(&spec->gen); 1016 spec->gen.mixer_nid = mixer_nid; 1017 spec->gen.own_eapd_ctl = 1; 1018 codec->single_adc_amp = 1; 1019 /* FIXME: do we need this for all Realtek codec models? */ 1020 codec->spdif_status_reset = 1; 1021 codec->patch_ops = alc_patch_ops; 1022 1023 err = alc_codec_rename_from_preset(codec); 1024 if (err < 0) { 1025 kfree(spec); 1026 return err; 1027 } 1028 return 0; 1029 } 1030 1031 static int alc880_parse_auto_config(struct hda_codec *codec) 1032 { 1033 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 }; 1034 static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 1035 return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids); 1036 } 1037 1038 /* 1039 * ALC880 fix-ups 1040 */ 1041 enum { 1042 ALC880_FIXUP_GPIO1, 1043 ALC880_FIXUP_GPIO2, 1044 ALC880_FIXUP_MEDION_RIM, 1045 ALC880_FIXUP_LG, 1046 ALC880_FIXUP_LG_LW25, 1047 ALC880_FIXUP_W810, 1048 ALC880_FIXUP_EAPD_COEF, 1049 ALC880_FIXUP_TCL_S700, 1050 ALC880_FIXUP_VOL_KNOB, 1051 ALC880_FIXUP_FUJITSU, 1052 ALC880_FIXUP_F1734, 1053 ALC880_FIXUP_UNIWILL, 1054 ALC880_FIXUP_UNIWILL_DIG, 1055 ALC880_FIXUP_Z71V, 1056 ALC880_FIXUP_ASUS_W5A, 1057 ALC880_FIXUP_3ST_BASE, 1058 ALC880_FIXUP_3ST, 1059 ALC880_FIXUP_3ST_DIG, 1060 ALC880_FIXUP_5ST_BASE, 1061 ALC880_FIXUP_5ST, 1062 ALC880_FIXUP_5ST_DIG, 1063 ALC880_FIXUP_6ST_BASE, 1064 ALC880_FIXUP_6ST, 1065 ALC880_FIXUP_6ST_DIG, 1066 ALC880_FIXUP_6ST_AUTOMUTE, 1067 }; 1068 1069 /* enable the volume-knob widget support on NID 0x21 */ 1070 static void alc880_fixup_vol_knob(struct hda_codec *codec, 1071 const struct hda_fixup *fix, int action) 1072 { 1073 if (action == HDA_FIXUP_ACT_PROBE) 1074 snd_hda_jack_detect_enable_callback(codec, 0x21, 1075 alc_update_knob_master); 1076 } 1077 1078 static const struct hda_fixup alc880_fixups[] = { 1079 [ALC880_FIXUP_GPIO1] = { 1080 .type = HDA_FIXUP_VERBS, 1081 .v.verbs = alc_gpio1_init_verbs, 1082 }, 1083 [ALC880_FIXUP_GPIO2] = { 1084 .type = HDA_FIXUP_VERBS, 1085 .v.verbs = alc_gpio2_init_verbs, 1086 }, 1087 [ALC880_FIXUP_MEDION_RIM] = { 1088 .type = HDA_FIXUP_VERBS, 1089 .v.verbs = (const struct hda_verb[]) { 1090 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 1091 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 }, 1092 { } 1093 }, 1094 .chained = true, 1095 .chain_id = ALC880_FIXUP_GPIO2, 1096 }, 1097 [ALC880_FIXUP_LG] = { 1098 .type = HDA_FIXUP_PINS, 1099 .v.pins = (const struct hda_pintbl[]) { 1100 /* disable bogus unused pins */ 1101 { 0x16, 0x411111f0 }, 1102 { 0x18, 0x411111f0 }, 1103 { 0x1a, 0x411111f0 }, 1104 { } 1105 } 1106 }, 1107 [ALC880_FIXUP_LG_LW25] = { 1108 .type = HDA_FIXUP_PINS, 1109 .v.pins = (const struct hda_pintbl[]) { 1110 { 0x1a, 0x0181344f }, /* line-in */ 1111 { 0x1b, 0x0321403f }, /* headphone */ 1112 { } 1113 } 1114 }, 1115 [ALC880_FIXUP_W810] = { 1116 .type = HDA_FIXUP_PINS, 1117 .v.pins = (const struct hda_pintbl[]) { 1118 /* disable bogus unused pins */ 1119 { 0x17, 0x411111f0 }, 1120 { } 1121 }, 1122 .chained = true, 1123 .chain_id = ALC880_FIXUP_GPIO2, 1124 }, 1125 [ALC880_FIXUP_EAPD_COEF] = { 1126 .type = HDA_FIXUP_VERBS, 1127 .v.verbs = (const struct hda_verb[]) { 1128 /* change to EAPD mode */ 1129 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 1130 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 }, 1131 {} 1132 }, 1133 }, 1134 [ALC880_FIXUP_TCL_S700] = { 1135 .type = HDA_FIXUP_VERBS, 1136 .v.verbs = (const struct hda_verb[]) { 1137 /* change to EAPD mode */ 1138 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 1139 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 }, 1140 {} 1141 }, 1142 .chained = true, 1143 .chain_id = ALC880_FIXUP_GPIO2, 1144 }, 1145 [ALC880_FIXUP_VOL_KNOB] = { 1146 .type = HDA_FIXUP_FUNC, 1147 .v.func = alc880_fixup_vol_knob, 1148 }, 1149 [ALC880_FIXUP_FUJITSU] = { 1150 /* override all pins as BIOS on old Amilo is broken */ 1151 .type = HDA_FIXUP_PINS, 1152 .v.pins = (const struct hda_pintbl[]) { 1153 { 0x14, 0x0121401f }, /* HP */ 1154 { 0x15, 0x99030120 }, /* speaker */ 1155 { 0x16, 0x99030130 }, /* bass speaker */ 1156 { 0x17, 0x411111f0 }, /* N/A */ 1157 { 0x18, 0x411111f0 }, /* N/A */ 1158 { 0x19, 0x01a19950 }, /* mic-in */ 1159 { 0x1a, 0x411111f0 }, /* N/A */ 1160 { 0x1b, 0x411111f0 }, /* N/A */ 1161 { 0x1c, 0x411111f0 }, /* N/A */ 1162 { 0x1d, 0x411111f0 }, /* N/A */ 1163 { 0x1e, 0x01454140 }, /* SPDIF out */ 1164 { } 1165 }, 1166 .chained = true, 1167 .chain_id = ALC880_FIXUP_VOL_KNOB, 1168 }, 1169 [ALC880_FIXUP_F1734] = { 1170 /* almost compatible with FUJITSU, but no bass and SPDIF */ 1171 .type = HDA_FIXUP_PINS, 1172 .v.pins = (const struct hda_pintbl[]) { 1173 { 0x14, 0x0121401f }, /* HP */ 1174 { 0x15, 0x99030120 }, /* speaker */ 1175 { 0x16, 0x411111f0 }, /* N/A */ 1176 { 0x17, 0x411111f0 }, /* N/A */ 1177 { 0x18, 0x411111f0 }, /* N/A */ 1178 { 0x19, 0x01a19950 }, /* mic-in */ 1179 { 0x1a, 0x411111f0 }, /* N/A */ 1180 { 0x1b, 0x411111f0 }, /* N/A */ 1181 { 0x1c, 0x411111f0 }, /* N/A */ 1182 { 0x1d, 0x411111f0 }, /* N/A */ 1183 { 0x1e, 0x411111f0 }, /* N/A */ 1184 { } 1185 }, 1186 .chained = true, 1187 .chain_id = ALC880_FIXUP_VOL_KNOB, 1188 }, 1189 [ALC880_FIXUP_UNIWILL] = { 1190 /* need to fix HP and speaker pins to be parsed correctly */ 1191 .type = HDA_FIXUP_PINS, 1192 .v.pins = (const struct hda_pintbl[]) { 1193 { 0x14, 0x0121411f }, /* HP */ 1194 { 0x15, 0x99030120 }, /* speaker */ 1195 { 0x16, 0x99030130 }, /* bass speaker */ 1196 { } 1197 }, 1198 }, 1199 [ALC880_FIXUP_UNIWILL_DIG] = { 1200 .type = HDA_FIXUP_PINS, 1201 .v.pins = (const struct hda_pintbl[]) { 1202 /* disable bogus unused pins */ 1203 { 0x17, 0x411111f0 }, 1204 { 0x19, 0x411111f0 }, 1205 { 0x1b, 0x411111f0 }, 1206 { 0x1f, 0x411111f0 }, 1207 { } 1208 } 1209 }, 1210 [ALC880_FIXUP_Z71V] = { 1211 .type = HDA_FIXUP_PINS, 1212 .v.pins = (const struct hda_pintbl[]) { 1213 /* set up the whole pins as BIOS is utterly broken */ 1214 { 0x14, 0x99030120 }, /* speaker */ 1215 { 0x15, 0x0121411f }, /* HP */ 1216 { 0x16, 0x411111f0 }, /* N/A */ 1217 { 0x17, 0x411111f0 }, /* N/A */ 1218 { 0x18, 0x01a19950 }, /* mic-in */ 1219 { 0x19, 0x411111f0 }, /* N/A */ 1220 { 0x1a, 0x01813031 }, /* line-in */ 1221 { 0x1b, 0x411111f0 }, /* N/A */ 1222 { 0x1c, 0x411111f0 }, /* N/A */ 1223 { 0x1d, 0x411111f0 }, /* N/A */ 1224 { 0x1e, 0x0144111e }, /* SPDIF */ 1225 { } 1226 } 1227 }, 1228 [ALC880_FIXUP_ASUS_W5A] = { 1229 .type = HDA_FIXUP_PINS, 1230 .v.pins = (const struct hda_pintbl[]) { 1231 /* set up the whole pins as BIOS is utterly broken */ 1232 { 0x14, 0x0121411f }, /* HP */ 1233 { 0x15, 0x411111f0 }, /* N/A */ 1234 { 0x16, 0x411111f0 }, /* N/A */ 1235 { 0x17, 0x411111f0 }, /* N/A */ 1236 { 0x18, 0x90a60160 }, /* mic */ 1237 { 0x19, 0x411111f0 }, /* N/A */ 1238 { 0x1a, 0x411111f0 }, /* N/A */ 1239 { 0x1b, 0x411111f0 }, /* N/A */ 1240 { 0x1c, 0x411111f0 }, /* N/A */ 1241 { 0x1d, 0x411111f0 }, /* N/A */ 1242 { 0x1e, 0xb743111e }, /* SPDIF out */ 1243 { } 1244 }, 1245 .chained = true, 1246 .chain_id = ALC880_FIXUP_GPIO1, 1247 }, 1248 [ALC880_FIXUP_3ST_BASE] = { 1249 .type = HDA_FIXUP_PINS, 1250 .v.pins = (const struct hda_pintbl[]) { 1251 { 0x14, 0x01014010 }, /* line-out */ 1252 { 0x15, 0x411111f0 }, /* N/A */ 1253 { 0x16, 0x411111f0 }, /* N/A */ 1254 { 0x17, 0x411111f0 }, /* N/A */ 1255 { 0x18, 0x01a19c30 }, /* mic-in */ 1256 { 0x19, 0x0121411f }, /* HP */ 1257 { 0x1a, 0x01813031 }, /* line-in */ 1258 { 0x1b, 0x02a19c40 }, /* front-mic */ 1259 { 0x1c, 0x411111f0 }, /* N/A */ 1260 { 0x1d, 0x411111f0 }, /* N/A */ 1261 /* 0x1e is filled in below */ 1262 { 0x1f, 0x411111f0 }, /* N/A */ 1263 { } 1264 } 1265 }, 1266 [ALC880_FIXUP_3ST] = { 1267 .type = HDA_FIXUP_PINS, 1268 .v.pins = (const struct hda_pintbl[]) { 1269 { 0x1e, 0x411111f0 }, /* N/A */ 1270 { } 1271 }, 1272 .chained = true, 1273 .chain_id = ALC880_FIXUP_3ST_BASE, 1274 }, 1275 [ALC880_FIXUP_3ST_DIG] = { 1276 .type = HDA_FIXUP_PINS, 1277 .v.pins = (const struct hda_pintbl[]) { 1278 { 0x1e, 0x0144111e }, /* SPDIF */ 1279 { } 1280 }, 1281 .chained = true, 1282 .chain_id = ALC880_FIXUP_3ST_BASE, 1283 }, 1284 [ALC880_FIXUP_5ST_BASE] = { 1285 .type = HDA_FIXUP_PINS, 1286 .v.pins = (const struct hda_pintbl[]) { 1287 { 0x14, 0x01014010 }, /* front */ 1288 { 0x15, 0x411111f0 }, /* N/A */ 1289 { 0x16, 0x01011411 }, /* CLFE */ 1290 { 0x17, 0x01016412 }, /* surr */ 1291 { 0x18, 0x01a19c30 }, /* mic-in */ 1292 { 0x19, 0x0121411f }, /* HP */ 1293 { 0x1a, 0x01813031 }, /* line-in */ 1294 { 0x1b, 0x02a19c40 }, /* front-mic */ 1295 { 0x1c, 0x411111f0 }, /* N/A */ 1296 { 0x1d, 0x411111f0 }, /* N/A */ 1297 /* 0x1e is filled in below */ 1298 { 0x1f, 0x411111f0 }, /* N/A */ 1299 { } 1300 } 1301 }, 1302 [ALC880_FIXUP_5ST] = { 1303 .type = HDA_FIXUP_PINS, 1304 .v.pins = (const struct hda_pintbl[]) { 1305 { 0x1e, 0x411111f0 }, /* N/A */ 1306 { } 1307 }, 1308 .chained = true, 1309 .chain_id = ALC880_FIXUP_5ST_BASE, 1310 }, 1311 [ALC880_FIXUP_5ST_DIG] = { 1312 .type = HDA_FIXUP_PINS, 1313 .v.pins = (const struct hda_pintbl[]) { 1314 { 0x1e, 0x0144111e }, /* SPDIF */ 1315 { } 1316 }, 1317 .chained = true, 1318 .chain_id = ALC880_FIXUP_5ST_BASE, 1319 }, 1320 [ALC880_FIXUP_6ST_BASE] = { 1321 .type = HDA_FIXUP_PINS, 1322 .v.pins = (const struct hda_pintbl[]) { 1323 { 0x14, 0x01014010 }, /* front */ 1324 { 0x15, 0x01016412 }, /* surr */ 1325 { 0x16, 0x01011411 }, /* CLFE */ 1326 { 0x17, 0x01012414 }, /* side */ 1327 { 0x18, 0x01a19c30 }, /* mic-in */ 1328 { 0x19, 0x02a19c40 }, /* front-mic */ 1329 { 0x1a, 0x01813031 }, /* line-in */ 1330 { 0x1b, 0x0121411f }, /* HP */ 1331 { 0x1c, 0x411111f0 }, /* N/A */ 1332 { 0x1d, 0x411111f0 }, /* N/A */ 1333 /* 0x1e is filled in below */ 1334 { 0x1f, 0x411111f0 }, /* N/A */ 1335 { } 1336 } 1337 }, 1338 [ALC880_FIXUP_6ST] = { 1339 .type = HDA_FIXUP_PINS, 1340 .v.pins = (const struct hda_pintbl[]) { 1341 { 0x1e, 0x411111f0 }, /* N/A */ 1342 { } 1343 }, 1344 .chained = true, 1345 .chain_id = ALC880_FIXUP_6ST_BASE, 1346 }, 1347 [ALC880_FIXUP_6ST_DIG] = { 1348 .type = HDA_FIXUP_PINS, 1349 .v.pins = (const struct hda_pintbl[]) { 1350 { 0x1e, 0x0144111e }, /* SPDIF */ 1351 { } 1352 }, 1353 .chained = true, 1354 .chain_id = ALC880_FIXUP_6ST_BASE, 1355 }, 1356 [ALC880_FIXUP_6ST_AUTOMUTE] = { 1357 .type = HDA_FIXUP_PINS, 1358 .v.pins = (const struct hda_pintbl[]) { 1359 { 0x1b, 0x0121401f }, /* HP with jack detect */ 1360 { } 1361 }, 1362 .chained_before = true, 1363 .chain_id = ALC880_FIXUP_6ST_BASE, 1364 }, 1365 }; 1366 1367 static const struct snd_pci_quirk alc880_fixup_tbl[] = { 1368 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810), 1369 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A), 1370 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V), 1371 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1), 1372 SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE), 1373 SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2), 1374 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF), 1375 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG), 1376 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734), 1377 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL), 1378 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB), 1379 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810), 1380 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM), 1381 SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE), 1382 SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU), 1383 SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU), 1384 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734), 1385 SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU), 1386 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG), 1387 SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG), 1388 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG), 1389 SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25), 1390 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700), 1391 1392 /* Below is the copied entries from alc880_quirks.c. 1393 * It's not quite sure whether BIOS sets the correct pin-config table 1394 * on these machines, thus they are kept to be compatible with 1395 * the old static quirks. Once when it's confirmed to work without 1396 * these overrides, it'd be better to remove. 1397 */ 1398 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG), 1399 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST), 1400 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG), 1401 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG), 1402 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG), 1403 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG), 1404 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG), 1405 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST), 1406 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG), 1407 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST), 1408 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST), 1409 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST), 1410 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST), 1411 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST), 1412 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG), 1413 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG), 1414 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG), 1415 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG), 1416 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG), 1417 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG), 1418 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG), 1419 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */ 1420 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG), 1421 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1422 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1423 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1424 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG), 1425 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1426 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG), 1427 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG), 1428 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1429 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1430 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG), 1431 /* default Intel */ 1432 SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST), 1433 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG), 1434 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG), 1435 {} 1436 }; 1437 1438 static const struct hda_model_fixup alc880_fixup_models[] = { 1439 {.id = ALC880_FIXUP_3ST, .name = "3stack"}, 1440 {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"}, 1441 {.id = ALC880_FIXUP_5ST, .name = "5stack"}, 1442 {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"}, 1443 {.id = ALC880_FIXUP_6ST, .name = "6stack"}, 1444 {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"}, 1445 {.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"}, 1446 {} 1447 }; 1448 1449 1450 /* 1451 * OK, here we have finally the patch for ALC880 1452 */ 1453 static int patch_alc880(struct hda_codec *codec) 1454 { 1455 struct alc_spec *spec; 1456 int err; 1457 1458 err = alc_alloc_spec(codec, 0x0b); 1459 if (err < 0) 1460 return err; 1461 1462 spec = codec->spec; 1463 spec->gen.need_dac_fix = 1; 1464 spec->gen.beep_nid = 0x01; 1465 1466 codec->patch_ops.unsol_event = alc880_unsol_event; 1467 1468 snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl, 1469 alc880_fixups); 1470 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 1471 1472 /* automatic parse from the BIOS config */ 1473 err = alc880_parse_auto_config(codec); 1474 if (err < 0) 1475 goto error; 1476 1477 if (!spec->gen.no_analog) 1478 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 1479 1480 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 1481 1482 return 0; 1483 1484 error: 1485 alc_free(codec); 1486 return err; 1487 } 1488 1489 1490 /* 1491 * ALC260 support 1492 */ 1493 static int alc260_parse_auto_config(struct hda_codec *codec) 1494 { 1495 static const hda_nid_t alc260_ignore[] = { 0x17, 0 }; 1496 static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 }; 1497 return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids); 1498 } 1499 1500 /* 1501 * Pin config fixes 1502 */ 1503 enum { 1504 ALC260_FIXUP_HP_DC5750, 1505 ALC260_FIXUP_HP_PIN_0F, 1506 ALC260_FIXUP_COEF, 1507 ALC260_FIXUP_GPIO1, 1508 ALC260_FIXUP_GPIO1_TOGGLE, 1509 ALC260_FIXUP_REPLACER, 1510 ALC260_FIXUP_HP_B1900, 1511 ALC260_FIXUP_KN1, 1512 ALC260_FIXUP_FSC_S7020, 1513 ALC260_FIXUP_FSC_S7020_JWSE, 1514 ALC260_FIXUP_VAIO_PINS, 1515 }; 1516 1517 static void alc260_gpio1_automute(struct hda_codec *codec) 1518 { 1519 struct alc_spec *spec = codec->spec; 1520 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 1521 spec->gen.hp_jack_present); 1522 } 1523 1524 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec, 1525 const struct hda_fixup *fix, int action) 1526 { 1527 struct alc_spec *spec = codec->spec; 1528 if (action == HDA_FIXUP_ACT_PROBE) { 1529 /* although the machine has only one output pin, we need to 1530 * toggle GPIO1 according to the jack state 1531 */ 1532 spec->gen.automute_hook = alc260_gpio1_automute; 1533 spec->gen.detect_hp = 1; 1534 spec->gen.automute_speaker = 1; 1535 spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */ 1536 snd_hda_jack_detect_enable_callback(codec, 0x0f, 1537 snd_hda_gen_hp_automute); 1538 snd_hda_add_verbs(codec, alc_gpio1_init_verbs); 1539 } 1540 } 1541 1542 static void alc260_fixup_kn1(struct hda_codec *codec, 1543 const struct hda_fixup *fix, int action) 1544 { 1545 struct alc_spec *spec = codec->spec; 1546 static const struct hda_pintbl pincfgs[] = { 1547 { 0x0f, 0x02214000 }, /* HP/speaker */ 1548 { 0x12, 0x90a60160 }, /* int mic */ 1549 { 0x13, 0x02a19000 }, /* ext mic */ 1550 { 0x18, 0x01446000 }, /* SPDIF out */ 1551 /* disable bogus I/O pins */ 1552 { 0x10, 0x411111f0 }, 1553 { 0x11, 0x411111f0 }, 1554 { 0x14, 0x411111f0 }, 1555 { 0x15, 0x411111f0 }, 1556 { 0x16, 0x411111f0 }, 1557 { 0x17, 0x411111f0 }, 1558 { 0x19, 0x411111f0 }, 1559 { } 1560 }; 1561 1562 switch (action) { 1563 case HDA_FIXUP_ACT_PRE_PROBE: 1564 snd_hda_apply_pincfgs(codec, pincfgs); 1565 break; 1566 case HDA_FIXUP_ACT_PROBE: 1567 spec->init_amp = ALC_INIT_NONE; 1568 break; 1569 } 1570 } 1571 1572 static void alc260_fixup_fsc_s7020(struct hda_codec *codec, 1573 const struct hda_fixup *fix, int action) 1574 { 1575 struct alc_spec *spec = codec->spec; 1576 if (action == HDA_FIXUP_ACT_PROBE) 1577 spec->init_amp = ALC_INIT_NONE; 1578 } 1579 1580 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec, 1581 const struct hda_fixup *fix, int action) 1582 { 1583 struct alc_spec *spec = codec->spec; 1584 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1585 spec->gen.add_jack_modes = 1; 1586 spec->gen.hp_mic = 1; 1587 } 1588 } 1589 1590 static const struct hda_fixup alc260_fixups[] = { 1591 [ALC260_FIXUP_HP_DC5750] = { 1592 .type = HDA_FIXUP_PINS, 1593 .v.pins = (const struct hda_pintbl[]) { 1594 { 0x11, 0x90130110 }, /* speaker */ 1595 { } 1596 } 1597 }, 1598 [ALC260_FIXUP_HP_PIN_0F] = { 1599 .type = HDA_FIXUP_PINS, 1600 .v.pins = (const struct hda_pintbl[]) { 1601 { 0x0f, 0x01214000 }, /* HP */ 1602 { } 1603 } 1604 }, 1605 [ALC260_FIXUP_COEF] = { 1606 .type = HDA_FIXUP_VERBS, 1607 .v.verbs = (const struct hda_verb[]) { 1608 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 }, 1609 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3040 }, 1610 { } 1611 }, 1612 }, 1613 [ALC260_FIXUP_GPIO1] = { 1614 .type = HDA_FIXUP_VERBS, 1615 .v.verbs = alc_gpio1_init_verbs, 1616 }, 1617 [ALC260_FIXUP_GPIO1_TOGGLE] = { 1618 .type = HDA_FIXUP_FUNC, 1619 .v.func = alc260_fixup_gpio1_toggle, 1620 .chained = true, 1621 .chain_id = ALC260_FIXUP_HP_PIN_0F, 1622 }, 1623 [ALC260_FIXUP_REPLACER] = { 1624 .type = HDA_FIXUP_VERBS, 1625 .v.verbs = (const struct hda_verb[]) { 1626 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 }, 1627 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3050 }, 1628 { } 1629 }, 1630 .chained = true, 1631 .chain_id = ALC260_FIXUP_GPIO1_TOGGLE, 1632 }, 1633 [ALC260_FIXUP_HP_B1900] = { 1634 .type = HDA_FIXUP_FUNC, 1635 .v.func = alc260_fixup_gpio1_toggle, 1636 .chained = true, 1637 .chain_id = ALC260_FIXUP_COEF, 1638 }, 1639 [ALC260_FIXUP_KN1] = { 1640 .type = HDA_FIXUP_FUNC, 1641 .v.func = alc260_fixup_kn1, 1642 }, 1643 [ALC260_FIXUP_FSC_S7020] = { 1644 .type = HDA_FIXUP_FUNC, 1645 .v.func = alc260_fixup_fsc_s7020, 1646 }, 1647 [ALC260_FIXUP_FSC_S7020_JWSE] = { 1648 .type = HDA_FIXUP_FUNC, 1649 .v.func = alc260_fixup_fsc_s7020_jwse, 1650 .chained = true, 1651 .chain_id = ALC260_FIXUP_FSC_S7020, 1652 }, 1653 [ALC260_FIXUP_VAIO_PINS] = { 1654 .type = HDA_FIXUP_PINS, 1655 .v.pins = (const struct hda_pintbl[]) { 1656 /* Pin configs are missing completely on some VAIOs */ 1657 { 0x0f, 0x01211020 }, 1658 { 0x10, 0x0001003f }, 1659 { 0x11, 0x411111f0 }, 1660 { 0x12, 0x01a15930 }, 1661 { 0x13, 0x411111f0 }, 1662 { 0x14, 0x411111f0 }, 1663 { 0x15, 0x411111f0 }, 1664 { 0x16, 0x411111f0 }, 1665 { 0x17, 0x411111f0 }, 1666 { 0x18, 0x411111f0 }, 1667 { 0x19, 0x411111f0 }, 1668 { } 1669 } 1670 }, 1671 }; 1672 1673 static const struct snd_pci_quirk alc260_fixup_tbl[] = { 1674 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1), 1675 SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF), 1676 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1), 1677 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750), 1678 SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900), 1679 SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS), 1680 SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F), 1681 SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020), 1682 SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1), 1683 SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1), 1684 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER), 1685 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF), 1686 {} 1687 }; 1688 1689 static const struct hda_model_fixup alc260_fixup_models[] = { 1690 {.id = ALC260_FIXUP_GPIO1, .name = "gpio1"}, 1691 {.id = ALC260_FIXUP_COEF, .name = "coef"}, 1692 {.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"}, 1693 {.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"}, 1694 {} 1695 }; 1696 1697 /* 1698 */ 1699 static int patch_alc260(struct hda_codec *codec) 1700 { 1701 struct alc_spec *spec; 1702 int err; 1703 1704 err = alc_alloc_spec(codec, 0x07); 1705 if (err < 0) 1706 return err; 1707 1708 spec = codec->spec; 1709 /* as quite a few machines require HP amp for speaker outputs, 1710 * it's easier to enable it unconditionally; even if it's unneeded, 1711 * it's almost harmless. 1712 */ 1713 spec->gen.prefer_hp_amp = 1; 1714 spec->gen.beep_nid = 0x01; 1715 1716 spec->shutup = alc_eapd_shutup; 1717 1718 snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl, 1719 alc260_fixups); 1720 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 1721 1722 /* automatic parse from the BIOS config */ 1723 err = alc260_parse_auto_config(codec); 1724 if (err < 0) 1725 goto error; 1726 1727 if (!spec->gen.no_analog) 1728 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT); 1729 1730 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 1731 1732 return 0; 1733 1734 error: 1735 alc_free(codec); 1736 return err; 1737 } 1738 1739 1740 /* 1741 * ALC882/883/885/888/889 support 1742 * 1743 * ALC882 is almost identical with ALC880 but has cleaner and more flexible 1744 * configuration. Each pin widget can choose any input DACs and a mixer. 1745 * Each ADC is connected from a mixer of all inputs. This makes possible 1746 * 6-channel independent captures. 1747 * 1748 * In addition, an independent DAC for the multi-playback (not used in this 1749 * driver yet). 1750 */ 1751 1752 /* 1753 * Pin config fixes 1754 */ 1755 enum { 1756 ALC882_FIXUP_ABIT_AW9D_MAX, 1757 ALC882_FIXUP_LENOVO_Y530, 1758 ALC882_FIXUP_PB_M5210, 1759 ALC882_FIXUP_ACER_ASPIRE_7736, 1760 ALC882_FIXUP_ASUS_W90V, 1761 ALC889_FIXUP_CD, 1762 ALC889_FIXUP_FRONT_HP_NO_PRESENCE, 1763 ALC889_FIXUP_VAIO_TT, 1764 ALC888_FIXUP_EEE1601, 1765 ALC882_FIXUP_EAPD, 1766 ALC883_FIXUP_EAPD, 1767 ALC883_FIXUP_ACER_EAPD, 1768 ALC882_FIXUP_GPIO1, 1769 ALC882_FIXUP_GPIO2, 1770 ALC882_FIXUP_GPIO3, 1771 ALC889_FIXUP_COEF, 1772 ALC882_FIXUP_ASUS_W2JC, 1773 ALC882_FIXUP_ACER_ASPIRE_4930G, 1774 ALC882_FIXUP_ACER_ASPIRE_8930G, 1775 ALC882_FIXUP_ASPIRE_8930G_VERBS, 1776 ALC885_FIXUP_MACPRO_GPIO, 1777 ALC889_FIXUP_DAC_ROUTE, 1778 ALC889_FIXUP_MBP_VREF, 1779 ALC889_FIXUP_IMAC91_VREF, 1780 ALC889_FIXUP_MBA11_VREF, 1781 ALC889_FIXUP_MBA21_VREF, 1782 ALC889_FIXUP_MP11_VREF, 1783 ALC889_FIXUP_MP41_VREF, 1784 ALC882_FIXUP_INV_DMIC, 1785 ALC882_FIXUP_NO_PRIMARY_HP, 1786 ALC887_FIXUP_ASUS_BASS, 1787 ALC887_FIXUP_BASS_CHMAP, 1788 ALC882_FIXUP_DISABLE_AAMIX, 1789 }; 1790 1791 static void alc889_fixup_coef(struct hda_codec *codec, 1792 const struct hda_fixup *fix, int action) 1793 { 1794 if (action != HDA_FIXUP_ACT_INIT) 1795 return; 1796 alc_update_coef_idx(codec, 7, 0, 0x2030); 1797 } 1798 1799 /* toggle speaker-output according to the hp-jack state */ 1800 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted) 1801 { 1802 unsigned int gpiostate, gpiomask, gpiodir; 1803 1804 gpiostate = snd_hda_codec_read(codec, codec->core.afg, 0, 1805 AC_VERB_GET_GPIO_DATA, 0); 1806 1807 if (!muted) 1808 gpiostate |= (1 << pin); 1809 else 1810 gpiostate &= ~(1 << pin); 1811 1812 gpiomask = snd_hda_codec_read(codec, codec->core.afg, 0, 1813 AC_VERB_GET_GPIO_MASK, 0); 1814 gpiomask |= (1 << pin); 1815 1816 gpiodir = snd_hda_codec_read(codec, codec->core.afg, 0, 1817 AC_VERB_GET_GPIO_DIRECTION, 0); 1818 gpiodir |= (1 << pin); 1819 1820 1821 snd_hda_codec_write(codec, codec->core.afg, 0, 1822 AC_VERB_SET_GPIO_MASK, gpiomask); 1823 snd_hda_codec_write(codec, codec->core.afg, 0, 1824 AC_VERB_SET_GPIO_DIRECTION, gpiodir); 1825 1826 msleep(1); 1827 1828 snd_hda_codec_write(codec, codec->core.afg, 0, 1829 AC_VERB_SET_GPIO_DATA, gpiostate); 1830 } 1831 1832 /* set up GPIO at initialization */ 1833 static void alc885_fixup_macpro_gpio(struct hda_codec *codec, 1834 const struct hda_fixup *fix, int action) 1835 { 1836 if (action != HDA_FIXUP_ACT_INIT) 1837 return; 1838 alc882_gpio_mute(codec, 0, 0); 1839 alc882_gpio_mute(codec, 1, 0); 1840 } 1841 1842 /* Fix the connection of some pins for ALC889: 1843 * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't 1844 * work correctly (bko#42740) 1845 */ 1846 static void alc889_fixup_dac_route(struct hda_codec *codec, 1847 const struct hda_fixup *fix, int action) 1848 { 1849 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1850 /* fake the connections during parsing the tree */ 1851 hda_nid_t conn1[2] = { 0x0c, 0x0d }; 1852 hda_nid_t conn2[2] = { 0x0e, 0x0f }; 1853 snd_hda_override_conn_list(codec, 0x14, 2, conn1); 1854 snd_hda_override_conn_list(codec, 0x15, 2, conn1); 1855 snd_hda_override_conn_list(codec, 0x18, 2, conn2); 1856 snd_hda_override_conn_list(codec, 0x1a, 2, conn2); 1857 } else if (action == HDA_FIXUP_ACT_PROBE) { 1858 /* restore the connections */ 1859 hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 }; 1860 snd_hda_override_conn_list(codec, 0x14, 5, conn); 1861 snd_hda_override_conn_list(codec, 0x15, 5, conn); 1862 snd_hda_override_conn_list(codec, 0x18, 5, conn); 1863 snd_hda_override_conn_list(codec, 0x1a, 5, conn); 1864 } 1865 } 1866 1867 /* Set VREF on HP pin */ 1868 static void alc889_fixup_mbp_vref(struct hda_codec *codec, 1869 const struct hda_fixup *fix, int action) 1870 { 1871 struct alc_spec *spec = codec->spec; 1872 static hda_nid_t nids[3] = { 0x14, 0x15, 0x19 }; 1873 int i; 1874 1875 if (action != HDA_FIXUP_ACT_INIT) 1876 return; 1877 for (i = 0; i < ARRAY_SIZE(nids); i++) { 1878 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]); 1879 if (get_defcfg_device(val) != AC_JACK_HP_OUT) 1880 continue; 1881 val = snd_hda_codec_get_pin_target(codec, nids[i]); 1882 val |= AC_PINCTL_VREF_80; 1883 snd_hda_set_pin_ctl(codec, nids[i], val); 1884 spec->gen.keep_vref_in_automute = 1; 1885 break; 1886 } 1887 } 1888 1889 static void alc889_fixup_mac_pins(struct hda_codec *codec, 1890 const hda_nid_t *nids, int num_nids) 1891 { 1892 struct alc_spec *spec = codec->spec; 1893 int i; 1894 1895 for (i = 0; i < num_nids; i++) { 1896 unsigned int val; 1897 val = snd_hda_codec_get_pin_target(codec, nids[i]); 1898 val |= AC_PINCTL_VREF_50; 1899 snd_hda_set_pin_ctl(codec, nids[i], val); 1900 } 1901 spec->gen.keep_vref_in_automute = 1; 1902 } 1903 1904 /* Set VREF on speaker pins on imac91 */ 1905 static void alc889_fixup_imac91_vref(struct hda_codec *codec, 1906 const struct hda_fixup *fix, int action) 1907 { 1908 static hda_nid_t nids[2] = { 0x18, 0x1a }; 1909 1910 if (action == HDA_FIXUP_ACT_INIT) 1911 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids)); 1912 } 1913 1914 /* Set VREF on speaker pins on mba11 */ 1915 static void alc889_fixup_mba11_vref(struct hda_codec *codec, 1916 const struct hda_fixup *fix, int action) 1917 { 1918 static hda_nid_t nids[1] = { 0x18 }; 1919 1920 if (action == HDA_FIXUP_ACT_INIT) 1921 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids)); 1922 } 1923 1924 /* Set VREF on speaker pins on mba21 */ 1925 static void alc889_fixup_mba21_vref(struct hda_codec *codec, 1926 const struct hda_fixup *fix, int action) 1927 { 1928 static hda_nid_t nids[2] = { 0x18, 0x19 }; 1929 1930 if (action == HDA_FIXUP_ACT_INIT) 1931 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids)); 1932 } 1933 1934 /* Don't take HP output as primary 1935 * Strangely, the speaker output doesn't work on Vaio Z and some Vaio 1936 * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05 1937 */ 1938 static void alc882_fixup_no_primary_hp(struct hda_codec *codec, 1939 const struct hda_fixup *fix, int action) 1940 { 1941 struct alc_spec *spec = codec->spec; 1942 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1943 spec->gen.no_primary_hp = 1; 1944 spec->gen.no_multi_io = 1; 1945 } 1946 } 1947 1948 static void alc_fixup_bass_chmap(struct hda_codec *codec, 1949 const struct hda_fixup *fix, int action); 1950 static void alc_fixup_disable_aamix(struct hda_codec *codec, 1951 const struct hda_fixup *fix, int action); 1952 1953 static const struct hda_fixup alc882_fixups[] = { 1954 [ALC882_FIXUP_ABIT_AW9D_MAX] = { 1955 .type = HDA_FIXUP_PINS, 1956 .v.pins = (const struct hda_pintbl[]) { 1957 { 0x15, 0x01080104 }, /* side */ 1958 { 0x16, 0x01011012 }, /* rear */ 1959 { 0x17, 0x01016011 }, /* clfe */ 1960 { } 1961 } 1962 }, 1963 [ALC882_FIXUP_LENOVO_Y530] = { 1964 .type = HDA_FIXUP_PINS, 1965 .v.pins = (const struct hda_pintbl[]) { 1966 { 0x15, 0x99130112 }, /* rear int speakers */ 1967 { 0x16, 0x99130111 }, /* subwoofer */ 1968 { } 1969 } 1970 }, 1971 [ALC882_FIXUP_PB_M5210] = { 1972 .type = HDA_FIXUP_PINCTLS, 1973 .v.pins = (const struct hda_pintbl[]) { 1974 { 0x19, PIN_VREF50 }, 1975 {} 1976 } 1977 }, 1978 [ALC882_FIXUP_ACER_ASPIRE_7736] = { 1979 .type = HDA_FIXUP_FUNC, 1980 .v.func = alc_fixup_sku_ignore, 1981 }, 1982 [ALC882_FIXUP_ASUS_W90V] = { 1983 .type = HDA_FIXUP_PINS, 1984 .v.pins = (const struct hda_pintbl[]) { 1985 { 0x16, 0x99130110 }, /* fix sequence for CLFE */ 1986 { } 1987 } 1988 }, 1989 [ALC889_FIXUP_CD] = { 1990 .type = HDA_FIXUP_PINS, 1991 .v.pins = (const struct hda_pintbl[]) { 1992 { 0x1c, 0x993301f0 }, /* CD */ 1993 { } 1994 } 1995 }, 1996 [ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = { 1997 .type = HDA_FIXUP_PINS, 1998 .v.pins = (const struct hda_pintbl[]) { 1999 { 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */ 2000 { } 2001 }, 2002 .chained = true, 2003 .chain_id = ALC889_FIXUP_CD, 2004 }, 2005 [ALC889_FIXUP_VAIO_TT] = { 2006 .type = HDA_FIXUP_PINS, 2007 .v.pins = (const struct hda_pintbl[]) { 2008 { 0x17, 0x90170111 }, /* hidden surround speaker */ 2009 { } 2010 } 2011 }, 2012 [ALC888_FIXUP_EEE1601] = { 2013 .type = HDA_FIXUP_VERBS, 2014 .v.verbs = (const struct hda_verb[]) { 2015 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b }, 2016 { 0x20, AC_VERB_SET_PROC_COEF, 0x0838 }, 2017 { } 2018 } 2019 }, 2020 [ALC882_FIXUP_EAPD] = { 2021 .type = HDA_FIXUP_VERBS, 2022 .v.verbs = (const struct hda_verb[]) { 2023 /* change to EAPD mode */ 2024 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2025 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 }, 2026 { } 2027 } 2028 }, 2029 [ALC883_FIXUP_EAPD] = { 2030 .type = HDA_FIXUP_VERBS, 2031 .v.verbs = (const struct hda_verb[]) { 2032 /* change to EAPD mode */ 2033 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2034 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 }, 2035 { } 2036 } 2037 }, 2038 [ALC883_FIXUP_ACER_EAPD] = { 2039 .type = HDA_FIXUP_VERBS, 2040 .v.verbs = (const struct hda_verb[]) { 2041 /* eanable EAPD on Acer laptops */ 2042 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2043 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 }, 2044 { } 2045 } 2046 }, 2047 [ALC882_FIXUP_GPIO1] = { 2048 .type = HDA_FIXUP_VERBS, 2049 .v.verbs = alc_gpio1_init_verbs, 2050 }, 2051 [ALC882_FIXUP_GPIO2] = { 2052 .type = HDA_FIXUP_VERBS, 2053 .v.verbs = alc_gpio2_init_verbs, 2054 }, 2055 [ALC882_FIXUP_GPIO3] = { 2056 .type = HDA_FIXUP_VERBS, 2057 .v.verbs = alc_gpio3_init_verbs, 2058 }, 2059 [ALC882_FIXUP_ASUS_W2JC] = { 2060 .type = HDA_FIXUP_VERBS, 2061 .v.verbs = alc_gpio1_init_verbs, 2062 .chained = true, 2063 .chain_id = ALC882_FIXUP_EAPD, 2064 }, 2065 [ALC889_FIXUP_COEF] = { 2066 .type = HDA_FIXUP_FUNC, 2067 .v.func = alc889_fixup_coef, 2068 }, 2069 [ALC882_FIXUP_ACER_ASPIRE_4930G] = { 2070 .type = HDA_FIXUP_PINS, 2071 .v.pins = (const struct hda_pintbl[]) { 2072 { 0x16, 0x99130111 }, /* CLFE speaker */ 2073 { 0x17, 0x99130112 }, /* surround speaker */ 2074 { } 2075 }, 2076 .chained = true, 2077 .chain_id = ALC882_FIXUP_GPIO1, 2078 }, 2079 [ALC882_FIXUP_ACER_ASPIRE_8930G] = { 2080 .type = HDA_FIXUP_PINS, 2081 .v.pins = (const struct hda_pintbl[]) { 2082 { 0x16, 0x99130111 }, /* CLFE speaker */ 2083 { 0x1b, 0x99130112 }, /* surround speaker */ 2084 { } 2085 }, 2086 .chained = true, 2087 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS, 2088 }, 2089 [ALC882_FIXUP_ASPIRE_8930G_VERBS] = { 2090 /* additional init verbs for Acer Aspire 8930G */ 2091 .type = HDA_FIXUP_VERBS, 2092 .v.verbs = (const struct hda_verb[]) { 2093 /* Enable all DACs */ 2094 /* DAC DISABLE/MUTE 1? */ 2095 /* setting bits 1-5 disables DAC nids 0x02-0x06 2096 * apparently. Init=0x38 */ 2097 { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 }, 2098 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 }, 2099 /* DAC DISABLE/MUTE 2? */ 2100 /* some bit here disables the other DACs. 2101 * Init=0x4900 */ 2102 { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 }, 2103 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 }, 2104 /* DMIC fix 2105 * This laptop has a stereo digital microphone. 2106 * The mics are only 1cm apart which makes the stereo 2107 * useless. However, either the mic or the ALC889 2108 * makes the signal become a difference/sum signal 2109 * instead of standard stereo, which is annoying. 2110 * So instead we flip this bit which makes the 2111 * codec replicate the sum signal to both channels, 2112 * turning it into a normal mono mic. 2113 */ 2114 /* DMIC_CONTROL? Init value = 0x0001 */ 2115 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b }, 2116 { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 }, 2117 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2118 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 }, 2119 { } 2120 }, 2121 .chained = true, 2122 .chain_id = ALC882_FIXUP_GPIO1, 2123 }, 2124 [ALC885_FIXUP_MACPRO_GPIO] = { 2125 .type = HDA_FIXUP_FUNC, 2126 .v.func = alc885_fixup_macpro_gpio, 2127 }, 2128 [ALC889_FIXUP_DAC_ROUTE] = { 2129 .type = HDA_FIXUP_FUNC, 2130 .v.func = alc889_fixup_dac_route, 2131 }, 2132 [ALC889_FIXUP_MBP_VREF] = { 2133 .type = HDA_FIXUP_FUNC, 2134 .v.func = alc889_fixup_mbp_vref, 2135 .chained = true, 2136 .chain_id = ALC882_FIXUP_GPIO1, 2137 }, 2138 [ALC889_FIXUP_IMAC91_VREF] = { 2139 .type = HDA_FIXUP_FUNC, 2140 .v.func = alc889_fixup_imac91_vref, 2141 .chained = true, 2142 .chain_id = ALC882_FIXUP_GPIO1, 2143 }, 2144 [ALC889_FIXUP_MBA11_VREF] = { 2145 .type = HDA_FIXUP_FUNC, 2146 .v.func = alc889_fixup_mba11_vref, 2147 .chained = true, 2148 .chain_id = ALC889_FIXUP_MBP_VREF, 2149 }, 2150 [ALC889_FIXUP_MBA21_VREF] = { 2151 .type = HDA_FIXUP_FUNC, 2152 .v.func = alc889_fixup_mba21_vref, 2153 .chained = true, 2154 .chain_id = ALC889_FIXUP_MBP_VREF, 2155 }, 2156 [ALC889_FIXUP_MP11_VREF] = { 2157 .type = HDA_FIXUP_FUNC, 2158 .v.func = alc889_fixup_mba11_vref, 2159 .chained = true, 2160 .chain_id = ALC885_FIXUP_MACPRO_GPIO, 2161 }, 2162 [ALC889_FIXUP_MP41_VREF] = { 2163 .type = HDA_FIXUP_FUNC, 2164 .v.func = alc889_fixup_mbp_vref, 2165 .chained = true, 2166 .chain_id = ALC885_FIXUP_MACPRO_GPIO, 2167 }, 2168 [ALC882_FIXUP_INV_DMIC] = { 2169 .type = HDA_FIXUP_FUNC, 2170 .v.func = alc_fixup_inv_dmic, 2171 }, 2172 [ALC882_FIXUP_NO_PRIMARY_HP] = { 2173 .type = HDA_FIXUP_FUNC, 2174 .v.func = alc882_fixup_no_primary_hp, 2175 }, 2176 [ALC887_FIXUP_ASUS_BASS] = { 2177 .type = HDA_FIXUP_PINS, 2178 .v.pins = (const struct hda_pintbl[]) { 2179 {0x16, 0x99130130}, /* bass speaker */ 2180 {} 2181 }, 2182 .chained = true, 2183 .chain_id = ALC887_FIXUP_BASS_CHMAP, 2184 }, 2185 [ALC887_FIXUP_BASS_CHMAP] = { 2186 .type = HDA_FIXUP_FUNC, 2187 .v.func = alc_fixup_bass_chmap, 2188 }, 2189 [ALC882_FIXUP_DISABLE_AAMIX] = { 2190 .type = HDA_FIXUP_FUNC, 2191 .v.func = alc_fixup_disable_aamix, 2192 }, 2193 }; 2194 2195 static const struct snd_pci_quirk alc882_fixup_tbl[] = { 2196 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD), 2197 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD), 2198 SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD), 2199 SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD), 2200 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD), 2201 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD), 2202 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD), 2203 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G", 2204 ALC882_FIXUP_ACER_ASPIRE_4930G), 2205 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G", 2206 ALC882_FIXUP_ACER_ASPIRE_4930G), 2207 SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G", 2208 ALC882_FIXUP_ACER_ASPIRE_8930G), 2209 SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G", 2210 ALC882_FIXUP_ACER_ASPIRE_8930G), 2211 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G", 2212 ALC882_FIXUP_ACER_ASPIRE_4930G), 2213 SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G", 2214 ALC882_FIXUP_ACER_ASPIRE_4930G), 2215 SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G", 2216 ALC882_FIXUP_ACER_ASPIRE_4930G), 2217 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210), 2218 SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G", 2219 ALC882_FIXUP_ACER_ASPIRE_4930G), 2220 SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE), 2221 SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G), 2222 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736), 2223 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD), 2224 SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V), 2225 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC), 2226 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601), 2227 SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS), 2228 SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT), 2229 SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP), 2230 SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP), 2231 2232 /* All Apple entries are in codec SSIDs */ 2233 SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF), 2234 SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF), 2235 SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF), 2236 SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF), 2237 SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO), 2238 SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO), 2239 SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF), 2240 SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF), 2241 SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD), 2242 SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF), 2243 SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF), 2244 SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF), 2245 SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF), 2246 SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO), 2247 SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF), 2248 SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF), 2249 SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF), 2250 SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF), 2251 SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF), 2252 SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF), 2253 SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF), 2254 SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF), 2255 2256 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD), 2257 SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD), 2258 SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3), 2259 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE), 2260 SND_PCI_QUIRK(0x1458, 0xa182, "Gigabyte Z170X-UD3", ALC882_FIXUP_DISABLE_AAMIX), 2261 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX), 2262 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD), 2263 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD), 2264 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530), 2265 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF), 2266 {} 2267 }; 2268 2269 static const struct hda_model_fixup alc882_fixup_models[] = { 2270 {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"}, 2271 {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"}, 2272 {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"}, 2273 {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"}, 2274 {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"}, 2275 {} 2276 }; 2277 2278 /* 2279 * BIOS auto configuration 2280 */ 2281 /* almost identical with ALC880 parser... */ 2282 static int alc882_parse_auto_config(struct hda_codec *codec) 2283 { 2284 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 }; 2285 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 2286 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids); 2287 } 2288 2289 /* 2290 */ 2291 static int patch_alc882(struct hda_codec *codec) 2292 { 2293 struct alc_spec *spec; 2294 int err; 2295 2296 err = alc_alloc_spec(codec, 0x0b); 2297 if (err < 0) 2298 return err; 2299 2300 spec = codec->spec; 2301 2302 switch (codec->core.vendor_id) { 2303 case 0x10ec0882: 2304 case 0x10ec0885: 2305 case 0x10ec0900: 2306 break; 2307 default: 2308 /* ALC883 and variants */ 2309 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 2310 break; 2311 } 2312 2313 snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl, 2314 alc882_fixups); 2315 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 2316 2317 alc_auto_parse_customize_define(codec); 2318 2319 if (has_cdefine_beep(codec)) 2320 spec->gen.beep_nid = 0x01; 2321 2322 /* automatic parse from the BIOS config */ 2323 err = alc882_parse_auto_config(codec); 2324 if (err < 0) 2325 goto error; 2326 2327 if (!spec->gen.no_analog && spec->gen.beep_nid) 2328 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 2329 2330 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 2331 2332 return 0; 2333 2334 error: 2335 alc_free(codec); 2336 return err; 2337 } 2338 2339 2340 /* 2341 * ALC262 support 2342 */ 2343 static int alc262_parse_auto_config(struct hda_codec *codec) 2344 { 2345 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 }; 2346 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 2347 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids); 2348 } 2349 2350 /* 2351 * Pin config fixes 2352 */ 2353 enum { 2354 ALC262_FIXUP_FSC_H270, 2355 ALC262_FIXUP_FSC_S7110, 2356 ALC262_FIXUP_HP_Z200, 2357 ALC262_FIXUP_TYAN, 2358 ALC262_FIXUP_LENOVO_3000, 2359 ALC262_FIXUP_BENQ, 2360 ALC262_FIXUP_BENQ_T31, 2361 ALC262_FIXUP_INV_DMIC, 2362 ALC262_FIXUP_INTEL_BAYLEYBAY, 2363 }; 2364 2365 static const struct hda_fixup alc262_fixups[] = { 2366 [ALC262_FIXUP_FSC_H270] = { 2367 .type = HDA_FIXUP_PINS, 2368 .v.pins = (const struct hda_pintbl[]) { 2369 { 0x14, 0x99130110 }, /* speaker */ 2370 { 0x15, 0x0221142f }, /* front HP */ 2371 { 0x1b, 0x0121141f }, /* rear HP */ 2372 { } 2373 } 2374 }, 2375 [ALC262_FIXUP_FSC_S7110] = { 2376 .type = HDA_FIXUP_PINS, 2377 .v.pins = (const struct hda_pintbl[]) { 2378 { 0x15, 0x90170110 }, /* speaker */ 2379 { } 2380 }, 2381 .chained = true, 2382 .chain_id = ALC262_FIXUP_BENQ, 2383 }, 2384 [ALC262_FIXUP_HP_Z200] = { 2385 .type = HDA_FIXUP_PINS, 2386 .v.pins = (const struct hda_pintbl[]) { 2387 { 0x16, 0x99130120 }, /* internal speaker */ 2388 { } 2389 } 2390 }, 2391 [ALC262_FIXUP_TYAN] = { 2392 .type = HDA_FIXUP_PINS, 2393 .v.pins = (const struct hda_pintbl[]) { 2394 { 0x14, 0x1993e1f0 }, /* int AUX */ 2395 { } 2396 } 2397 }, 2398 [ALC262_FIXUP_LENOVO_3000] = { 2399 .type = HDA_FIXUP_PINCTLS, 2400 .v.pins = (const struct hda_pintbl[]) { 2401 { 0x19, PIN_VREF50 }, 2402 {} 2403 }, 2404 .chained = true, 2405 .chain_id = ALC262_FIXUP_BENQ, 2406 }, 2407 [ALC262_FIXUP_BENQ] = { 2408 .type = HDA_FIXUP_VERBS, 2409 .v.verbs = (const struct hda_verb[]) { 2410 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2411 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 }, 2412 {} 2413 } 2414 }, 2415 [ALC262_FIXUP_BENQ_T31] = { 2416 .type = HDA_FIXUP_VERBS, 2417 .v.verbs = (const struct hda_verb[]) { 2418 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 2419 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 }, 2420 {} 2421 } 2422 }, 2423 [ALC262_FIXUP_INV_DMIC] = { 2424 .type = HDA_FIXUP_FUNC, 2425 .v.func = alc_fixup_inv_dmic, 2426 }, 2427 [ALC262_FIXUP_INTEL_BAYLEYBAY] = { 2428 .type = HDA_FIXUP_FUNC, 2429 .v.func = alc_fixup_no_depop_delay, 2430 }, 2431 }; 2432 2433 static const struct snd_pci_quirk alc262_fixup_tbl[] = { 2434 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200), 2435 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110), 2436 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ), 2437 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN), 2438 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270), 2439 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000), 2440 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ), 2441 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31), 2442 SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY), 2443 {} 2444 }; 2445 2446 static const struct hda_model_fixup alc262_fixup_models[] = { 2447 {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"}, 2448 {} 2449 }; 2450 2451 /* 2452 */ 2453 static int patch_alc262(struct hda_codec *codec) 2454 { 2455 struct alc_spec *spec; 2456 int err; 2457 2458 err = alc_alloc_spec(codec, 0x0b); 2459 if (err < 0) 2460 return err; 2461 2462 spec = codec->spec; 2463 spec->gen.shared_mic_vref_pin = 0x18; 2464 2465 spec->shutup = alc_eapd_shutup; 2466 2467 #if 0 2468 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is 2469 * under-run 2470 */ 2471 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80); 2472 #endif 2473 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 2474 2475 snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl, 2476 alc262_fixups); 2477 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 2478 2479 alc_auto_parse_customize_define(codec); 2480 2481 if (has_cdefine_beep(codec)) 2482 spec->gen.beep_nid = 0x01; 2483 2484 /* automatic parse from the BIOS config */ 2485 err = alc262_parse_auto_config(codec); 2486 if (err < 0) 2487 goto error; 2488 2489 if (!spec->gen.no_analog && spec->gen.beep_nid) 2490 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 2491 2492 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 2493 2494 return 0; 2495 2496 error: 2497 alc_free(codec); 2498 return err; 2499 } 2500 2501 /* 2502 * ALC268 2503 */ 2504 /* bind Beep switches of both NID 0x0f and 0x10 */ 2505 static const struct hda_bind_ctls alc268_bind_beep_sw = { 2506 .ops = &snd_hda_bind_sw, 2507 .values = { 2508 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT), 2509 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT), 2510 0 2511 }, 2512 }; 2513 2514 static const struct snd_kcontrol_new alc268_beep_mixer[] = { 2515 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT), 2516 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw), 2517 { } 2518 }; 2519 2520 /* set PCBEEP vol = 0, mute connections */ 2521 static const struct hda_verb alc268_beep_init_verbs[] = { 2522 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2523 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2524 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2525 { } 2526 }; 2527 2528 enum { 2529 ALC268_FIXUP_INV_DMIC, 2530 ALC268_FIXUP_HP_EAPD, 2531 ALC268_FIXUP_SPDIF, 2532 }; 2533 2534 static const struct hda_fixup alc268_fixups[] = { 2535 [ALC268_FIXUP_INV_DMIC] = { 2536 .type = HDA_FIXUP_FUNC, 2537 .v.func = alc_fixup_inv_dmic, 2538 }, 2539 [ALC268_FIXUP_HP_EAPD] = { 2540 .type = HDA_FIXUP_VERBS, 2541 .v.verbs = (const struct hda_verb[]) { 2542 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0}, 2543 {} 2544 } 2545 }, 2546 [ALC268_FIXUP_SPDIF] = { 2547 .type = HDA_FIXUP_PINS, 2548 .v.pins = (const struct hda_pintbl[]) { 2549 { 0x1e, 0x014b1180 }, /* enable SPDIF out */ 2550 {} 2551 } 2552 }, 2553 }; 2554 2555 static const struct hda_model_fixup alc268_fixup_models[] = { 2556 {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"}, 2557 {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"}, 2558 {} 2559 }; 2560 2561 static const struct snd_pci_quirk alc268_fixup_tbl[] = { 2562 SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF), 2563 SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC), 2564 /* below is codec SSID since multiple Toshiba laptops have the 2565 * same PCI SSID 1179:ff00 2566 */ 2567 SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD), 2568 {} 2569 }; 2570 2571 /* 2572 * BIOS auto configuration 2573 */ 2574 static int alc268_parse_auto_config(struct hda_codec *codec) 2575 { 2576 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 2577 return alc_parse_auto_config(codec, NULL, alc268_ssids); 2578 } 2579 2580 /* 2581 */ 2582 static int patch_alc268(struct hda_codec *codec) 2583 { 2584 struct alc_spec *spec; 2585 int err; 2586 2587 /* ALC268 has no aa-loopback mixer */ 2588 err = alc_alloc_spec(codec, 0); 2589 if (err < 0) 2590 return err; 2591 2592 spec = codec->spec; 2593 spec->gen.beep_nid = 0x01; 2594 2595 spec->shutup = alc_eapd_shutup; 2596 2597 snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups); 2598 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 2599 2600 /* automatic parse from the BIOS config */ 2601 err = alc268_parse_auto_config(codec); 2602 if (err < 0) 2603 goto error; 2604 2605 if (err > 0 && !spec->gen.no_analog && 2606 spec->gen.autocfg.speaker_pins[0] != 0x1d) { 2607 add_mixer(spec, alc268_beep_mixer); 2608 snd_hda_add_verbs(codec, alc268_beep_init_verbs); 2609 if (!query_amp_caps(codec, 0x1d, HDA_INPUT)) 2610 /* override the amp caps for beep generator */ 2611 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT, 2612 (0x0c << AC_AMPCAP_OFFSET_SHIFT) | 2613 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) | 2614 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) | 2615 (0 << AC_AMPCAP_MUTE_SHIFT)); 2616 } 2617 2618 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 2619 2620 return 0; 2621 2622 error: 2623 alc_free(codec); 2624 return err; 2625 } 2626 2627 /* 2628 * ALC269 2629 */ 2630 2631 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = { 2632 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */ 2633 }; 2634 2635 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = { 2636 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */ 2637 }; 2638 2639 /* different alc269-variants */ 2640 enum { 2641 ALC269_TYPE_ALC269VA, 2642 ALC269_TYPE_ALC269VB, 2643 ALC269_TYPE_ALC269VC, 2644 ALC269_TYPE_ALC269VD, 2645 ALC269_TYPE_ALC280, 2646 ALC269_TYPE_ALC282, 2647 ALC269_TYPE_ALC283, 2648 ALC269_TYPE_ALC284, 2649 ALC269_TYPE_ALC285, 2650 ALC269_TYPE_ALC286, 2651 ALC269_TYPE_ALC298, 2652 ALC269_TYPE_ALC255, 2653 ALC269_TYPE_ALC256, 2654 }; 2655 2656 /* 2657 * BIOS auto configuration 2658 */ 2659 static int alc269_parse_auto_config(struct hda_codec *codec) 2660 { 2661 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 }; 2662 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 }; 2663 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 2664 struct alc_spec *spec = codec->spec; 2665 const hda_nid_t *ssids; 2666 2667 switch (spec->codec_variant) { 2668 case ALC269_TYPE_ALC269VA: 2669 case ALC269_TYPE_ALC269VC: 2670 case ALC269_TYPE_ALC280: 2671 case ALC269_TYPE_ALC284: 2672 case ALC269_TYPE_ALC285: 2673 ssids = alc269va_ssids; 2674 break; 2675 case ALC269_TYPE_ALC269VB: 2676 case ALC269_TYPE_ALC269VD: 2677 case ALC269_TYPE_ALC282: 2678 case ALC269_TYPE_ALC283: 2679 case ALC269_TYPE_ALC286: 2680 case ALC269_TYPE_ALC298: 2681 case ALC269_TYPE_ALC255: 2682 case ALC269_TYPE_ALC256: 2683 ssids = alc269_ssids; 2684 break; 2685 default: 2686 ssids = alc269_ssids; 2687 break; 2688 } 2689 2690 return alc_parse_auto_config(codec, alc269_ignore, ssids); 2691 } 2692 2693 static int find_ext_mic_pin(struct hda_codec *codec); 2694 2695 static void alc286_shutup(struct hda_codec *codec) 2696 { 2697 int i; 2698 int mic_pin = find_ext_mic_pin(codec); 2699 /* don't shut up pins when unloading the driver; otherwise it breaks 2700 * the default pin setup at the next load of the driver 2701 */ 2702 if (codec->bus->shutdown) 2703 return; 2704 for (i = 0; i < codec->init_pins.used; i++) { 2705 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i); 2706 /* use read here for syncing after issuing each verb */ 2707 if (pin->nid != mic_pin) 2708 snd_hda_codec_read(codec, pin->nid, 0, 2709 AC_VERB_SET_PIN_WIDGET_CONTROL, 0); 2710 } 2711 codec->pins_shutup = 1; 2712 } 2713 2714 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up) 2715 { 2716 alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0); 2717 } 2718 2719 static void alc269_shutup(struct hda_codec *codec) 2720 { 2721 struct alc_spec *spec = codec->spec; 2722 2723 if (spec->codec_variant == ALC269_TYPE_ALC269VB) 2724 alc269vb_toggle_power_output(codec, 0); 2725 if (spec->codec_variant == ALC269_TYPE_ALC269VB && 2726 (alc_get_coef0(codec) & 0x00ff) == 0x018) { 2727 msleep(150); 2728 } 2729 snd_hda_shutup_pins(codec); 2730 } 2731 2732 static struct coef_fw alc282_coefs[] = { 2733 WRITE_COEF(0x03, 0x0002), /* Power Down Control */ 2734 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */ 2735 WRITE_COEF(0x07, 0x0200), /* DMIC control */ 2736 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */ 2737 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */ 2738 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */ 2739 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */ 2740 WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */ 2741 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */ 2742 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */ 2743 WRITE_COEF(0x6f, 0x0), /* Class D test 4 */ 2744 UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */ 2745 WRITE_COEF(0x34, 0xa0c0), /* ANC */ 2746 UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */ 2747 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */ 2748 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */ 2749 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */ 2750 WRITE_COEF(0x63, 0x2902), /* PLL */ 2751 WRITE_COEF(0x68, 0xa080), /* capless control 2 */ 2752 WRITE_COEF(0x69, 0x3400), /* capless control 3 */ 2753 WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */ 2754 WRITE_COEF(0x6b, 0x0), /* capless control 5 */ 2755 UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */ 2756 WRITE_COEF(0x6e, 0x110a), /* class D test 3 */ 2757 UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */ 2758 WRITE_COEF(0x71, 0x0014), /* class D test 6 */ 2759 WRITE_COEF(0x72, 0xc2ba), /* classD OCP */ 2760 UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */ 2761 WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */ 2762 {} 2763 }; 2764 2765 static void alc282_restore_default_value(struct hda_codec *codec) 2766 { 2767 alc_process_coef_fw(codec, alc282_coefs); 2768 } 2769 2770 static void alc282_init(struct hda_codec *codec) 2771 { 2772 struct alc_spec *spec = codec->spec; 2773 hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0]; 2774 bool hp_pin_sense; 2775 int coef78; 2776 2777 alc282_restore_default_value(codec); 2778 2779 if (!hp_pin) 2780 return; 2781 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 2782 coef78 = alc_read_coef_idx(codec, 0x78); 2783 2784 /* Index 0x78 Direct Drive HP AMP LPM Control 1 */ 2785 /* Headphone capless set to high power mode */ 2786 alc_write_coef_idx(codec, 0x78, 0x9004); 2787 2788 if (hp_pin_sense) 2789 msleep(2); 2790 2791 snd_hda_codec_write(codec, hp_pin, 0, 2792 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 2793 2794 if (hp_pin_sense) 2795 msleep(85); 2796 2797 snd_hda_codec_write(codec, hp_pin, 0, 2798 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 2799 2800 if (hp_pin_sense) 2801 msleep(100); 2802 2803 /* Headphone capless set to normal mode */ 2804 alc_write_coef_idx(codec, 0x78, coef78); 2805 } 2806 2807 static void alc282_shutup(struct hda_codec *codec) 2808 { 2809 struct alc_spec *spec = codec->spec; 2810 hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0]; 2811 bool hp_pin_sense; 2812 int coef78; 2813 2814 if (!hp_pin) { 2815 alc269_shutup(codec); 2816 return; 2817 } 2818 2819 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 2820 coef78 = alc_read_coef_idx(codec, 0x78); 2821 alc_write_coef_idx(codec, 0x78, 0x9004); 2822 2823 if (hp_pin_sense) 2824 msleep(2); 2825 2826 snd_hda_codec_write(codec, hp_pin, 0, 2827 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 2828 2829 if (hp_pin_sense) 2830 msleep(85); 2831 2832 snd_hda_codec_write(codec, hp_pin, 0, 2833 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 2834 2835 if (hp_pin_sense) 2836 msleep(100); 2837 2838 alc_auto_setup_eapd(codec, false); 2839 snd_hda_shutup_pins(codec); 2840 alc_write_coef_idx(codec, 0x78, coef78); 2841 } 2842 2843 static struct coef_fw alc283_coefs[] = { 2844 WRITE_COEF(0x03, 0x0002), /* Power Down Control */ 2845 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */ 2846 WRITE_COEF(0x07, 0x0200), /* DMIC control */ 2847 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */ 2848 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */ 2849 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */ 2850 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */ 2851 WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */ 2852 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */ 2853 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */ 2854 WRITE_COEF(0x3a, 0x0), /* Class D test 4 */ 2855 UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */ 2856 WRITE_COEF(0x22, 0xa0c0), /* ANC */ 2857 UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */ 2858 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */ 2859 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */ 2860 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */ 2861 WRITE_COEF(0x2e, 0x2902), /* PLL */ 2862 WRITE_COEF(0x33, 0xa080), /* capless control 2 */ 2863 WRITE_COEF(0x34, 0x3400), /* capless control 3 */ 2864 WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */ 2865 WRITE_COEF(0x36, 0x0), /* capless control 5 */ 2866 UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */ 2867 WRITE_COEF(0x39, 0x110a), /* class D test 3 */ 2868 UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */ 2869 WRITE_COEF(0x3c, 0x0014), /* class D test 6 */ 2870 WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */ 2871 UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */ 2872 WRITE_COEF(0x49, 0x0), /* test mode */ 2873 UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */ 2874 UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */ 2875 WRITE_COEF(0x37, 0xfc06), /* Class D amp control */ 2876 UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */ 2877 {} 2878 }; 2879 2880 static void alc283_restore_default_value(struct hda_codec *codec) 2881 { 2882 alc_process_coef_fw(codec, alc283_coefs); 2883 } 2884 2885 static void alc283_init(struct hda_codec *codec) 2886 { 2887 struct alc_spec *spec = codec->spec; 2888 hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0]; 2889 bool hp_pin_sense; 2890 2891 if (!spec->gen.autocfg.hp_outs) { 2892 if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT) 2893 hp_pin = spec->gen.autocfg.line_out_pins[0]; 2894 } 2895 2896 alc283_restore_default_value(codec); 2897 2898 if (!hp_pin) 2899 return; 2900 2901 msleep(30); 2902 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 2903 2904 /* Index 0x43 Direct Drive HP AMP LPM Control 1 */ 2905 /* Headphone capless set to high power mode */ 2906 alc_write_coef_idx(codec, 0x43, 0x9004); 2907 2908 snd_hda_codec_write(codec, hp_pin, 0, 2909 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 2910 2911 if (hp_pin_sense) 2912 msleep(85); 2913 2914 snd_hda_codec_write(codec, hp_pin, 0, 2915 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 2916 2917 if (hp_pin_sense) 2918 msleep(85); 2919 /* Index 0x46 Combo jack auto switch control 2 */ 2920 /* 3k pull low control for Headset jack. */ 2921 alc_update_coef_idx(codec, 0x46, 3 << 12, 0); 2922 /* Headphone capless set to normal mode */ 2923 alc_write_coef_idx(codec, 0x43, 0x9614); 2924 } 2925 2926 static void alc283_shutup(struct hda_codec *codec) 2927 { 2928 struct alc_spec *spec = codec->spec; 2929 hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0]; 2930 bool hp_pin_sense; 2931 2932 if (!spec->gen.autocfg.hp_outs) { 2933 if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT) 2934 hp_pin = spec->gen.autocfg.line_out_pins[0]; 2935 } 2936 2937 if (!hp_pin) { 2938 alc269_shutup(codec); 2939 return; 2940 } 2941 2942 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin); 2943 2944 alc_write_coef_idx(codec, 0x43, 0x9004); 2945 2946 /*depop hp during suspend*/ 2947 alc_write_coef_idx(codec, 0x06, 0x2100); 2948 2949 snd_hda_codec_write(codec, hp_pin, 0, 2950 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 2951 2952 if (hp_pin_sense) 2953 msleep(100); 2954 2955 snd_hda_codec_write(codec, hp_pin, 0, 2956 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0); 2957 2958 alc_update_coef_idx(codec, 0x46, 0, 3 << 12); 2959 2960 if (hp_pin_sense) 2961 msleep(100); 2962 alc_auto_setup_eapd(codec, false); 2963 snd_hda_shutup_pins(codec); 2964 alc_write_coef_idx(codec, 0x43, 0x9614); 2965 } 2966 2967 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg, 2968 unsigned int val) 2969 { 2970 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1); 2971 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */ 2972 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */ 2973 } 2974 2975 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg) 2976 { 2977 unsigned int val; 2978 2979 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1); 2980 val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0) 2981 & 0xffff; 2982 val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0) 2983 << 16; 2984 return val; 2985 } 2986 2987 static void alc5505_dsp_halt(struct hda_codec *codec) 2988 { 2989 unsigned int val; 2990 2991 alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */ 2992 alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */ 2993 alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */ 2994 alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */ 2995 alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */ 2996 alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */ 2997 alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */ 2998 val = alc5505_coef_get(codec, 0x6220); 2999 alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */ 3000 } 3001 3002 static void alc5505_dsp_back_from_halt(struct hda_codec *codec) 3003 { 3004 alc5505_coef_set(codec, 0x61b8, 0x04133302); 3005 alc5505_coef_set(codec, 0x61b0, 0x00005b16); 3006 alc5505_coef_set(codec, 0x61b4, 0x040a2b02); 3007 alc5505_coef_set(codec, 0x6230, 0xf80d4011); 3008 alc5505_coef_set(codec, 0x6220, 0x2002010f); 3009 alc5505_coef_set(codec, 0x880c, 0x00000004); 3010 } 3011 3012 static void alc5505_dsp_init(struct hda_codec *codec) 3013 { 3014 unsigned int val; 3015 3016 alc5505_dsp_halt(codec); 3017 alc5505_dsp_back_from_halt(codec); 3018 alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */ 3019 alc5505_coef_set(codec, 0x61b0, 0x5b16); 3020 alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */ 3021 alc5505_coef_set(codec, 0x61b4, 0x04132b02); 3022 alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/ 3023 alc5505_coef_set(codec, 0x61b8, 0x041f3302); 3024 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */ 3025 alc5505_coef_set(codec, 0x61b8, 0x041b3302); 3026 alc5505_coef_set(codec, 0x61b8, 0x04173302); 3027 alc5505_coef_set(codec, 0x61b8, 0x04163302); 3028 alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */ 3029 alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */ 3030 alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */ 3031 3032 val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */ 3033 if (val <= 3) 3034 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */ 3035 else 3036 alc5505_coef_set(codec, 0x6220, 0x6002018f); 3037 3038 alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/ 3039 alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */ 3040 alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */ 3041 alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */ 3042 alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */ 3043 alc5505_coef_set(codec, 0x880c, 0x00000003); 3044 alc5505_coef_set(codec, 0x880c, 0x00000010); 3045 3046 #ifdef HALT_REALTEK_ALC5505 3047 alc5505_dsp_halt(codec); 3048 #endif 3049 } 3050 3051 #ifdef HALT_REALTEK_ALC5505 3052 #define alc5505_dsp_suspend(codec) /* NOP */ 3053 #define alc5505_dsp_resume(codec) /* NOP */ 3054 #else 3055 #define alc5505_dsp_suspend(codec) alc5505_dsp_halt(codec) 3056 #define alc5505_dsp_resume(codec) alc5505_dsp_back_from_halt(codec) 3057 #endif 3058 3059 #ifdef CONFIG_PM 3060 static int alc269_suspend(struct hda_codec *codec) 3061 { 3062 struct alc_spec *spec = codec->spec; 3063 3064 if (spec->has_alc5505_dsp) 3065 alc5505_dsp_suspend(codec); 3066 return alc_suspend(codec); 3067 } 3068 3069 static int alc269_resume(struct hda_codec *codec) 3070 { 3071 struct alc_spec *spec = codec->spec; 3072 3073 if (spec->codec_variant == ALC269_TYPE_ALC269VB) 3074 alc269vb_toggle_power_output(codec, 0); 3075 if (spec->codec_variant == ALC269_TYPE_ALC269VB && 3076 (alc_get_coef0(codec) & 0x00ff) == 0x018) { 3077 msleep(150); 3078 } 3079 3080 codec->patch_ops.init(codec); 3081 3082 if (spec->codec_variant == ALC269_TYPE_ALC269VB) 3083 alc269vb_toggle_power_output(codec, 1); 3084 if (spec->codec_variant == ALC269_TYPE_ALC269VB && 3085 (alc_get_coef0(codec) & 0x00ff) == 0x017) { 3086 msleep(200); 3087 } 3088 3089 regcache_sync(codec->core.regmap); 3090 hda_call_check_power_status(codec, 0x01); 3091 3092 /* on some machine, the BIOS will clear the codec gpio data when enter 3093 * suspend, and won't restore the data after resume, so we restore it 3094 * in the driver. 3095 */ 3096 if (spec->gpio_led) 3097 snd_hda_codec_write(codec, codec->core.afg, 0, AC_VERB_SET_GPIO_DATA, 3098 spec->gpio_led); 3099 3100 if (spec->has_alc5505_dsp) 3101 alc5505_dsp_resume(codec); 3102 3103 return 0; 3104 } 3105 #endif /* CONFIG_PM */ 3106 3107 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec, 3108 const struct hda_fixup *fix, int action) 3109 { 3110 struct alc_spec *spec = codec->spec; 3111 3112 if (action == HDA_FIXUP_ACT_PRE_PROBE) 3113 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 3114 } 3115 3116 static void alc269_fixup_hweq(struct hda_codec *codec, 3117 const struct hda_fixup *fix, int action) 3118 { 3119 if (action == HDA_FIXUP_ACT_INIT) 3120 alc_update_coef_idx(codec, 0x1e, 0, 0x80); 3121 } 3122 3123 static void alc269_fixup_headset_mic(struct hda_codec *codec, 3124 const struct hda_fixup *fix, int action) 3125 { 3126 struct alc_spec *spec = codec->spec; 3127 3128 if (action == HDA_FIXUP_ACT_PRE_PROBE) 3129 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 3130 } 3131 3132 static void alc271_fixup_dmic(struct hda_codec *codec, 3133 const struct hda_fixup *fix, int action) 3134 { 3135 static const struct hda_verb verbs[] = { 3136 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d}, 3137 {0x20, AC_VERB_SET_PROC_COEF, 0x4000}, 3138 {} 3139 }; 3140 unsigned int cfg; 3141 3142 if (strcmp(codec->core.chip_name, "ALC271X") && 3143 strcmp(codec->core.chip_name, "ALC269VB")) 3144 return; 3145 cfg = snd_hda_codec_get_pincfg(codec, 0x12); 3146 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED) 3147 snd_hda_sequence_write(codec, verbs); 3148 } 3149 3150 static void alc269_fixup_pcm_44k(struct hda_codec *codec, 3151 const struct hda_fixup *fix, int action) 3152 { 3153 struct alc_spec *spec = codec->spec; 3154 3155 if (action != HDA_FIXUP_ACT_PROBE) 3156 return; 3157 3158 /* Due to a hardware problem on Lenovo Ideadpad, we need to 3159 * fix the sample rate of analog I/O to 44.1kHz 3160 */ 3161 spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback; 3162 spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture; 3163 } 3164 3165 static void alc269_fixup_stereo_dmic(struct hda_codec *codec, 3166 const struct hda_fixup *fix, int action) 3167 { 3168 /* The digital-mic unit sends PDM (differential signal) instead of 3169 * the standard PCM, thus you can't record a valid mono stream as is. 3170 * Below is a workaround specific to ALC269 to control the dmic 3171 * signal source as mono. 3172 */ 3173 if (action == HDA_FIXUP_ACT_INIT) 3174 alc_update_coef_idx(codec, 0x07, 0, 0x80); 3175 } 3176 3177 static void alc269_quanta_automute(struct hda_codec *codec) 3178 { 3179 snd_hda_gen_update_outputs(codec); 3180 3181 alc_write_coef_idx(codec, 0x0c, 0x680); 3182 alc_write_coef_idx(codec, 0x0c, 0x480); 3183 } 3184 3185 static void alc269_fixup_quanta_mute(struct hda_codec *codec, 3186 const struct hda_fixup *fix, int action) 3187 { 3188 struct alc_spec *spec = codec->spec; 3189 if (action != HDA_FIXUP_ACT_PROBE) 3190 return; 3191 spec->gen.automute_hook = alc269_quanta_automute; 3192 } 3193 3194 static void alc269_x101_hp_automute_hook(struct hda_codec *codec, 3195 struct hda_jack_callback *jack) 3196 { 3197 struct alc_spec *spec = codec->spec; 3198 int vref; 3199 msleep(200); 3200 snd_hda_gen_hp_automute(codec, jack); 3201 3202 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0; 3203 msleep(100); 3204 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 3205 vref); 3206 msleep(500); 3207 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 3208 vref); 3209 } 3210 3211 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec, 3212 const struct hda_fixup *fix, int action) 3213 { 3214 struct alc_spec *spec = codec->spec; 3215 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 3216 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 3217 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook; 3218 } 3219 } 3220 3221 3222 /* update mute-LED according to the speaker mute state via mic VREF pin */ 3223 static void alc269_fixup_mic_mute_hook(void *private_data, int enabled) 3224 { 3225 struct hda_codec *codec = private_data; 3226 struct alc_spec *spec = codec->spec; 3227 unsigned int pinval; 3228 3229 if (spec->mute_led_polarity) 3230 enabled = !enabled; 3231 pinval = snd_hda_codec_get_pin_target(codec, spec->mute_led_nid); 3232 pinval &= ~AC_PINCTL_VREFEN; 3233 pinval |= enabled ? AC_PINCTL_VREF_HIZ : AC_PINCTL_VREF_80; 3234 if (spec->mute_led_nid) 3235 snd_hda_set_pin_ctl_cache(codec, spec->mute_led_nid, pinval); 3236 } 3237 3238 /* Make sure the led works even in runtime suspend */ 3239 static unsigned int led_power_filter(struct hda_codec *codec, 3240 hda_nid_t nid, 3241 unsigned int power_state) 3242 { 3243 struct alc_spec *spec = codec->spec; 3244 3245 if (power_state != AC_PWRST_D3 || nid == 0 || 3246 (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid)) 3247 return power_state; 3248 3249 /* Set pin ctl again, it might have just been set to 0 */ 3250 snd_hda_set_pin_ctl(codec, nid, 3251 snd_hda_codec_get_pin_target(codec, nid)); 3252 3253 return snd_hda_gen_path_power_filter(codec, nid, power_state); 3254 } 3255 3256 static void alc269_fixup_hp_mute_led(struct hda_codec *codec, 3257 const struct hda_fixup *fix, int action) 3258 { 3259 struct alc_spec *spec = codec->spec; 3260 const struct dmi_device *dev = NULL; 3261 3262 if (action != HDA_FIXUP_ACT_PRE_PROBE) 3263 return; 3264 3265 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) { 3266 int pol, pin; 3267 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2) 3268 continue; 3269 if (pin < 0x0a || pin >= 0x10) 3270 break; 3271 spec->mute_led_polarity = pol; 3272 spec->mute_led_nid = pin - 0x0a + 0x18; 3273 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook; 3274 spec->gen.vmaster_mute_enum = 1; 3275 codec->power_filter = led_power_filter; 3276 codec_dbg(codec, 3277 "Detected mute LED for %x:%d\n", spec->mute_led_nid, 3278 spec->mute_led_polarity); 3279 break; 3280 } 3281 } 3282 3283 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec, 3284 const struct hda_fixup *fix, int action) 3285 { 3286 struct alc_spec *spec = codec->spec; 3287 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 3288 spec->mute_led_polarity = 0; 3289 spec->mute_led_nid = 0x18; 3290 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook; 3291 spec->gen.vmaster_mute_enum = 1; 3292 codec->power_filter = led_power_filter; 3293 } 3294 } 3295 3296 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec, 3297 const struct hda_fixup *fix, int action) 3298 { 3299 struct alc_spec *spec = codec->spec; 3300 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 3301 spec->mute_led_polarity = 0; 3302 spec->mute_led_nid = 0x19; 3303 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook; 3304 spec->gen.vmaster_mute_enum = 1; 3305 codec->power_filter = led_power_filter; 3306 } 3307 } 3308 3309 /* update LED status via GPIO */ 3310 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask, 3311 bool enabled) 3312 { 3313 struct alc_spec *spec = codec->spec; 3314 unsigned int oldval = spec->gpio_led; 3315 3316 if (spec->mute_led_polarity) 3317 enabled = !enabled; 3318 3319 if (enabled) 3320 spec->gpio_led &= ~mask; 3321 else 3322 spec->gpio_led |= mask; 3323 if (spec->gpio_led != oldval) 3324 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 3325 spec->gpio_led); 3326 } 3327 3328 /* turn on/off mute LED via GPIO per vmaster hook */ 3329 static void alc_fixup_gpio_mute_hook(void *private_data, int enabled) 3330 { 3331 struct hda_codec *codec = private_data; 3332 struct alc_spec *spec = codec->spec; 3333 3334 alc_update_gpio_led(codec, spec->gpio_mute_led_mask, enabled); 3335 } 3336 3337 /* turn on/off mic-mute LED via GPIO per capture hook */ 3338 static void alc_fixup_gpio_mic_mute_hook(struct hda_codec *codec, 3339 struct snd_kcontrol *kcontrol, 3340 struct snd_ctl_elem_value *ucontrol) 3341 { 3342 struct alc_spec *spec = codec->spec; 3343 3344 if (ucontrol) 3345 alc_update_gpio_led(codec, spec->gpio_mic_led_mask, 3346 ucontrol->value.integer.value[0] || 3347 ucontrol->value.integer.value[1]); 3348 } 3349 3350 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec, 3351 const struct hda_fixup *fix, int action) 3352 { 3353 struct alc_spec *spec = codec->spec; 3354 static const struct hda_verb gpio_init[] = { 3355 { 0x01, AC_VERB_SET_GPIO_MASK, 0x18 }, 3356 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 }, 3357 {} 3358 }; 3359 3360 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 3361 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook; 3362 spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook; 3363 spec->gpio_led = 0; 3364 spec->mute_led_polarity = 0; 3365 spec->gpio_mute_led_mask = 0x08; 3366 spec->gpio_mic_led_mask = 0x10; 3367 snd_hda_add_verbs(codec, gpio_init); 3368 } 3369 } 3370 3371 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec, 3372 const struct hda_fixup *fix, int action) 3373 { 3374 struct alc_spec *spec = codec->spec; 3375 static const struct hda_verb gpio_init[] = { 3376 { 0x01, AC_VERB_SET_GPIO_MASK, 0x22 }, 3377 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x22 }, 3378 {} 3379 }; 3380 3381 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 3382 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook; 3383 spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook; 3384 spec->gpio_led = 0; 3385 spec->mute_led_polarity = 0; 3386 spec->gpio_mute_led_mask = 0x02; 3387 spec->gpio_mic_led_mask = 0x20; 3388 snd_hda_add_verbs(codec, gpio_init); 3389 } 3390 } 3391 3392 /* turn on/off mic-mute LED per capture hook */ 3393 static void alc269_fixup_hp_cap_mic_mute_hook(struct hda_codec *codec, 3394 struct snd_kcontrol *kcontrol, 3395 struct snd_ctl_elem_value *ucontrol) 3396 { 3397 struct alc_spec *spec = codec->spec; 3398 unsigned int pinval, enable, disable; 3399 3400 pinval = snd_hda_codec_get_pin_target(codec, spec->cap_mute_led_nid); 3401 pinval &= ~AC_PINCTL_VREFEN; 3402 enable = pinval | AC_PINCTL_VREF_80; 3403 disable = pinval | AC_PINCTL_VREF_HIZ; 3404 3405 if (!ucontrol) 3406 return; 3407 3408 if (ucontrol->value.integer.value[0] || 3409 ucontrol->value.integer.value[1]) 3410 pinval = disable; 3411 else 3412 pinval = enable; 3413 3414 if (spec->cap_mute_led_nid) 3415 snd_hda_set_pin_ctl_cache(codec, spec->cap_mute_led_nid, pinval); 3416 } 3417 3418 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec, 3419 const struct hda_fixup *fix, int action) 3420 { 3421 struct alc_spec *spec = codec->spec; 3422 static const struct hda_verb gpio_init[] = { 3423 { 0x01, AC_VERB_SET_GPIO_MASK, 0x08 }, 3424 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x08 }, 3425 {} 3426 }; 3427 3428 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 3429 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook; 3430 spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook; 3431 spec->gpio_led = 0; 3432 spec->mute_led_polarity = 0; 3433 spec->gpio_mute_led_mask = 0x08; 3434 spec->cap_mute_led_nid = 0x18; 3435 snd_hda_add_verbs(codec, gpio_init); 3436 codec->power_filter = led_power_filter; 3437 } 3438 } 3439 3440 static void alc280_fixup_hp_gpio4(struct hda_codec *codec, 3441 const struct hda_fixup *fix, int action) 3442 { 3443 /* Like hp_gpio_mic1_led, but also needs GPIO4 low to enable headphone amp */ 3444 struct alc_spec *spec = codec->spec; 3445 static const struct hda_verb gpio_init[] = { 3446 { 0x01, AC_VERB_SET_GPIO_MASK, 0x18 }, 3447 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 }, 3448 {} 3449 }; 3450 3451 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 3452 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook; 3453 spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook; 3454 spec->gpio_led = 0; 3455 spec->mute_led_polarity = 0; 3456 spec->gpio_mute_led_mask = 0x08; 3457 spec->cap_mute_led_nid = 0x18; 3458 snd_hda_add_verbs(codec, gpio_init); 3459 codec->power_filter = led_power_filter; 3460 } 3461 } 3462 3463 static void gpio2_mic_hotkey_event(struct hda_codec *codec, 3464 struct hda_jack_callback *event) 3465 { 3466 struct alc_spec *spec = codec->spec; 3467 3468 /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore 3469 send both key on and key off event for every interrupt. */ 3470 input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1); 3471 input_sync(spec->kb_dev); 3472 input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0); 3473 input_sync(spec->kb_dev); 3474 } 3475 3476 static int alc_register_micmute_input_device(struct hda_codec *codec) 3477 { 3478 struct alc_spec *spec = codec->spec; 3479 int i; 3480 3481 spec->kb_dev = input_allocate_device(); 3482 if (!spec->kb_dev) { 3483 codec_err(codec, "Out of memory (input_allocate_device)\n"); 3484 return -ENOMEM; 3485 } 3486 3487 spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE; 3488 3489 spec->kb_dev->name = "Microphone Mute Button"; 3490 spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY); 3491 spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]); 3492 spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map); 3493 spec->kb_dev->keycode = spec->alc_mute_keycode_map; 3494 for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++) 3495 set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit); 3496 3497 if (input_register_device(spec->kb_dev)) { 3498 codec_err(codec, "input_register_device failed\n"); 3499 input_free_device(spec->kb_dev); 3500 spec->kb_dev = NULL; 3501 return -ENOMEM; 3502 } 3503 3504 return 0; 3505 } 3506 3507 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec, 3508 const struct hda_fixup *fix, int action) 3509 { 3510 /* GPIO1 = set according to SKU external amp 3511 GPIO2 = mic mute hotkey 3512 GPIO3 = mute LED 3513 GPIO4 = mic mute LED */ 3514 static const struct hda_verb gpio_init[] = { 3515 { 0x01, AC_VERB_SET_GPIO_MASK, 0x1e }, 3516 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x1a }, 3517 { 0x01, AC_VERB_SET_GPIO_DATA, 0x02 }, 3518 {} 3519 }; 3520 3521 struct alc_spec *spec = codec->spec; 3522 3523 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 3524 if (alc_register_micmute_input_device(codec) != 0) 3525 return; 3526 3527 snd_hda_add_verbs(codec, gpio_init); 3528 snd_hda_codec_write_cache(codec, codec->core.afg, 0, 3529 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04); 3530 snd_hda_jack_detect_enable_callback(codec, codec->core.afg, 3531 gpio2_mic_hotkey_event); 3532 3533 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook; 3534 spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook; 3535 spec->gpio_led = 0; 3536 spec->mute_led_polarity = 0; 3537 spec->gpio_mute_led_mask = 0x08; 3538 spec->gpio_mic_led_mask = 0x10; 3539 return; 3540 } 3541 3542 if (!spec->kb_dev) 3543 return; 3544 3545 switch (action) { 3546 case HDA_FIXUP_ACT_PROBE: 3547 spec->init_amp = ALC_INIT_DEFAULT; 3548 break; 3549 case HDA_FIXUP_ACT_FREE: 3550 input_unregister_device(spec->kb_dev); 3551 spec->kb_dev = NULL; 3552 } 3553 } 3554 3555 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec, 3556 const struct hda_fixup *fix, int action) 3557 { 3558 /* Line2 = mic mute hotkey 3559 GPIO2 = mic mute LED */ 3560 static const struct hda_verb gpio_init[] = { 3561 { 0x01, AC_VERB_SET_GPIO_MASK, 0x04 }, 3562 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04 }, 3563 {} 3564 }; 3565 3566 struct alc_spec *spec = codec->spec; 3567 3568 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 3569 if (alc_register_micmute_input_device(codec) != 0) 3570 return; 3571 3572 snd_hda_add_verbs(codec, gpio_init); 3573 snd_hda_jack_detect_enable_callback(codec, 0x1b, 3574 gpio2_mic_hotkey_event); 3575 3576 spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook; 3577 spec->gpio_led = 0; 3578 spec->mute_led_polarity = 0; 3579 spec->gpio_mic_led_mask = 0x04; 3580 return; 3581 } 3582 3583 if (!spec->kb_dev) 3584 return; 3585 3586 switch (action) { 3587 case HDA_FIXUP_ACT_PROBE: 3588 spec->init_amp = ALC_INIT_DEFAULT; 3589 break; 3590 case HDA_FIXUP_ACT_FREE: 3591 input_unregister_device(spec->kb_dev); 3592 spec->kb_dev = NULL; 3593 } 3594 } 3595 3596 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec, 3597 const struct hda_fixup *fix, int action) 3598 { 3599 struct alc_spec *spec = codec->spec; 3600 3601 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 3602 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook; 3603 spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook; 3604 spec->mute_led_polarity = 0; 3605 spec->mute_led_nid = 0x1a; 3606 spec->cap_mute_led_nid = 0x18; 3607 spec->gen.vmaster_mute_enum = 1; 3608 codec->power_filter = led_power_filter; 3609 } 3610 } 3611 3612 static void alc_headset_mode_unplugged(struct hda_codec *codec) 3613 { 3614 static struct coef_fw coef0255[] = { 3615 WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */ 3616 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */ 3617 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/ 3618 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */ 3619 WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */ 3620 {} 3621 }; 3622 static struct coef_fw coef0233[] = { 3623 WRITE_COEF(0x1b, 0x0c0b), 3624 WRITE_COEF(0x45, 0xc429), 3625 UPDATE_COEF(0x35, 0x4000, 0), 3626 WRITE_COEF(0x06, 0x2104), 3627 WRITE_COEF(0x1a, 0x0001), 3628 WRITE_COEF(0x26, 0x0004), 3629 WRITE_COEF(0x32, 0x42a3), 3630 {} 3631 }; 3632 static struct coef_fw coef0288[] = { 3633 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), 3634 UPDATE_COEF(0x50, 0x2000, 0x2000), 3635 UPDATE_COEF(0x56, 0x0006, 0x0006), 3636 UPDATE_COEF(0x66, 0x0008, 0), 3637 UPDATE_COEF(0x67, 0x2000, 0), 3638 {} 3639 }; 3640 static struct coef_fw coef0292[] = { 3641 WRITE_COEF(0x76, 0x000e), 3642 WRITE_COEF(0x6c, 0x2400), 3643 WRITE_COEF(0x18, 0x7308), 3644 WRITE_COEF(0x6b, 0xc429), 3645 {} 3646 }; 3647 static struct coef_fw coef0293[] = { 3648 UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */ 3649 UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */ 3650 UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */ 3651 UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */ 3652 WRITE_COEF(0x45, 0xc429), /* Set to TRS type */ 3653 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */ 3654 {} 3655 }; 3656 static struct coef_fw coef0668[] = { 3657 WRITE_COEF(0x15, 0x0d40), 3658 WRITE_COEF(0xb7, 0x802b), 3659 {} 3660 }; 3661 3662 switch (codec->core.vendor_id) { 3663 case 0x10ec0255: 3664 case 0x10ec0256: 3665 alc_process_coef_fw(codec, coef0255); 3666 break; 3667 case 0x10ec0233: 3668 case 0x10ec0283: 3669 alc_process_coef_fw(codec, coef0233); 3670 break; 3671 case 0x10ec0286: 3672 case 0x10ec0288: 3673 case 0x10ec0298: 3674 alc_process_coef_fw(codec, coef0288); 3675 break; 3676 case 0x10ec0292: 3677 alc_process_coef_fw(codec, coef0292); 3678 break; 3679 case 0x10ec0293: 3680 alc_process_coef_fw(codec, coef0293); 3681 break; 3682 case 0x10ec0668: 3683 alc_process_coef_fw(codec, coef0668); 3684 break; 3685 } 3686 codec_dbg(codec, "Headset jack set to unplugged mode.\n"); 3687 } 3688 3689 3690 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin, 3691 hda_nid_t mic_pin) 3692 { 3693 static struct coef_fw coef0255[] = { 3694 WRITE_COEFEX(0x57, 0x03, 0x8aa6), 3695 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */ 3696 {} 3697 }; 3698 static struct coef_fw coef0233[] = { 3699 UPDATE_COEF(0x35, 0, 1<<14), 3700 WRITE_COEF(0x06, 0x2100), 3701 WRITE_COEF(0x1a, 0x0021), 3702 WRITE_COEF(0x26, 0x008c), 3703 {} 3704 }; 3705 static struct coef_fw coef0288[] = { 3706 UPDATE_COEF(0x50, 0x2000, 0), 3707 UPDATE_COEF(0x56, 0x0006, 0), 3708 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), 3709 UPDATE_COEF(0x66, 0x0008, 0x0008), 3710 UPDATE_COEF(0x67, 0x2000, 0x2000), 3711 {} 3712 }; 3713 static struct coef_fw coef0292[] = { 3714 WRITE_COEF(0x19, 0xa208), 3715 WRITE_COEF(0x2e, 0xacf0), 3716 {} 3717 }; 3718 static struct coef_fw coef0293[] = { 3719 UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */ 3720 UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */ 3721 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */ 3722 {} 3723 }; 3724 static struct coef_fw coef0688[] = { 3725 WRITE_COEF(0xb7, 0x802b), 3726 WRITE_COEF(0xb5, 0x1040), 3727 UPDATE_COEF(0xc3, 0, 1<<12), 3728 {} 3729 }; 3730 3731 switch (codec->core.vendor_id) { 3732 case 0x10ec0255: 3733 case 0x10ec0256: 3734 alc_write_coef_idx(codec, 0x45, 0xc489); 3735 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 3736 alc_process_coef_fw(codec, coef0255); 3737 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 3738 break; 3739 case 0x10ec0233: 3740 case 0x10ec0283: 3741 alc_write_coef_idx(codec, 0x45, 0xc429); 3742 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 3743 alc_process_coef_fw(codec, coef0233); 3744 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 3745 break; 3746 case 0x10ec0286: 3747 case 0x10ec0288: 3748 case 0x10ec0298: 3749 alc_update_coef_idx(codec, 0x4f, 0x000c, 0); 3750 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 3751 alc_process_coef_fw(codec, coef0288); 3752 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 3753 break; 3754 case 0x10ec0292: 3755 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 3756 alc_process_coef_fw(codec, coef0292); 3757 break; 3758 case 0x10ec0293: 3759 /* Set to TRS mode */ 3760 alc_write_coef_idx(codec, 0x45, 0xc429); 3761 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 3762 alc_process_coef_fw(codec, coef0293); 3763 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 3764 break; 3765 case 0x10ec0662: 3766 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 3767 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 3768 break; 3769 case 0x10ec0668: 3770 alc_write_coef_idx(codec, 0x11, 0x0001); 3771 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); 3772 alc_process_coef_fw(codec, coef0688); 3773 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50); 3774 break; 3775 } 3776 codec_dbg(codec, "Headset jack set to mic-in mode.\n"); 3777 } 3778 3779 static void alc_headset_mode_default(struct hda_codec *codec) 3780 { 3781 static struct coef_fw coef0255[] = { 3782 WRITE_COEF(0x45, 0xc089), 3783 WRITE_COEF(0x45, 0xc489), 3784 WRITE_COEFEX(0x57, 0x03, 0x8ea6), 3785 WRITE_COEF(0x49, 0x0049), 3786 {} 3787 }; 3788 static struct coef_fw coef0233[] = { 3789 WRITE_COEF(0x06, 0x2100), 3790 WRITE_COEF(0x32, 0x4ea3), 3791 {} 3792 }; 3793 static struct coef_fw coef0288[] = { 3794 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */ 3795 UPDATE_COEF(0x50, 0x2000, 0x2000), 3796 UPDATE_COEF(0x56, 0x0006, 0x0006), 3797 UPDATE_COEF(0x66, 0x0008, 0), 3798 UPDATE_COEF(0x67, 0x2000, 0), 3799 {} 3800 }; 3801 static struct coef_fw coef0292[] = { 3802 WRITE_COEF(0x76, 0x000e), 3803 WRITE_COEF(0x6c, 0x2400), 3804 WRITE_COEF(0x6b, 0xc429), 3805 WRITE_COEF(0x18, 0x7308), 3806 {} 3807 }; 3808 static struct coef_fw coef0293[] = { 3809 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */ 3810 WRITE_COEF(0x45, 0xC429), /* Set to TRS type */ 3811 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */ 3812 {} 3813 }; 3814 static struct coef_fw coef0688[] = { 3815 WRITE_COEF(0x11, 0x0041), 3816 WRITE_COEF(0x15, 0x0d40), 3817 WRITE_COEF(0xb7, 0x802b), 3818 {} 3819 }; 3820 3821 switch (codec->core.vendor_id) { 3822 case 0x10ec0255: 3823 case 0x10ec0256: 3824 alc_process_coef_fw(codec, coef0255); 3825 break; 3826 case 0x10ec0233: 3827 case 0x10ec0283: 3828 alc_process_coef_fw(codec, coef0233); 3829 break; 3830 case 0x10ec0286: 3831 case 0x10ec0288: 3832 case 0x10ec0298: 3833 alc_process_coef_fw(codec, coef0288); 3834 break; 3835 case 0x10ec0292: 3836 alc_process_coef_fw(codec, coef0292); 3837 break; 3838 case 0x10ec0293: 3839 alc_process_coef_fw(codec, coef0293); 3840 break; 3841 case 0x10ec0668: 3842 alc_process_coef_fw(codec, coef0688); 3843 break; 3844 } 3845 codec_dbg(codec, "Headset jack set to headphone (default) mode.\n"); 3846 } 3847 3848 /* Iphone type */ 3849 static void alc_headset_mode_ctia(struct hda_codec *codec) 3850 { 3851 static struct coef_fw coef0255[] = { 3852 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */ 3853 WRITE_COEF(0x1b, 0x0c2b), 3854 WRITE_COEFEX(0x57, 0x03, 0x8ea6), 3855 {} 3856 }; 3857 static struct coef_fw coef0233[] = { 3858 WRITE_COEF(0x45, 0xd429), 3859 WRITE_COEF(0x1b, 0x0c2b), 3860 WRITE_COEF(0x32, 0x4ea3), 3861 {} 3862 }; 3863 static struct coef_fw coef0288[] = { 3864 UPDATE_COEF(0x50, 0x2000, 0x2000), 3865 UPDATE_COEF(0x56, 0x0006, 0x0006), 3866 UPDATE_COEF(0x66, 0x0008, 0), 3867 UPDATE_COEF(0x67, 0x2000, 0), 3868 {} 3869 }; 3870 static struct coef_fw coef0292[] = { 3871 WRITE_COEF(0x6b, 0xd429), 3872 WRITE_COEF(0x76, 0x0008), 3873 WRITE_COEF(0x18, 0x7388), 3874 {} 3875 }; 3876 static struct coef_fw coef0293[] = { 3877 WRITE_COEF(0x45, 0xd429), /* Set to ctia type */ 3878 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */ 3879 {} 3880 }; 3881 static struct coef_fw coef0688[] = { 3882 WRITE_COEF(0x11, 0x0001), 3883 WRITE_COEF(0x15, 0x0d60), 3884 WRITE_COEF(0xc3, 0x0000), 3885 {} 3886 }; 3887 3888 switch (codec->core.vendor_id) { 3889 case 0x10ec0255: 3890 case 0x10ec0256: 3891 alc_process_coef_fw(codec, coef0255); 3892 break; 3893 case 0x10ec0233: 3894 case 0x10ec0283: 3895 alc_process_coef_fw(codec, coef0233); 3896 break; 3897 case 0x10ec0298: 3898 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);/* Headset output enable */ 3899 /* ALC298 jack type setting is the same with ALC286/ALC288 */ 3900 case 0x10ec0286: 3901 case 0x10ec0288: 3902 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400); 3903 msleep(300); 3904 alc_process_coef_fw(codec, coef0288); 3905 break; 3906 case 0x10ec0292: 3907 alc_process_coef_fw(codec, coef0292); 3908 break; 3909 case 0x10ec0293: 3910 alc_process_coef_fw(codec, coef0293); 3911 break; 3912 case 0x10ec0668: 3913 alc_process_coef_fw(codec, coef0688); 3914 break; 3915 } 3916 codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n"); 3917 } 3918 3919 /* Nokia type */ 3920 static void alc_headset_mode_omtp(struct hda_codec *codec) 3921 { 3922 static struct coef_fw coef0255[] = { 3923 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */ 3924 WRITE_COEF(0x1b, 0x0c2b), 3925 WRITE_COEFEX(0x57, 0x03, 0x8ea6), 3926 {} 3927 }; 3928 static struct coef_fw coef0233[] = { 3929 WRITE_COEF(0x45, 0xe429), 3930 WRITE_COEF(0x1b, 0x0c2b), 3931 WRITE_COEF(0x32, 0x4ea3), 3932 {} 3933 }; 3934 static struct coef_fw coef0288[] = { 3935 UPDATE_COEF(0x50, 0x2000, 0x2000), 3936 UPDATE_COEF(0x56, 0x0006, 0x0006), 3937 UPDATE_COEF(0x66, 0x0008, 0), 3938 UPDATE_COEF(0x67, 0x2000, 0), 3939 {} 3940 }; 3941 static struct coef_fw coef0292[] = { 3942 WRITE_COEF(0x6b, 0xe429), 3943 WRITE_COEF(0x76, 0x0008), 3944 WRITE_COEF(0x18, 0x7388), 3945 {} 3946 }; 3947 static struct coef_fw coef0293[] = { 3948 WRITE_COEF(0x45, 0xe429), /* Set to omtp type */ 3949 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */ 3950 {} 3951 }; 3952 static struct coef_fw coef0688[] = { 3953 WRITE_COEF(0x11, 0x0001), 3954 WRITE_COEF(0x15, 0x0d50), 3955 WRITE_COEF(0xc3, 0x0000), 3956 {} 3957 }; 3958 3959 switch (codec->core.vendor_id) { 3960 case 0x10ec0255: 3961 case 0x10ec0256: 3962 alc_process_coef_fw(codec, coef0255); 3963 break; 3964 case 0x10ec0233: 3965 case 0x10ec0283: 3966 alc_process_coef_fw(codec, coef0233); 3967 break; 3968 case 0x10ec0298: 3969 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */ 3970 /* ALC298 jack type setting is the same with ALC286/ALC288 */ 3971 case 0x10ec0286: 3972 case 0x10ec0288: 3973 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400); 3974 msleep(300); 3975 alc_process_coef_fw(codec, coef0288); 3976 break; 3977 case 0x10ec0292: 3978 alc_process_coef_fw(codec, coef0292); 3979 break; 3980 case 0x10ec0293: 3981 alc_process_coef_fw(codec, coef0293); 3982 break; 3983 case 0x10ec0668: 3984 alc_process_coef_fw(codec, coef0688); 3985 break; 3986 } 3987 codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n"); 3988 } 3989 3990 static void alc_determine_headset_type(struct hda_codec *codec) 3991 { 3992 int val; 3993 bool is_ctia = false; 3994 struct alc_spec *spec = codec->spec; 3995 static struct coef_fw coef0255[] = { 3996 WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/ 3997 WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref 3998 conteol) */ 3999 {} 4000 }; 4001 static struct coef_fw coef0288[] = { 4002 UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */ 4003 {} 4004 }; 4005 static struct coef_fw coef0293[] = { 4006 UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */ 4007 WRITE_COEF(0x45, 0xD429), /* Set to ctia type */ 4008 {} 4009 }; 4010 static struct coef_fw coef0688[] = { 4011 WRITE_COEF(0x11, 0x0001), 4012 WRITE_COEF(0xb7, 0x802b), 4013 WRITE_COEF(0x15, 0x0d60), 4014 WRITE_COEF(0xc3, 0x0c00), 4015 {} 4016 }; 4017 4018 switch (codec->core.vendor_id) { 4019 case 0x10ec0255: 4020 case 0x10ec0256: 4021 alc_process_coef_fw(codec, coef0255); 4022 msleep(300); 4023 val = alc_read_coef_idx(codec, 0x46); 4024 is_ctia = (val & 0x0070) == 0x0070; 4025 break; 4026 case 0x10ec0233: 4027 case 0x10ec0283: 4028 alc_write_coef_idx(codec, 0x45, 0xd029); 4029 msleep(300); 4030 val = alc_read_coef_idx(codec, 0x46); 4031 is_ctia = (val & 0x0070) == 0x0070; 4032 break; 4033 case 0x10ec0298: 4034 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020); /* Headset output enable */ 4035 /* ALC298 check jack type is the same with ALC286/ALC288 */ 4036 case 0x10ec0286: 4037 case 0x10ec0288: 4038 alc_process_coef_fw(codec, coef0288); 4039 msleep(350); 4040 val = alc_read_coef_idx(codec, 0x50); 4041 is_ctia = (val & 0x0070) == 0x0070; 4042 break; 4043 case 0x10ec0292: 4044 alc_write_coef_idx(codec, 0x6b, 0xd429); 4045 msleep(300); 4046 val = alc_read_coef_idx(codec, 0x6c); 4047 is_ctia = (val & 0x001c) == 0x001c; 4048 break; 4049 case 0x10ec0293: 4050 alc_process_coef_fw(codec, coef0293); 4051 msleep(300); 4052 val = alc_read_coef_idx(codec, 0x46); 4053 is_ctia = (val & 0x0070) == 0x0070; 4054 break; 4055 case 0x10ec0668: 4056 alc_process_coef_fw(codec, coef0688); 4057 msleep(300); 4058 val = alc_read_coef_idx(codec, 0xbe); 4059 is_ctia = (val & 0x1c02) == 0x1c02; 4060 break; 4061 } 4062 4063 codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n", 4064 is_ctia ? "yes" : "no"); 4065 spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP; 4066 } 4067 4068 static void alc_update_headset_mode(struct hda_codec *codec) 4069 { 4070 struct alc_spec *spec = codec->spec; 4071 4072 hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]]; 4073 hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0]; 4074 4075 int new_headset_mode; 4076 4077 if (!snd_hda_jack_detect(codec, hp_pin)) 4078 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED; 4079 else if (mux_pin == spec->headset_mic_pin) 4080 new_headset_mode = ALC_HEADSET_MODE_HEADSET; 4081 else if (mux_pin == spec->headphone_mic_pin) 4082 new_headset_mode = ALC_HEADSET_MODE_MIC; 4083 else 4084 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE; 4085 4086 if (new_headset_mode == spec->current_headset_mode) { 4087 snd_hda_gen_update_outputs(codec); 4088 return; 4089 } 4090 4091 switch (new_headset_mode) { 4092 case ALC_HEADSET_MODE_UNPLUGGED: 4093 alc_headset_mode_unplugged(codec); 4094 spec->gen.hp_jack_present = false; 4095 break; 4096 case ALC_HEADSET_MODE_HEADSET: 4097 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN) 4098 alc_determine_headset_type(codec); 4099 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA) 4100 alc_headset_mode_ctia(codec); 4101 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP) 4102 alc_headset_mode_omtp(codec); 4103 spec->gen.hp_jack_present = true; 4104 break; 4105 case ALC_HEADSET_MODE_MIC: 4106 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin); 4107 spec->gen.hp_jack_present = false; 4108 break; 4109 case ALC_HEADSET_MODE_HEADPHONE: 4110 alc_headset_mode_default(codec); 4111 spec->gen.hp_jack_present = true; 4112 break; 4113 } 4114 if (new_headset_mode != ALC_HEADSET_MODE_MIC) { 4115 snd_hda_set_pin_ctl_cache(codec, hp_pin, 4116 AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN); 4117 if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin) 4118 snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin, 4119 PIN_VREFHIZ); 4120 } 4121 spec->current_headset_mode = new_headset_mode; 4122 4123 snd_hda_gen_update_outputs(codec); 4124 } 4125 4126 static void alc_update_headset_mode_hook(struct hda_codec *codec, 4127 struct snd_kcontrol *kcontrol, 4128 struct snd_ctl_elem_value *ucontrol) 4129 { 4130 alc_update_headset_mode(codec); 4131 } 4132 4133 static void alc_update_headset_jack_cb(struct hda_codec *codec, 4134 struct hda_jack_callback *jack) 4135 { 4136 struct alc_spec *spec = codec->spec; 4137 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN; 4138 snd_hda_gen_hp_automute(codec, jack); 4139 } 4140 4141 static void alc_probe_headset_mode(struct hda_codec *codec) 4142 { 4143 int i; 4144 struct alc_spec *spec = codec->spec; 4145 struct auto_pin_cfg *cfg = &spec->gen.autocfg; 4146 4147 /* Find mic pins */ 4148 for (i = 0; i < cfg->num_inputs; i++) { 4149 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin) 4150 spec->headset_mic_pin = cfg->inputs[i].pin; 4151 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin) 4152 spec->headphone_mic_pin = cfg->inputs[i].pin; 4153 } 4154 4155 spec->gen.cap_sync_hook = alc_update_headset_mode_hook; 4156 spec->gen.automute_hook = alc_update_headset_mode; 4157 spec->gen.hp_automute_hook = alc_update_headset_jack_cb; 4158 } 4159 4160 static void alc_fixup_headset_mode(struct hda_codec *codec, 4161 const struct hda_fixup *fix, int action) 4162 { 4163 struct alc_spec *spec = codec->spec; 4164 4165 switch (action) { 4166 case HDA_FIXUP_ACT_PRE_PROBE: 4167 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC; 4168 break; 4169 case HDA_FIXUP_ACT_PROBE: 4170 alc_probe_headset_mode(codec); 4171 break; 4172 case HDA_FIXUP_ACT_INIT: 4173 spec->current_headset_mode = 0; 4174 alc_update_headset_mode(codec); 4175 break; 4176 } 4177 } 4178 4179 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec, 4180 const struct hda_fixup *fix, int action) 4181 { 4182 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4183 struct alc_spec *spec = codec->spec; 4184 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 4185 } 4186 else 4187 alc_fixup_headset_mode(codec, fix, action); 4188 } 4189 4190 static void alc255_set_default_jack_type(struct hda_codec *codec) 4191 { 4192 /* Set to iphone type */ 4193 static struct coef_fw fw[] = { 4194 WRITE_COEF(0x1b, 0x880b), 4195 WRITE_COEF(0x45, 0xd089), 4196 WRITE_COEF(0x1b, 0x080b), 4197 WRITE_COEF(0x46, 0x0004), 4198 WRITE_COEF(0x1b, 0x0c0b), 4199 {} 4200 }; 4201 alc_process_coef_fw(codec, fw); 4202 msleep(30); 4203 } 4204 4205 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec, 4206 const struct hda_fixup *fix, int action) 4207 { 4208 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4209 alc255_set_default_jack_type(codec); 4210 } 4211 alc_fixup_headset_mode(codec, fix, action); 4212 } 4213 4214 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec, 4215 const struct hda_fixup *fix, int action) 4216 { 4217 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4218 struct alc_spec *spec = codec->spec; 4219 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 4220 alc255_set_default_jack_type(codec); 4221 } 4222 else 4223 alc_fixup_headset_mode(codec, fix, action); 4224 } 4225 4226 static void alc288_update_headset_jack_cb(struct hda_codec *codec, 4227 struct hda_jack_callback *jack) 4228 { 4229 struct alc_spec *spec = codec->spec; 4230 int present; 4231 4232 alc_update_headset_jack_cb(codec, jack); 4233 /* Headset Mic enable or disable, only for Dell Dino */ 4234 present = spec->gen.hp_jack_present ? 0x40 : 0; 4235 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 4236 present); 4237 } 4238 4239 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec, 4240 const struct hda_fixup *fix, int action) 4241 { 4242 alc_fixup_headset_mode(codec, fix, action); 4243 if (action == HDA_FIXUP_ACT_PROBE) { 4244 struct alc_spec *spec = codec->spec; 4245 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb; 4246 } 4247 } 4248 4249 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec, 4250 const struct hda_fixup *fix, int action) 4251 { 4252 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4253 struct alc_spec *spec = codec->spec; 4254 spec->gen.auto_mute_via_amp = 1; 4255 } 4256 } 4257 4258 static void alc_no_shutup(struct hda_codec *codec) 4259 { 4260 } 4261 4262 static void alc_fixup_no_shutup(struct hda_codec *codec, 4263 const struct hda_fixup *fix, int action) 4264 { 4265 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4266 struct alc_spec *spec = codec->spec; 4267 spec->shutup = alc_no_shutup; 4268 } 4269 } 4270 4271 static void alc_fixup_disable_aamix(struct hda_codec *codec, 4272 const struct hda_fixup *fix, int action) 4273 { 4274 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4275 struct alc_spec *spec = codec->spec; 4276 /* Disable AA-loopback as it causes white noise */ 4277 spec->gen.mixer_nid = 0; 4278 } 4279 } 4280 4281 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */ 4282 static void alc_fixup_tpt440_dock(struct hda_codec *codec, 4283 const struct hda_fixup *fix, int action) 4284 { 4285 static const struct hda_pintbl pincfgs[] = { 4286 { 0x16, 0x21211010 }, /* dock headphone */ 4287 { 0x19, 0x21a11010 }, /* dock mic */ 4288 { } 4289 }; 4290 struct alc_spec *spec = codec->spec; 4291 4292 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4293 spec->shutup = alc_no_shutup; /* reduce click noise */ 4294 spec->reboot_notify = alc_d3_at_reboot; /* reduce noise */ 4295 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 4296 codec->power_save_node = 0; /* avoid click noises */ 4297 snd_hda_apply_pincfgs(codec, pincfgs); 4298 } 4299 } 4300 4301 static void alc_shutup_dell_xps13(struct hda_codec *codec) 4302 { 4303 struct alc_spec *spec = codec->spec; 4304 int hp_pin = spec->gen.autocfg.hp_pins[0]; 4305 4306 /* Prevent pop noises when headphones are plugged in */ 4307 snd_hda_codec_write(codec, hp_pin, 0, 4308 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 4309 msleep(20); 4310 } 4311 4312 static void alc_fixup_dell_xps13(struct hda_codec *codec, 4313 const struct hda_fixup *fix, int action) 4314 { 4315 struct alc_spec *spec = codec->spec; 4316 struct hda_input_mux *imux = &spec->gen.input_mux; 4317 int i; 4318 4319 switch (action) { 4320 case HDA_FIXUP_ACT_PRE_PROBE: 4321 /* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise 4322 * it causes a click noise at start up 4323 */ 4324 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ); 4325 break; 4326 case HDA_FIXUP_ACT_PROBE: 4327 spec->shutup = alc_shutup_dell_xps13; 4328 4329 /* Make the internal mic the default input source. */ 4330 for (i = 0; i < imux->num_items; i++) { 4331 if (spec->gen.imux_pins[i] == 0x12) { 4332 spec->gen.cur_mux[0] = i; 4333 break; 4334 } 4335 } 4336 break; 4337 } 4338 } 4339 4340 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec, 4341 const struct hda_fixup *fix, int action) 4342 { 4343 struct alc_spec *spec = codec->spec; 4344 4345 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4346 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC; 4347 spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */ 4348 4349 /* Disable boost for mic-in permanently. (This code is only called 4350 from quirks that guarantee that the headphone is at NID 0x1b.) */ 4351 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000); 4352 snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP); 4353 } else 4354 alc_fixup_headset_mode(codec, fix, action); 4355 } 4356 4357 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec, 4358 const struct hda_fixup *fix, int action) 4359 { 4360 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4361 alc_write_coef_idx(codec, 0xc4, 0x8000); 4362 alc_update_coef_idx(codec, 0xc2, ~0xfe, 0); 4363 snd_hda_set_pin_ctl_cache(codec, 0x18, 0); 4364 } 4365 alc_fixup_headset_mode(codec, fix, action); 4366 } 4367 4368 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */ 4369 static int find_ext_mic_pin(struct hda_codec *codec) 4370 { 4371 struct alc_spec *spec = codec->spec; 4372 struct auto_pin_cfg *cfg = &spec->gen.autocfg; 4373 hda_nid_t nid; 4374 unsigned int defcfg; 4375 int i; 4376 4377 for (i = 0; i < cfg->num_inputs; i++) { 4378 if (cfg->inputs[i].type != AUTO_PIN_MIC) 4379 continue; 4380 nid = cfg->inputs[i].pin; 4381 defcfg = snd_hda_codec_get_pincfg(codec, nid); 4382 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT) 4383 continue; 4384 return nid; 4385 } 4386 4387 return 0; 4388 } 4389 4390 static void alc271_hp_gate_mic_jack(struct hda_codec *codec, 4391 const struct hda_fixup *fix, 4392 int action) 4393 { 4394 struct alc_spec *spec = codec->spec; 4395 4396 if (action == HDA_FIXUP_ACT_PROBE) { 4397 int mic_pin = find_ext_mic_pin(codec); 4398 int hp_pin = spec->gen.autocfg.hp_pins[0]; 4399 4400 if (snd_BUG_ON(!mic_pin || !hp_pin)) 4401 return; 4402 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin); 4403 } 4404 } 4405 4406 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec, 4407 const struct hda_fixup *fix, 4408 int action) 4409 { 4410 struct alc_spec *spec = codec->spec; 4411 struct auto_pin_cfg *cfg = &spec->gen.autocfg; 4412 int i; 4413 4414 /* The mic boosts on level 2 and 3 are too noisy 4415 on the internal mic input. 4416 Therefore limit the boost to 0 or 1. */ 4417 4418 if (action != HDA_FIXUP_ACT_PROBE) 4419 return; 4420 4421 for (i = 0; i < cfg->num_inputs; i++) { 4422 hda_nid_t nid = cfg->inputs[i].pin; 4423 unsigned int defcfg; 4424 if (cfg->inputs[i].type != AUTO_PIN_MIC) 4425 continue; 4426 defcfg = snd_hda_codec_get_pincfg(codec, nid); 4427 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT) 4428 continue; 4429 4430 snd_hda_override_amp_caps(codec, nid, HDA_INPUT, 4431 (0x00 << AC_AMPCAP_OFFSET_SHIFT) | 4432 (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) | 4433 (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) | 4434 (0 << AC_AMPCAP_MUTE_SHIFT)); 4435 } 4436 } 4437 4438 static void alc283_hp_automute_hook(struct hda_codec *codec, 4439 struct hda_jack_callback *jack) 4440 { 4441 struct alc_spec *spec = codec->spec; 4442 int vref; 4443 4444 msleep(200); 4445 snd_hda_gen_hp_automute(codec, jack); 4446 4447 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0; 4448 4449 msleep(600); 4450 snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4451 vref); 4452 } 4453 4454 static void alc283_fixup_chromebook(struct hda_codec *codec, 4455 const struct hda_fixup *fix, int action) 4456 { 4457 struct alc_spec *spec = codec->spec; 4458 4459 switch (action) { 4460 case HDA_FIXUP_ACT_PRE_PROBE: 4461 snd_hda_override_wcaps(codec, 0x03, 0); 4462 /* Disable AA-loopback as it causes white noise */ 4463 spec->gen.mixer_nid = 0; 4464 break; 4465 case HDA_FIXUP_ACT_INIT: 4466 /* MIC2-VREF control */ 4467 /* Set to manual mode */ 4468 alc_update_coef_idx(codec, 0x06, 0x000c, 0); 4469 /* Enable Line1 input control by verb */ 4470 alc_update_coef_idx(codec, 0x1a, 0, 1 << 4); 4471 break; 4472 } 4473 } 4474 4475 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec, 4476 const struct hda_fixup *fix, int action) 4477 { 4478 struct alc_spec *spec = codec->spec; 4479 4480 switch (action) { 4481 case HDA_FIXUP_ACT_PRE_PROBE: 4482 spec->gen.hp_automute_hook = alc283_hp_automute_hook; 4483 break; 4484 case HDA_FIXUP_ACT_INIT: 4485 /* MIC2-VREF control */ 4486 /* Set to manual mode */ 4487 alc_update_coef_idx(codec, 0x06, 0x000c, 0); 4488 break; 4489 } 4490 } 4491 4492 /* mute tablet speaker pin (0x14) via dock plugging in addition */ 4493 static void asus_tx300_automute(struct hda_codec *codec) 4494 { 4495 struct alc_spec *spec = codec->spec; 4496 snd_hda_gen_update_outputs(codec); 4497 if (snd_hda_jack_detect(codec, 0x1b)) 4498 spec->gen.mute_bits |= (1ULL << 0x14); 4499 } 4500 4501 static void alc282_fixup_asus_tx300(struct hda_codec *codec, 4502 const struct hda_fixup *fix, int action) 4503 { 4504 struct alc_spec *spec = codec->spec; 4505 /* TX300 needs to set up GPIO2 for the speaker amp */ 4506 static const struct hda_verb gpio2_verbs[] = { 4507 { 0x01, AC_VERB_SET_GPIO_MASK, 0x04 }, 4508 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04 }, 4509 { 0x01, AC_VERB_SET_GPIO_DATA, 0x04 }, 4510 {} 4511 }; 4512 static const struct hda_pintbl dock_pins[] = { 4513 { 0x1b, 0x21114000 }, /* dock speaker pin */ 4514 {} 4515 }; 4516 struct snd_kcontrol *kctl; 4517 4518 switch (action) { 4519 case HDA_FIXUP_ACT_PRE_PROBE: 4520 snd_hda_add_verbs(codec, gpio2_verbs); 4521 snd_hda_apply_pincfgs(codec, dock_pins); 4522 spec->gen.auto_mute_via_amp = 1; 4523 spec->gen.automute_hook = asus_tx300_automute; 4524 snd_hda_jack_detect_enable_callback(codec, 0x1b, 4525 snd_hda_gen_hp_automute); 4526 break; 4527 case HDA_FIXUP_ACT_BUILD: 4528 /* this is a bit tricky; give more sane names for the main 4529 * (tablet) speaker and the dock speaker, respectively 4530 */ 4531 kctl = snd_hda_find_mixer_ctl(codec, "Speaker Playback Switch"); 4532 if (kctl) 4533 strcpy(kctl->id.name, "Dock Speaker Playback Switch"); 4534 kctl = snd_hda_find_mixer_ctl(codec, "Bass Speaker Playback Switch"); 4535 if (kctl) 4536 strcpy(kctl->id.name, "Speaker Playback Switch"); 4537 break; 4538 } 4539 } 4540 4541 static void alc290_fixup_mono_speakers(struct hda_codec *codec, 4542 const struct hda_fixup *fix, int action) 4543 { 4544 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4545 /* DAC node 0x03 is giving mono output. We therefore want to 4546 make sure 0x14 (front speaker) and 0x15 (headphones) use the 4547 stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */ 4548 hda_nid_t conn1[2] = { 0x0c }; 4549 snd_hda_override_conn_list(codec, 0x14, 1, conn1); 4550 snd_hda_override_conn_list(codec, 0x15, 1, conn1); 4551 } 4552 } 4553 4554 /* Hook to update amp GPIO4 for automute */ 4555 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec, 4556 struct hda_jack_callback *jack) 4557 { 4558 struct alc_spec *spec = codec->spec; 4559 4560 snd_hda_gen_hp_automute(codec, jack); 4561 /* mute_led_polarity is set to 0, so we pass inverted value here */ 4562 alc_update_gpio_led(codec, 0x10, !spec->gen.hp_jack_present); 4563 } 4564 4565 /* Manage GPIOs for HP EliteBook Folio 9480m. 4566 * 4567 * GPIO4 is the headphone amplifier power control 4568 * GPIO3 is the audio output mute indicator LED 4569 */ 4570 4571 static void alc280_fixup_hp_9480m(struct hda_codec *codec, 4572 const struct hda_fixup *fix, 4573 int action) 4574 { 4575 struct alc_spec *spec = codec->spec; 4576 static const struct hda_verb gpio_init[] = { 4577 { 0x01, AC_VERB_SET_GPIO_MASK, 0x18 }, 4578 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 }, 4579 {} 4580 }; 4581 4582 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 4583 /* Set the hooks to turn the headphone amp on/off 4584 * as needed 4585 */ 4586 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook; 4587 spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook; 4588 4589 /* The GPIOs are currently off */ 4590 spec->gpio_led = 0; 4591 4592 /* GPIO3 is connected to the output mute LED, 4593 * high is on, low is off 4594 */ 4595 spec->mute_led_polarity = 0; 4596 spec->gpio_mute_led_mask = 0x08; 4597 4598 /* Initialize GPIO configuration */ 4599 snd_hda_add_verbs(codec, gpio_init); 4600 } 4601 } 4602 4603 /* for hda_fixup_thinkpad_acpi() */ 4604 #include "thinkpad_helper.c" 4605 4606 /* for dell wmi mic mute led */ 4607 #include "dell_wmi_helper.c" 4608 4609 enum { 4610 ALC269_FIXUP_SONY_VAIO, 4611 ALC275_FIXUP_SONY_VAIO_GPIO2, 4612 ALC269_FIXUP_DELL_M101Z, 4613 ALC269_FIXUP_SKU_IGNORE, 4614 ALC269_FIXUP_ASUS_G73JW, 4615 ALC269_FIXUP_LENOVO_EAPD, 4616 ALC275_FIXUP_SONY_HWEQ, 4617 ALC275_FIXUP_SONY_DISABLE_AAMIX, 4618 ALC271_FIXUP_DMIC, 4619 ALC269_FIXUP_PCM_44K, 4620 ALC269_FIXUP_STEREO_DMIC, 4621 ALC269_FIXUP_HEADSET_MIC, 4622 ALC269_FIXUP_QUANTA_MUTE, 4623 ALC269_FIXUP_LIFEBOOK, 4624 ALC269_FIXUP_LIFEBOOK_EXTMIC, 4625 ALC269_FIXUP_LIFEBOOK_HP_PIN, 4626 ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT, 4627 ALC269_FIXUP_AMIC, 4628 ALC269_FIXUP_DMIC, 4629 ALC269VB_FIXUP_AMIC, 4630 ALC269VB_FIXUP_DMIC, 4631 ALC269_FIXUP_HP_MUTE_LED, 4632 ALC269_FIXUP_HP_MUTE_LED_MIC1, 4633 ALC269_FIXUP_HP_MUTE_LED_MIC2, 4634 ALC269_FIXUP_HP_GPIO_LED, 4635 ALC269_FIXUP_HP_GPIO_MIC1_LED, 4636 ALC269_FIXUP_HP_LINE1_MIC1_LED, 4637 ALC269_FIXUP_INV_DMIC, 4638 ALC269_FIXUP_LENOVO_DOCK, 4639 ALC269_FIXUP_NO_SHUTUP, 4640 ALC286_FIXUP_SONY_MIC_NO_PRESENCE, 4641 ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT, 4642 ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 4643 ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, 4644 ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, 4645 ALC269_FIXUP_HEADSET_MODE, 4646 ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, 4647 ALC269_FIXUP_ASPIRE_HEADSET_MIC, 4648 ALC269_FIXUP_ASUS_X101_FUNC, 4649 ALC269_FIXUP_ASUS_X101_VERB, 4650 ALC269_FIXUP_ASUS_X101, 4651 ALC271_FIXUP_AMIC_MIC2, 4652 ALC271_FIXUP_HP_GATE_MIC_JACK, 4653 ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, 4654 ALC269_FIXUP_ACER_AC700, 4655 ALC269_FIXUP_LIMIT_INT_MIC_BOOST, 4656 ALC269VB_FIXUP_ASUS_ZENBOOK, 4657 ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, 4658 ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED, 4659 ALC269VB_FIXUP_ORDISSIMO_EVE2, 4660 ALC283_FIXUP_CHROME_BOOK, 4661 ALC283_FIXUP_SENSE_COMBO_JACK, 4662 ALC282_FIXUP_ASUS_TX300, 4663 ALC283_FIXUP_INT_MIC, 4664 ALC290_FIXUP_MONO_SPEAKERS, 4665 ALC290_FIXUP_MONO_SPEAKERS_HSJACK, 4666 ALC290_FIXUP_SUBWOOFER, 4667 ALC290_FIXUP_SUBWOOFER_HSJACK, 4668 ALC269_FIXUP_THINKPAD_ACPI, 4669 ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 4670 ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, 4671 ALC255_FIXUP_HEADSET_MODE, 4672 ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC, 4673 ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, 4674 ALC292_FIXUP_TPT440_DOCK, 4675 ALC292_FIXUP_TPT440, 4676 ALC283_FIXUP_BXBT2807_MIC, 4677 ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED, 4678 ALC282_FIXUP_ASPIRE_V5_PINS, 4679 ALC280_FIXUP_HP_GPIO4, 4680 ALC286_FIXUP_HP_GPIO_LED, 4681 ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, 4682 ALC280_FIXUP_HP_DOCK_PINS, 4683 ALC280_FIXUP_HP_9480M, 4684 ALC288_FIXUP_DELL_HEADSET_MODE, 4685 ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, 4686 ALC288_FIXUP_DELL_XPS_13_GPIO6, 4687 ALC288_FIXUP_DELL_XPS_13, 4688 ALC288_FIXUP_DISABLE_AAMIX, 4689 ALC292_FIXUP_DELL_E7X, 4690 ALC292_FIXUP_DISABLE_AAMIX, 4691 ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, 4692 ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 4693 ALC275_FIXUP_DELL_XPS, 4694 ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE, 4695 ALC293_FIXUP_LENOVO_SPK_NOISE, 4696 ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, 4697 }; 4698 4699 static const struct hda_fixup alc269_fixups[] = { 4700 [ALC269_FIXUP_SONY_VAIO] = { 4701 .type = HDA_FIXUP_PINCTLS, 4702 .v.pins = (const struct hda_pintbl[]) { 4703 {0x19, PIN_VREFGRD}, 4704 {} 4705 } 4706 }, 4707 [ALC275_FIXUP_SONY_VAIO_GPIO2] = { 4708 .type = HDA_FIXUP_VERBS, 4709 .v.verbs = (const struct hda_verb[]) { 4710 {0x01, AC_VERB_SET_GPIO_MASK, 0x04}, 4711 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04}, 4712 {0x01, AC_VERB_SET_GPIO_DATA, 0x00}, 4713 { } 4714 }, 4715 .chained = true, 4716 .chain_id = ALC269_FIXUP_SONY_VAIO 4717 }, 4718 [ALC269_FIXUP_DELL_M101Z] = { 4719 .type = HDA_FIXUP_VERBS, 4720 .v.verbs = (const struct hda_verb[]) { 4721 /* Enables internal speaker */ 4722 {0x20, AC_VERB_SET_COEF_INDEX, 13}, 4723 {0x20, AC_VERB_SET_PROC_COEF, 0x4040}, 4724 {} 4725 } 4726 }, 4727 [ALC269_FIXUP_SKU_IGNORE] = { 4728 .type = HDA_FIXUP_FUNC, 4729 .v.func = alc_fixup_sku_ignore, 4730 }, 4731 [ALC269_FIXUP_ASUS_G73JW] = { 4732 .type = HDA_FIXUP_PINS, 4733 .v.pins = (const struct hda_pintbl[]) { 4734 { 0x17, 0x99130111 }, /* subwoofer */ 4735 { } 4736 } 4737 }, 4738 [ALC269_FIXUP_LENOVO_EAPD] = { 4739 .type = HDA_FIXUP_VERBS, 4740 .v.verbs = (const struct hda_verb[]) { 4741 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0}, 4742 {} 4743 } 4744 }, 4745 [ALC275_FIXUP_SONY_HWEQ] = { 4746 .type = HDA_FIXUP_FUNC, 4747 .v.func = alc269_fixup_hweq, 4748 .chained = true, 4749 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2 4750 }, 4751 [ALC275_FIXUP_SONY_DISABLE_AAMIX] = { 4752 .type = HDA_FIXUP_FUNC, 4753 .v.func = alc_fixup_disable_aamix, 4754 .chained = true, 4755 .chain_id = ALC269_FIXUP_SONY_VAIO 4756 }, 4757 [ALC271_FIXUP_DMIC] = { 4758 .type = HDA_FIXUP_FUNC, 4759 .v.func = alc271_fixup_dmic, 4760 }, 4761 [ALC269_FIXUP_PCM_44K] = { 4762 .type = HDA_FIXUP_FUNC, 4763 .v.func = alc269_fixup_pcm_44k, 4764 .chained = true, 4765 .chain_id = ALC269_FIXUP_QUANTA_MUTE 4766 }, 4767 [ALC269_FIXUP_STEREO_DMIC] = { 4768 .type = HDA_FIXUP_FUNC, 4769 .v.func = alc269_fixup_stereo_dmic, 4770 }, 4771 [ALC269_FIXUP_HEADSET_MIC] = { 4772 .type = HDA_FIXUP_FUNC, 4773 .v.func = alc269_fixup_headset_mic, 4774 }, 4775 [ALC269_FIXUP_QUANTA_MUTE] = { 4776 .type = HDA_FIXUP_FUNC, 4777 .v.func = alc269_fixup_quanta_mute, 4778 }, 4779 [ALC269_FIXUP_LIFEBOOK] = { 4780 .type = HDA_FIXUP_PINS, 4781 .v.pins = (const struct hda_pintbl[]) { 4782 { 0x1a, 0x2101103f }, /* dock line-out */ 4783 { 0x1b, 0x23a11040 }, /* dock mic-in */ 4784 { } 4785 }, 4786 .chained = true, 4787 .chain_id = ALC269_FIXUP_QUANTA_MUTE 4788 }, 4789 [ALC269_FIXUP_LIFEBOOK_EXTMIC] = { 4790 .type = HDA_FIXUP_PINS, 4791 .v.pins = (const struct hda_pintbl[]) { 4792 { 0x19, 0x01a1903c }, /* headset mic, with jack detect */ 4793 { } 4794 }, 4795 }, 4796 [ALC269_FIXUP_LIFEBOOK_HP_PIN] = { 4797 .type = HDA_FIXUP_PINS, 4798 .v.pins = (const struct hda_pintbl[]) { 4799 { 0x21, 0x0221102f }, /* HP out */ 4800 { } 4801 }, 4802 }, 4803 [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = { 4804 .type = HDA_FIXUP_FUNC, 4805 .v.func = alc269_fixup_pincfg_no_hp_to_lineout, 4806 }, 4807 [ALC269_FIXUP_AMIC] = { 4808 .type = HDA_FIXUP_PINS, 4809 .v.pins = (const struct hda_pintbl[]) { 4810 { 0x14, 0x99130110 }, /* speaker */ 4811 { 0x15, 0x0121401f }, /* HP out */ 4812 { 0x18, 0x01a19c20 }, /* mic */ 4813 { 0x19, 0x99a3092f }, /* int-mic */ 4814 { } 4815 }, 4816 }, 4817 [ALC269_FIXUP_DMIC] = { 4818 .type = HDA_FIXUP_PINS, 4819 .v.pins = (const struct hda_pintbl[]) { 4820 { 0x12, 0x99a3092f }, /* int-mic */ 4821 { 0x14, 0x99130110 }, /* speaker */ 4822 { 0x15, 0x0121401f }, /* HP out */ 4823 { 0x18, 0x01a19c20 }, /* mic */ 4824 { } 4825 }, 4826 }, 4827 [ALC269VB_FIXUP_AMIC] = { 4828 .type = HDA_FIXUP_PINS, 4829 .v.pins = (const struct hda_pintbl[]) { 4830 { 0x14, 0x99130110 }, /* speaker */ 4831 { 0x18, 0x01a19c20 }, /* mic */ 4832 { 0x19, 0x99a3092f }, /* int-mic */ 4833 { 0x21, 0x0121401f }, /* HP out */ 4834 { } 4835 }, 4836 }, 4837 [ALC269VB_FIXUP_DMIC] = { 4838 .type = HDA_FIXUP_PINS, 4839 .v.pins = (const struct hda_pintbl[]) { 4840 { 0x12, 0x99a3092f }, /* int-mic */ 4841 { 0x14, 0x99130110 }, /* speaker */ 4842 { 0x18, 0x01a19c20 }, /* mic */ 4843 { 0x21, 0x0121401f }, /* HP out */ 4844 { } 4845 }, 4846 }, 4847 [ALC269_FIXUP_HP_MUTE_LED] = { 4848 .type = HDA_FIXUP_FUNC, 4849 .v.func = alc269_fixup_hp_mute_led, 4850 }, 4851 [ALC269_FIXUP_HP_MUTE_LED_MIC1] = { 4852 .type = HDA_FIXUP_FUNC, 4853 .v.func = alc269_fixup_hp_mute_led_mic1, 4854 }, 4855 [ALC269_FIXUP_HP_MUTE_LED_MIC2] = { 4856 .type = HDA_FIXUP_FUNC, 4857 .v.func = alc269_fixup_hp_mute_led_mic2, 4858 }, 4859 [ALC269_FIXUP_HP_GPIO_LED] = { 4860 .type = HDA_FIXUP_FUNC, 4861 .v.func = alc269_fixup_hp_gpio_led, 4862 }, 4863 [ALC269_FIXUP_HP_GPIO_MIC1_LED] = { 4864 .type = HDA_FIXUP_FUNC, 4865 .v.func = alc269_fixup_hp_gpio_mic1_led, 4866 }, 4867 [ALC269_FIXUP_HP_LINE1_MIC1_LED] = { 4868 .type = HDA_FIXUP_FUNC, 4869 .v.func = alc269_fixup_hp_line1_mic1_led, 4870 }, 4871 [ALC269_FIXUP_INV_DMIC] = { 4872 .type = HDA_FIXUP_FUNC, 4873 .v.func = alc_fixup_inv_dmic, 4874 }, 4875 [ALC269_FIXUP_NO_SHUTUP] = { 4876 .type = HDA_FIXUP_FUNC, 4877 .v.func = alc_fixup_no_shutup, 4878 }, 4879 [ALC269_FIXUP_LENOVO_DOCK] = { 4880 .type = HDA_FIXUP_PINS, 4881 .v.pins = (const struct hda_pintbl[]) { 4882 { 0x19, 0x23a11040 }, /* dock mic */ 4883 { 0x1b, 0x2121103f }, /* dock headphone */ 4884 { } 4885 }, 4886 .chained = true, 4887 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT 4888 }, 4889 [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = { 4890 .type = HDA_FIXUP_FUNC, 4891 .v.func = alc269_fixup_pincfg_no_hp_to_lineout, 4892 .chained = true, 4893 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 4894 }, 4895 [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = { 4896 .type = HDA_FIXUP_PINS, 4897 .v.pins = (const struct hda_pintbl[]) { 4898 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 4899 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 4900 { } 4901 }, 4902 .chained = true, 4903 .chain_id = ALC269_FIXUP_HEADSET_MODE 4904 }, 4905 [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = { 4906 .type = HDA_FIXUP_PINS, 4907 .v.pins = (const struct hda_pintbl[]) { 4908 { 0x16, 0x21014020 }, /* dock line out */ 4909 { 0x19, 0x21a19030 }, /* dock mic */ 4910 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 4911 { } 4912 }, 4913 .chained = true, 4914 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 4915 }, 4916 [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = { 4917 .type = HDA_FIXUP_PINS, 4918 .v.pins = (const struct hda_pintbl[]) { 4919 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 4920 { } 4921 }, 4922 .chained = true, 4923 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC 4924 }, 4925 [ALC269_FIXUP_HEADSET_MODE] = { 4926 .type = HDA_FIXUP_FUNC, 4927 .v.func = alc_fixup_headset_mode, 4928 .chained = true, 4929 .chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED 4930 }, 4931 [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = { 4932 .type = HDA_FIXUP_FUNC, 4933 .v.func = alc_fixup_headset_mode_no_hp_mic, 4934 }, 4935 [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = { 4936 .type = HDA_FIXUP_PINS, 4937 .v.pins = (const struct hda_pintbl[]) { 4938 { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */ 4939 { } 4940 }, 4941 .chained = true, 4942 .chain_id = ALC269_FIXUP_HEADSET_MODE, 4943 }, 4944 [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = { 4945 .type = HDA_FIXUP_PINS, 4946 .v.pins = (const struct hda_pintbl[]) { 4947 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 4948 { } 4949 }, 4950 .chained = true, 4951 .chain_id = ALC269_FIXUP_HEADSET_MIC 4952 }, 4953 [ALC269_FIXUP_ASUS_X101_FUNC] = { 4954 .type = HDA_FIXUP_FUNC, 4955 .v.func = alc269_fixup_x101_headset_mic, 4956 }, 4957 [ALC269_FIXUP_ASUS_X101_VERB] = { 4958 .type = HDA_FIXUP_VERBS, 4959 .v.verbs = (const struct hda_verb[]) { 4960 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 4961 {0x20, AC_VERB_SET_COEF_INDEX, 0x08}, 4962 {0x20, AC_VERB_SET_PROC_COEF, 0x0310}, 4963 { } 4964 }, 4965 .chained = true, 4966 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC 4967 }, 4968 [ALC269_FIXUP_ASUS_X101] = { 4969 .type = HDA_FIXUP_PINS, 4970 .v.pins = (const struct hda_pintbl[]) { 4971 { 0x18, 0x04a1182c }, /* Headset mic */ 4972 { } 4973 }, 4974 .chained = true, 4975 .chain_id = ALC269_FIXUP_ASUS_X101_VERB 4976 }, 4977 [ALC271_FIXUP_AMIC_MIC2] = { 4978 .type = HDA_FIXUP_PINS, 4979 .v.pins = (const struct hda_pintbl[]) { 4980 { 0x14, 0x99130110 }, /* speaker */ 4981 { 0x19, 0x01a19c20 }, /* mic */ 4982 { 0x1b, 0x99a7012f }, /* int-mic */ 4983 { 0x21, 0x0121401f }, /* HP out */ 4984 { } 4985 }, 4986 }, 4987 [ALC271_FIXUP_HP_GATE_MIC_JACK] = { 4988 .type = HDA_FIXUP_FUNC, 4989 .v.func = alc271_hp_gate_mic_jack, 4990 .chained = true, 4991 .chain_id = ALC271_FIXUP_AMIC_MIC2, 4992 }, 4993 [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = { 4994 .type = HDA_FIXUP_FUNC, 4995 .v.func = alc269_fixup_limit_int_mic_boost, 4996 .chained = true, 4997 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK, 4998 }, 4999 [ALC269_FIXUP_ACER_AC700] = { 5000 .type = HDA_FIXUP_PINS, 5001 .v.pins = (const struct hda_pintbl[]) { 5002 { 0x12, 0x99a3092f }, /* int-mic */ 5003 { 0x14, 0x99130110 }, /* speaker */ 5004 { 0x18, 0x03a11c20 }, /* mic */ 5005 { 0x1e, 0x0346101e }, /* SPDIF1 */ 5006 { 0x21, 0x0321101f }, /* HP out */ 5007 { } 5008 }, 5009 .chained = true, 5010 .chain_id = ALC271_FIXUP_DMIC, 5011 }, 5012 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = { 5013 .type = HDA_FIXUP_FUNC, 5014 .v.func = alc269_fixup_limit_int_mic_boost, 5015 .chained = true, 5016 .chain_id = ALC269_FIXUP_THINKPAD_ACPI, 5017 }, 5018 [ALC269VB_FIXUP_ASUS_ZENBOOK] = { 5019 .type = HDA_FIXUP_FUNC, 5020 .v.func = alc269_fixup_limit_int_mic_boost, 5021 .chained = true, 5022 .chain_id = ALC269VB_FIXUP_DMIC, 5023 }, 5024 [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = { 5025 .type = HDA_FIXUP_VERBS, 5026 .v.verbs = (const struct hda_verb[]) { 5027 /* class-D output amp +5dB */ 5028 { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 }, 5029 { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 }, 5030 {} 5031 }, 5032 .chained = true, 5033 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK, 5034 }, 5035 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = { 5036 .type = HDA_FIXUP_FUNC, 5037 .v.func = alc269_fixup_limit_int_mic_boost, 5038 .chained = true, 5039 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1, 5040 }, 5041 [ALC269VB_FIXUP_ORDISSIMO_EVE2] = { 5042 .type = HDA_FIXUP_PINS, 5043 .v.pins = (const struct hda_pintbl[]) { 5044 { 0x12, 0x99a3092f }, /* int-mic */ 5045 { 0x18, 0x03a11d20 }, /* mic */ 5046 { 0x19, 0x411111f0 }, /* Unused bogus pin */ 5047 { } 5048 }, 5049 }, 5050 [ALC283_FIXUP_CHROME_BOOK] = { 5051 .type = HDA_FIXUP_FUNC, 5052 .v.func = alc283_fixup_chromebook, 5053 }, 5054 [ALC283_FIXUP_SENSE_COMBO_JACK] = { 5055 .type = HDA_FIXUP_FUNC, 5056 .v.func = alc283_fixup_sense_combo_jack, 5057 .chained = true, 5058 .chain_id = ALC283_FIXUP_CHROME_BOOK, 5059 }, 5060 [ALC282_FIXUP_ASUS_TX300] = { 5061 .type = HDA_FIXUP_FUNC, 5062 .v.func = alc282_fixup_asus_tx300, 5063 }, 5064 [ALC283_FIXUP_INT_MIC] = { 5065 .type = HDA_FIXUP_VERBS, 5066 .v.verbs = (const struct hda_verb[]) { 5067 {0x20, AC_VERB_SET_COEF_INDEX, 0x1a}, 5068 {0x20, AC_VERB_SET_PROC_COEF, 0x0011}, 5069 { } 5070 }, 5071 .chained = true, 5072 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST 5073 }, 5074 [ALC290_FIXUP_SUBWOOFER_HSJACK] = { 5075 .type = HDA_FIXUP_PINS, 5076 .v.pins = (const struct hda_pintbl[]) { 5077 { 0x17, 0x90170112 }, /* subwoofer */ 5078 { } 5079 }, 5080 .chained = true, 5081 .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, 5082 }, 5083 [ALC290_FIXUP_SUBWOOFER] = { 5084 .type = HDA_FIXUP_PINS, 5085 .v.pins = (const struct hda_pintbl[]) { 5086 { 0x17, 0x90170112 }, /* subwoofer */ 5087 { } 5088 }, 5089 .chained = true, 5090 .chain_id = ALC290_FIXUP_MONO_SPEAKERS, 5091 }, 5092 [ALC290_FIXUP_MONO_SPEAKERS] = { 5093 .type = HDA_FIXUP_FUNC, 5094 .v.func = alc290_fixup_mono_speakers, 5095 }, 5096 [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = { 5097 .type = HDA_FIXUP_FUNC, 5098 .v.func = alc290_fixup_mono_speakers, 5099 .chained = true, 5100 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, 5101 }, 5102 [ALC269_FIXUP_THINKPAD_ACPI] = { 5103 .type = HDA_FIXUP_FUNC, 5104 .v.func = hda_fixup_thinkpad_acpi, 5105 }, 5106 [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = { 5107 .type = HDA_FIXUP_PINS, 5108 .v.pins = (const struct hda_pintbl[]) { 5109 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 5110 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 5111 { } 5112 }, 5113 .chained = true, 5114 .chain_id = ALC255_FIXUP_HEADSET_MODE 5115 }, 5116 [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = { 5117 .type = HDA_FIXUP_PINS, 5118 .v.pins = (const struct hda_pintbl[]) { 5119 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 5120 { } 5121 }, 5122 .chained = true, 5123 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC 5124 }, 5125 [ALC255_FIXUP_HEADSET_MODE] = { 5126 .type = HDA_FIXUP_FUNC, 5127 .v.func = alc_fixup_headset_mode_alc255, 5128 .chained = true, 5129 .chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED 5130 }, 5131 [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = { 5132 .type = HDA_FIXUP_FUNC, 5133 .v.func = alc_fixup_headset_mode_alc255_no_hp_mic, 5134 }, 5135 [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = { 5136 .type = HDA_FIXUP_PINS, 5137 .v.pins = (const struct hda_pintbl[]) { 5138 { 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 5139 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 5140 { } 5141 }, 5142 .chained = true, 5143 .chain_id = ALC269_FIXUP_HEADSET_MODE 5144 }, 5145 [ALC292_FIXUP_TPT440_DOCK] = { 5146 .type = HDA_FIXUP_FUNC, 5147 .v.func = alc_fixup_tpt440_dock, 5148 .chained = true, 5149 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST 5150 }, 5151 [ALC292_FIXUP_TPT440] = { 5152 .type = HDA_FIXUP_FUNC, 5153 .v.func = alc_fixup_disable_aamix, 5154 .chained = true, 5155 .chain_id = ALC292_FIXUP_TPT440_DOCK, 5156 }, 5157 [ALC283_FIXUP_BXBT2807_MIC] = { 5158 .type = HDA_FIXUP_PINS, 5159 .v.pins = (const struct hda_pintbl[]) { 5160 { 0x19, 0x04a110f0 }, 5161 { }, 5162 }, 5163 }, 5164 [ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED] = { 5165 .type = HDA_FIXUP_FUNC, 5166 .v.func = alc_fixup_dell_wmi, 5167 }, 5168 [ALC282_FIXUP_ASPIRE_V5_PINS] = { 5169 .type = HDA_FIXUP_PINS, 5170 .v.pins = (const struct hda_pintbl[]) { 5171 { 0x12, 0x90a60130 }, 5172 { 0x14, 0x90170110 }, 5173 { 0x17, 0x40000008 }, 5174 { 0x18, 0x411111f0 }, 5175 { 0x19, 0x01a1913c }, 5176 { 0x1a, 0x411111f0 }, 5177 { 0x1b, 0x411111f0 }, 5178 { 0x1d, 0x40f89b2d }, 5179 { 0x1e, 0x411111f0 }, 5180 { 0x21, 0x0321101f }, 5181 { }, 5182 }, 5183 }, 5184 [ALC280_FIXUP_HP_GPIO4] = { 5185 .type = HDA_FIXUP_FUNC, 5186 .v.func = alc280_fixup_hp_gpio4, 5187 }, 5188 [ALC286_FIXUP_HP_GPIO_LED] = { 5189 .type = HDA_FIXUP_FUNC, 5190 .v.func = alc286_fixup_hp_gpio_led, 5191 }, 5192 [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = { 5193 .type = HDA_FIXUP_FUNC, 5194 .v.func = alc280_fixup_hp_gpio2_mic_hotkey, 5195 }, 5196 [ALC280_FIXUP_HP_DOCK_PINS] = { 5197 .type = HDA_FIXUP_PINS, 5198 .v.pins = (const struct hda_pintbl[]) { 5199 { 0x1b, 0x21011020 }, /* line-out */ 5200 { 0x1a, 0x01a1903c }, /* headset mic */ 5201 { 0x18, 0x2181103f }, /* line-in */ 5202 { }, 5203 }, 5204 .chained = true, 5205 .chain_id = ALC280_FIXUP_HP_GPIO4 5206 }, 5207 [ALC280_FIXUP_HP_9480M] = { 5208 .type = HDA_FIXUP_FUNC, 5209 .v.func = alc280_fixup_hp_9480m, 5210 }, 5211 [ALC288_FIXUP_DELL_HEADSET_MODE] = { 5212 .type = HDA_FIXUP_FUNC, 5213 .v.func = alc_fixup_headset_mode_dell_alc288, 5214 .chained = true, 5215 .chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED 5216 }, 5217 [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = { 5218 .type = HDA_FIXUP_PINS, 5219 .v.pins = (const struct hda_pintbl[]) { 5220 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 5221 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 5222 { } 5223 }, 5224 .chained = true, 5225 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE 5226 }, 5227 [ALC288_FIXUP_DELL_XPS_13_GPIO6] = { 5228 .type = HDA_FIXUP_VERBS, 5229 .v.verbs = (const struct hda_verb[]) { 5230 {0x01, AC_VERB_SET_GPIO_MASK, 0x40}, 5231 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x40}, 5232 {0x01, AC_VERB_SET_GPIO_DATA, 0x00}, 5233 { } 5234 }, 5235 .chained = true, 5236 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE 5237 }, 5238 [ALC288_FIXUP_DISABLE_AAMIX] = { 5239 .type = HDA_FIXUP_FUNC, 5240 .v.func = alc_fixup_disable_aamix, 5241 .chained = true, 5242 .chain_id = ALC288_FIXUP_DELL_XPS_13_GPIO6 5243 }, 5244 [ALC288_FIXUP_DELL_XPS_13] = { 5245 .type = HDA_FIXUP_FUNC, 5246 .v.func = alc_fixup_dell_xps13, 5247 .chained = true, 5248 .chain_id = ALC288_FIXUP_DISABLE_AAMIX 5249 }, 5250 [ALC292_FIXUP_DISABLE_AAMIX] = { 5251 .type = HDA_FIXUP_FUNC, 5252 .v.func = alc_fixup_disable_aamix, 5253 .chained = true, 5254 .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE 5255 }, 5256 [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = { 5257 .type = HDA_FIXUP_FUNC, 5258 .v.func = alc_fixup_disable_aamix, 5259 .chained = true, 5260 .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE 5261 }, 5262 [ALC292_FIXUP_DELL_E7X] = { 5263 .type = HDA_FIXUP_FUNC, 5264 .v.func = alc_fixup_dell_xps13, 5265 .chained = true, 5266 .chain_id = ALC292_FIXUP_DISABLE_AAMIX 5267 }, 5268 [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = { 5269 .type = HDA_FIXUP_PINS, 5270 .v.pins = (const struct hda_pintbl[]) { 5271 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */ 5272 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */ 5273 { } 5274 }, 5275 .chained = true, 5276 .chain_id = ALC269_FIXUP_HEADSET_MODE 5277 }, 5278 [ALC275_FIXUP_DELL_XPS] = { 5279 .type = HDA_FIXUP_VERBS, 5280 .v.verbs = (const struct hda_verb[]) { 5281 /* Enables internal speaker */ 5282 {0x20, AC_VERB_SET_COEF_INDEX, 0x1f}, 5283 {0x20, AC_VERB_SET_PROC_COEF, 0x00c0}, 5284 {0x20, AC_VERB_SET_COEF_INDEX, 0x30}, 5285 {0x20, AC_VERB_SET_PROC_COEF, 0x00b1}, 5286 {} 5287 } 5288 }, 5289 [ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE] = { 5290 .type = HDA_FIXUP_VERBS, 5291 .v.verbs = (const struct hda_verb[]) { 5292 /* Disable pass-through path for FRONT 14h */ 5293 {0x20, AC_VERB_SET_COEF_INDEX, 0x36}, 5294 {0x20, AC_VERB_SET_PROC_COEF, 0x1737}, 5295 {} 5296 }, 5297 .chained = true, 5298 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE 5299 }, 5300 [ALC293_FIXUP_LENOVO_SPK_NOISE] = { 5301 .type = HDA_FIXUP_FUNC, 5302 .v.func = alc_fixup_disable_aamix, 5303 .chained = true, 5304 .chain_id = ALC269_FIXUP_THINKPAD_ACPI 5305 }, 5306 [ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = { 5307 .type = HDA_FIXUP_FUNC, 5308 .v.func = alc233_fixup_lenovo_line2_mic_hotkey, 5309 }, 5310 }; 5311 5312 static const struct snd_pci_quirk alc269_fixup_tbl[] = { 5313 SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC), 5314 SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC), 5315 SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC), 5316 SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700), 5317 SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC), 5318 SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC), 5319 SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK), 5320 SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK), 5321 SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572), 5322 SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS), 5323 SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK), 5324 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z), 5325 SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS), 5326 SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X), 5327 SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X), 5328 SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X), 5329 SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER), 5330 SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE), 5331 SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE), 5332 SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE), 5333 SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK), 5334 SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK), 5335 SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X), 5336 SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK), 5337 SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 5338 SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 5339 SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13), 5340 SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK), 5341 SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE), 5342 SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 5343 SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 5344 SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 5345 SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 5346 SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 5347 SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 5348 SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK), 5349 SND_PCI_QUIRK(0x1028, 0x0704, "Dell XPS 13", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE), 5350 SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 5351 SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), 5352 SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2), 5353 SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED), 5354 SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED), 5355 SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY), 5356 /* ALC282 */ 5357 SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5358 SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5359 SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5360 SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 5361 SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 5362 SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 5363 SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 5364 SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED), 5365 SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5366 SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5367 SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5368 SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5369 SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED), 5370 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS), 5371 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS), 5372 SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5373 SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5374 SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5375 SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5376 SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5377 SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M), 5378 SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 5379 SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 5380 /* ALC290 */ 5381 SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 5382 SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 5383 SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 5384 SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 5385 SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 5386 SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 5387 SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 5388 SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 5389 SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 5390 SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 5391 SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5392 SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5393 SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5394 SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5395 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 5396 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 5397 SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED), 5398 SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5399 SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5400 SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5401 SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5402 SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5403 SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5404 SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5405 SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5406 SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5407 SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5408 SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5409 SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1), 5410 SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300), 5411 SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 5412 SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 5413 SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK), 5414 SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A), 5415 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC), 5416 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW), 5417 SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC), 5418 SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 5419 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC), 5420 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC), 5421 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC), 5422 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC), 5423 SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101), 5424 SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE), 5425 SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE), 5426 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2), 5427 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ), 5428 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ), 5429 SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX), 5430 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK), 5431 SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT), 5432 SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN), 5433 SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN), 5434 SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC), 5435 SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC), 5436 SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_BXBT2807_MIC), 5437 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE), 5438 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE), 5439 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE), 5440 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE), 5441 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE), 5442 SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK), 5443 SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK), 5444 SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK), 5445 SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK), 5446 SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK), 5447 SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK), 5448 SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440), 5449 SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK), 5450 SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK), 5451 SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK), 5452 SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK), 5453 SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK), 5454 SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 5455 SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK), 5456 SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK), 5457 SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK), 5458 SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE), 5459 SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY), 5460 SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC), 5461 SND_PCI_QUIRK(0x17aa, 0x3978, "IdeaPad Y410P", ALC269_FIXUP_NO_SHUTUP), 5462 SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 5463 SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC), 5464 SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK), 5465 SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 5466 SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK), 5467 SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK), 5468 SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK), 5469 SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE), 5470 SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST), 5471 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K), 5472 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD), 5473 SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */ 5474 5475 #if 0 5476 /* Below is a quirk table taken from the old code. 5477 * Basically the device should work as is without the fixup table. 5478 * If BIOS doesn't give a proper info, enable the corresponding 5479 * fixup entry. 5480 */ 5481 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A", 5482 ALC269_FIXUP_AMIC), 5483 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC), 5484 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC), 5485 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC), 5486 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC), 5487 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC), 5488 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC), 5489 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC), 5490 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC), 5491 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC), 5492 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC), 5493 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC), 5494 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC), 5495 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC), 5496 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC), 5497 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC), 5498 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC), 5499 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC), 5500 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC), 5501 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC), 5502 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC), 5503 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC), 5504 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC), 5505 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC), 5506 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC), 5507 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC), 5508 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC), 5509 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC), 5510 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC), 5511 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC), 5512 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC), 5513 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC), 5514 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC), 5515 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC), 5516 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC), 5517 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC), 5518 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC), 5519 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC), 5520 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC), 5521 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC), 5522 #endif 5523 {} 5524 }; 5525 5526 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = { 5527 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC), 5528 SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED), 5529 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO), 5530 SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI), 5531 {} 5532 }; 5533 5534 static const struct hda_model_fixup alc269_fixup_models[] = { 5535 {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"}, 5536 {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"}, 5537 {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"}, 5538 {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"}, 5539 {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"}, 5540 {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"}, 5541 {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"}, 5542 {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"}, 5543 {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"}, 5544 {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"}, 5545 {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"}, 5546 {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"}, 5547 {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"}, 5548 {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"}, 5549 {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"}, 5550 {.id = ALC292_FIXUP_TPT440, .name = "tpt440"}, 5551 {} 5552 }; 5553 5554 #define ALC256_STANDARD_PINS \ 5555 {0x12, 0x90a60140}, \ 5556 {0x14, 0x90170110}, \ 5557 {0x21, 0x02211020} 5558 5559 #define ALC282_STANDARD_PINS \ 5560 {0x14, 0x90170110} 5561 5562 #define ALC290_STANDARD_PINS \ 5563 {0x12, 0x99a30130} 5564 5565 #define ALC292_STANDARD_PINS \ 5566 {0x14, 0x90170110}, \ 5567 {0x15, 0x0221401f} 5568 5569 #define ALC298_STANDARD_PINS \ 5570 {0x12, 0x90a60130}, \ 5571 {0x21, 0x03211020} 5572 5573 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = { 5574 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, 5575 {0x14, 0x90170110}, 5576 {0x21, 0x02211020}), 5577 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 5578 {0x12, 0x90a60140}, 5579 {0x14, 0x90170110}, 5580 {0x21, 0x02211020}), 5581 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 5582 {0x12, 0x90a60160}, 5583 {0x14, 0x90170120}, 5584 {0x21, 0x02211030}), 5585 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 5586 {0x14, 0x90170130}, 5587 {0x1b, 0x01014020}, 5588 {0x21, 0x0221103f}), 5589 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 5590 {0x14, 0x90170150}, 5591 {0x1b, 0x02011020}, 5592 {0x21, 0x0221105f}), 5593 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 5594 {0x14, 0x90170110}, 5595 {0x1b, 0x01014020}, 5596 {0x21, 0x0221101f}), 5597 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 5598 {0x12, 0x90a60160}, 5599 {0x14, 0x90170120}, 5600 {0x17, 0x90170140}, 5601 {0x21, 0x0321102f}), 5602 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 5603 {0x12, 0x90a60160}, 5604 {0x14, 0x90170130}, 5605 {0x21, 0x02211040}), 5606 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 5607 {0x12, 0x90a60160}, 5608 {0x14, 0x90170140}, 5609 {0x21, 0x02211050}), 5610 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 5611 {0x12, 0x90a60170}, 5612 {0x14, 0x90170120}, 5613 {0x21, 0x02211030}), 5614 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 5615 {0x12, 0x90a60170}, 5616 {0x14, 0x90170130}, 5617 {0x21, 0x02211040}), 5618 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 5619 {0x12, 0x90a60170}, 5620 {0x14, 0x90170140}, 5621 {0x21, 0x02211050}), 5622 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 5623 {0x12, 0x90a60180}, 5624 {0x14, 0x90170130}, 5625 {0x21, 0x02211040}), 5626 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 5627 {0x12, 0x90a60160}, 5628 {0x14, 0x90170120}, 5629 {0x21, 0x02211030}), 5630 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, 5631 ALC256_STANDARD_PINS), 5632 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4, 5633 {0x12, 0x90a60130}, 5634 {0x14, 0x90170110}, 5635 {0x15, 0x0421101f}, 5636 {0x1a, 0x04a11020}), 5637 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED, 5638 {0x12, 0x90a60140}, 5639 {0x14, 0x90170110}, 5640 {0x15, 0x0421101f}, 5641 {0x18, 0x02811030}, 5642 {0x1a, 0x04a1103f}, 5643 {0x1b, 0x02011020}), 5644 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1, 5645 ALC282_STANDARD_PINS, 5646 {0x12, 0x99a30130}, 5647 {0x19, 0x03a11020}, 5648 {0x21, 0x0321101f}), 5649 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 5650 ALC282_STANDARD_PINS, 5651 {0x12, 0x99a30130}, 5652 {0x19, 0x03a11020}, 5653 {0x21, 0x03211040}), 5654 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 5655 ALC282_STANDARD_PINS, 5656 {0x12, 0x99a30130}, 5657 {0x19, 0x03a11030}, 5658 {0x21, 0x03211020}), 5659 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 5660 ALC282_STANDARD_PINS, 5661 {0x12, 0x99a30130}, 5662 {0x19, 0x04a11020}, 5663 {0x21, 0x0421101f}), 5664 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED, 5665 ALC282_STANDARD_PINS, 5666 {0x12, 0x90a60140}, 5667 {0x19, 0x04a11030}, 5668 {0x21, 0x04211020}), 5669 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 5670 ALC282_STANDARD_PINS, 5671 {0x12, 0x90a60130}, 5672 {0x21, 0x0321101f}), 5673 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 5674 {0x12, 0x90a60160}, 5675 {0x14, 0x90170120}, 5676 {0x21, 0x02211030}), 5677 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, 5678 ALC282_STANDARD_PINS, 5679 {0x12, 0x90a60130}, 5680 {0x19, 0x03a11020}, 5681 {0x21, 0x0321101f}), 5682 SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL_XPS_13_GPIO6, 5683 {0x12, 0x90a60120}, 5684 {0x14, 0x90170110}, 5685 {0x21, 0x0321101f}), 5686 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 5687 ALC290_STANDARD_PINS, 5688 {0x15, 0x04211040}, 5689 {0x18, 0x90170112}, 5690 {0x1a, 0x04a11020}), 5691 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 5692 ALC290_STANDARD_PINS, 5693 {0x15, 0x04211040}, 5694 {0x18, 0x90170110}, 5695 {0x1a, 0x04a11020}), 5696 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 5697 ALC290_STANDARD_PINS, 5698 {0x15, 0x0421101f}, 5699 {0x1a, 0x04a11020}), 5700 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 5701 ALC290_STANDARD_PINS, 5702 {0x15, 0x04211020}, 5703 {0x1a, 0x04a11040}), 5704 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 5705 ALC290_STANDARD_PINS, 5706 {0x14, 0x90170110}, 5707 {0x15, 0x04211020}, 5708 {0x1a, 0x04a11040}), 5709 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 5710 ALC290_STANDARD_PINS, 5711 {0x14, 0x90170110}, 5712 {0x15, 0x04211020}, 5713 {0x1a, 0x04a11020}), 5714 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1, 5715 ALC290_STANDARD_PINS, 5716 {0x14, 0x90170110}, 5717 {0x15, 0x0421101f}, 5718 {0x1a, 0x04a11020}), 5719 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, 5720 ALC292_STANDARD_PINS, 5721 {0x12, 0x90a60140}, 5722 {0x16, 0x01014020}, 5723 {0x19, 0x01a19030}), 5724 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, 5725 ALC292_STANDARD_PINS, 5726 {0x12, 0x90a60140}, 5727 {0x16, 0x01014020}, 5728 {0x18, 0x02a19031}, 5729 {0x19, 0x01a1903e}), 5730 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, 5731 ALC292_STANDARD_PINS, 5732 {0x12, 0x90a60140}), 5733 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, 5734 ALC292_STANDARD_PINS, 5735 {0x13, 0x90a60140}, 5736 {0x16, 0x21014020}, 5737 {0x19, 0x21a19030}), 5738 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, 5739 ALC292_STANDARD_PINS, 5740 {0x13, 0x90a60140}), 5741 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 5742 ALC298_STANDARD_PINS, 5743 {0x17, 0x90170110}), 5744 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 5745 ALC298_STANDARD_PINS, 5746 {0x17, 0x90170140}), 5747 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, 5748 ALC298_STANDARD_PINS, 5749 {0x17, 0x90170150}), 5750 {} 5751 }; 5752 5753 static void alc269_fill_coef(struct hda_codec *codec) 5754 { 5755 struct alc_spec *spec = codec->spec; 5756 int val; 5757 5758 if (spec->codec_variant != ALC269_TYPE_ALC269VB) 5759 return; 5760 5761 if ((alc_get_coef0(codec) & 0x00ff) < 0x015) { 5762 alc_write_coef_idx(codec, 0xf, 0x960b); 5763 alc_write_coef_idx(codec, 0xe, 0x8817); 5764 } 5765 5766 if ((alc_get_coef0(codec) & 0x00ff) == 0x016) { 5767 alc_write_coef_idx(codec, 0xf, 0x960b); 5768 alc_write_coef_idx(codec, 0xe, 0x8814); 5769 } 5770 5771 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) { 5772 /* Power up output pin */ 5773 alc_update_coef_idx(codec, 0x04, 0, 1<<11); 5774 } 5775 5776 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) { 5777 val = alc_read_coef_idx(codec, 0xd); 5778 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) { 5779 /* Capless ramp up clock control */ 5780 alc_write_coef_idx(codec, 0xd, val | (1<<10)); 5781 } 5782 val = alc_read_coef_idx(codec, 0x17); 5783 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) { 5784 /* Class D power on reset */ 5785 alc_write_coef_idx(codec, 0x17, val | (1<<7)); 5786 } 5787 } 5788 5789 /* HP */ 5790 alc_update_coef_idx(codec, 0x4, 0, 1<<11); 5791 } 5792 5793 /* 5794 */ 5795 static int patch_alc269(struct hda_codec *codec) 5796 { 5797 struct alc_spec *spec; 5798 int err; 5799 5800 err = alc_alloc_spec(codec, 0x0b); 5801 if (err < 0) 5802 return err; 5803 5804 spec = codec->spec; 5805 spec->gen.shared_mic_vref_pin = 0x18; 5806 codec->power_save_node = 1; 5807 5808 #ifdef CONFIG_PM 5809 codec->patch_ops.suspend = alc269_suspend; 5810 codec->patch_ops.resume = alc269_resume; 5811 #endif 5812 spec->shutup = alc269_shutup; 5813 5814 snd_hda_pick_fixup(codec, alc269_fixup_models, 5815 alc269_fixup_tbl, alc269_fixups); 5816 snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups); 5817 snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl, 5818 alc269_fixups); 5819 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 5820 5821 alc_auto_parse_customize_define(codec); 5822 5823 if (has_cdefine_beep(codec)) 5824 spec->gen.beep_nid = 0x01; 5825 5826 switch (codec->core.vendor_id) { 5827 case 0x10ec0269: 5828 spec->codec_variant = ALC269_TYPE_ALC269VA; 5829 switch (alc_get_coef0(codec) & 0x00f0) { 5830 case 0x0010: 5831 if (codec->bus->pci && 5832 codec->bus->pci->subsystem_vendor == 0x1025 && 5833 spec->cdefine.platform_type == 1) 5834 err = alc_codec_rename(codec, "ALC271X"); 5835 spec->codec_variant = ALC269_TYPE_ALC269VB; 5836 break; 5837 case 0x0020: 5838 if (codec->bus->pci && 5839 codec->bus->pci->subsystem_vendor == 0x17aa && 5840 codec->bus->pci->subsystem_device == 0x21f3) 5841 err = alc_codec_rename(codec, "ALC3202"); 5842 spec->codec_variant = ALC269_TYPE_ALC269VC; 5843 break; 5844 case 0x0030: 5845 spec->codec_variant = ALC269_TYPE_ALC269VD; 5846 break; 5847 default: 5848 alc_fix_pll_init(codec, 0x20, 0x04, 15); 5849 } 5850 if (err < 0) 5851 goto error; 5852 spec->init_hook = alc269_fill_coef; 5853 alc269_fill_coef(codec); 5854 break; 5855 5856 case 0x10ec0280: 5857 case 0x10ec0290: 5858 spec->codec_variant = ALC269_TYPE_ALC280; 5859 break; 5860 case 0x10ec0282: 5861 spec->codec_variant = ALC269_TYPE_ALC282; 5862 spec->shutup = alc282_shutup; 5863 spec->init_hook = alc282_init; 5864 break; 5865 case 0x10ec0233: 5866 case 0x10ec0283: 5867 spec->codec_variant = ALC269_TYPE_ALC283; 5868 spec->shutup = alc283_shutup; 5869 spec->init_hook = alc283_init; 5870 break; 5871 case 0x10ec0284: 5872 case 0x10ec0292: 5873 spec->codec_variant = ALC269_TYPE_ALC284; 5874 break; 5875 case 0x10ec0285: 5876 case 0x10ec0293: 5877 spec->codec_variant = ALC269_TYPE_ALC285; 5878 break; 5879 case 0x10ec0286: 5880 case 0x10ec0288: 5881 spec->codec_variant = ALC269_TYPE_ALC286; 5882 spec->shutup = alc286_shutup; 5883 break; 5884 case 0x10ec0298: 5885 spec->codec_variant = ALC269_TYPE_ALC298; 5886 break; 5887 case 0x10ec0255: 5888 spec->codec_variant = ALC269_TYPE_ALC255; 5889 break; 5890 case 0x10ec0256: 5891 spec->codec_variant = ALC269_TYPE_ALC256; 5892 spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */ 5893 alc_update_coef_idx(codec, 0x36, 1 << 13, 1 << 5); /* Switch pcbeep path to Line in path*/ 5894 break; 5895 } 5896 5897 if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) { 5898 spec->has_alc5505_dsp = 1; 5899 spec->init_hook = alc5505_dsp_init; 5900 } 5901 5902 /* automatic parse from the BIOS config */ 5903 err = alc269_parse_auto_config(codec); 5904 if (err < 0) 5905 goto error; 5906 5907 if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) 5908 set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT); 5909 5910 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 5911 5912 return 0; 5913 5914 error: 5915 alc_free(codec); 5916 return err; 5917 } 5918 5919 /* 5920 * ALC861 5921 */ 5922 5923 static int alc861_parse_auto_config(struct hda_codec *codec) 5924 { 5925 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 }; 5926 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 }; 5927 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids); 5928 } 5929 5930 /* Pin config fixes */ 5931 enum { 5932 ALC861_FIXUP_FSC_AMILO_PI1505, 5933 ALC861_FIXUP_AMP_VREF_0F, 5934 ALC861_FIXUP_NO_JACK_DETECT, 5935 ALC861_FIXUP_ASUS_A6RP, 5936 ALC660_FIXUP_ASUS_W7J, 5937 }; 5938 5939 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */ 5940 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec, 5941 const struct hda_fixup *fix, int action) 5942 { 5943 struct alc_spec *spec = codec->spec; 5944 unsigned int val; 5945 5946 if (action != HDA_FIXUP_ACT_INIT) 5947 return; 5948 val = snd_hda_codec_get_pin_target(codec, 0x0f); 5949 if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))) 5950 val |= AC_PINCTL_IN_EN; 5951 val |= AC_PINCTL_VREF_50; 5952 snd_hda_set_pin_ctl(codec, 0x0f, val); 5953 spec->gen.keep_vref_in_automute = 1; 5954 } 5955 5956 /* suppress the jack-detection */ 5957 static void alc_fixup_no_jack_detect(struct hda_codec *codec, 5958 const struct hda_fixup *fix, int action) 5959 { 5960 if (action == HDA_FIXUP_ACT_PRE_PROBE) 5961 codec->no_jack_detect = 1; 5962 } 5963 5964 static const struct hda_fixup alc861_fixups[] = { 5965 [ALC861_FIXUP_FSC_AMILO_PI1505] = { 5966 .type = HDA_FIXUP_PINS, 5967 .v.pins = (const struct hda_pintbl[]) { 5968 { 0x0b, 0x0221101f }, /* HP */ 5969 { 0x0f, 0x90170310 }, /* speaker */ 5970 { } 5971 } 5972 }, 5973 [ALC861_FIXUP_AMP_VREF_0F] = { 5974 .type = HDA_FIXUP_FUNC, 5975 .v.func = alc861_fixup_asus_amp_vref_0f, 5976 }, 5977 [ALC861_FIXUP_NO_JACK_DETECT] = { 5978 .type = HDA_FIXUP_FUNC, 5979 .v.func = alc_fixup_no_jack_detect, 5980 }, 5981 [ALC861_FIXUP_ASUS_A6RP] = { 5982 .type = HDA_FIXUP_FUNC, 5983 .v.func = alc861_fixup_asus_amp_vref_0f, 5984 .chained = true, 5985 .chain_id = ALC861_FIXUP_NO_JACK_DETECT, 5986 }, 5987 [ALC660_FIXUP_ASUS_W7J] = { 5988 .type = HDA_FIXUP_VERBS, 5989 .v.verbs = (const struct hda_verb[]) { 5990 /* ASUS W7J needs a magic pin setup on unused NID 0x10 5991 * for enabling outputs 5992 */ 5993 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 5994 { } 5995 }, 5996 } 5997 }; 5998 5999 static const struct snd_pci_quirk alc861_fixup_tbl[] = { 6000 SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J), 6001 SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J), 6002 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP), 6003 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F), 6004 SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT), 6005 SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F), 6006 SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F), 6007 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505), 6008 {} 6009 }; 6010 6011 /* 6012 */ 6013 static int patch_alc861(struct hda_codec *codec) 6014 { 6015 struct alc_spec *spec; 6016 int err; 6017 6018 err = alc_alloc_spec(codec, 0x15); 6019 if (err < 0) 6020 return err; 6021 6022 spec = codec->spec; 6023 spec->gen.beep_nid = 0x23; 6024 6025 #ifdef CONFIG_PM 6026 spec->power_hook = alc_power_eapd; 6027 #endif 6028 6029 snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups); 6030 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 6031 6032 /* automatic parse from the BIOS config */ 6033 err = alc861_parse_auto_config(codec); 6034 if (err < 0) 6035 goto error; 6036 6037 if (!spec->gen.no_analog) 6038 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT); 6039 6040 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 6041 6042 return 0; 6043 6044 error: 6045 alc_free(codec); 6046 return err; 6047 } 6048 6049 /* 6050 * ALC861-VD support 6051 * 6052 * Based on ALC882 6053 * 6054 * In addition, an independent DAC 6055 */ 6056 static int alc861vd_parse_auto_config(struct hda_codec *codec) 6057 { 6058 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 }; 6059 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 6060 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids); 6061 } 6062 6063 enum { 6064 ALC660VD_FIX_ASUS_GPIO1, 6065 ALC861VD_FIX_DALLAS, 6066 }; 6067 6068 /* exclude VREF80 */ 6069 static void alc861vd_fixup_dallas(struct hda_codec *codec, 6070 const struct hda_fixup *fix, int action) 6071 { 6072 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6073 snd_hda_override_pin_caps(codec, 0x18, 0x00000734); 6074 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c); 6075 } 6076 } 6077 6078 static const struct hda_fixup alc861vd_fixups[] = { 6079 [ALC660VD_FIX_ASUS_GPIO1] = { 6080 .type = HDA_FIXUP_VERBS, 6081 .v.verbs = (const struct hda_verb[]) { 6082 /* reset GPIO1 */ 6083 {0x01, AC_VERB_SET_GPIO_MASK, 0x03}, 6084 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, 6085 {0x01, AC_VERB_SET_GPIO_DATA, 0x01}, 6086 { } 6087 } 6088 }, 6089 [ALC861VD_FIX_DALLAS] = { 6090 .type = HDA_FIXUP_FUNC, 6091 .v.func = alc861vd_fixup_dallas, 6092 }, 6093 }; 6094 6095 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = { 6096 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS), 6097 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1), 6098 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS), 6099 {} 6100 }; 6101 6102 /* 6103 */ 6104 static int patch_alc861vd(struct hda_codec *codec) 6105 { 6106 struct alc_spec *spec; 6107 int err; 6108 6109 err = alc_alloc_spec(codec, 0x0b); 6110 if (err < 0) 6111 return err; 6112 6113 spec = codec->spec; 6114 spec->gen.beep_nid = 0x23; 6115 6116 spec->shutup = alc_eapd_shutup; 6117 6118 snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups); 6119 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 6120 6121 /* automatic parse from the BIOS config */ 6122 err = alc861vd_parse_auto_config(codec); 6123 if (err < 0) 6124 goto error; 6125 6126 if (!spec->gen.no_analog) 6127 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 6128 6129 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 6130 6131 return 0; 6132 6133 error: 6134 alc_free(codec); 6135 return err; 6136 } 6137 6138 /* 6139 * ALC662 support 6140 * 6141 * ALC662 is almost identical with ALC880 but has cleaner and more flexible 6142 * configuration. Each pin widget can choose any input DACs and a mixer. 6143 * Each ADC is connected from a mixer of all inputs. This makes possible 6144 * 6-channel independent captures. 6145 * 6146 * In addition, an independent DAC for the multi-playback (not used in this 6147 * driver yet). 6148 */ 6149 6150 /* 6151 * BIOS auto configuration 6152 */ 6153 6154 static int alc662_parse_auto_config(struct hda_codec *codec) 6155 { 6156 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 }; 6157 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 }; 6158 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 6159 const hda_nid_t *ssids; 6160 6161 if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 || 6162 codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 || 6163 codec->core.vendor_id == 0x10ec0671) 6164 ssids = alc663_ssids; 6165 else 6166 ssids = alc662_ssids; 6167 return alc_parse_auto_config(codec, alc662_ignore, ssids); 6168 } 6169 6170 static void alc272_fixup_mario(struct hda_codec *codec, 6171 const struct hda_fixup *fix, int action) 6172 { 6173 if (action != HDA_FIXUP_ACT_PRE_PROBE) 6174 return; 6175 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT, 6176 (0x3b << AC_AMPCAP_OFFSET_SHIFT) | 6177 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) | 6178 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) | 6179 (0 << AC_AMPCAP_MUTE_SHIFT))) 6180 codec_warn(codec, "failed to override amp caps for NID 0x2\n"); 6181 } 6182 6183 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = { 6184 { .channels = 2, 6185 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } }, 6186 { .channels = 4, 6187 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, 6188 SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */ 6189 { } 6190 }; 6191 6192 /* override the 2.1 chmap */ 6193 static void alc_fixup_bass_chmap(struct hda_codec *codec, 6194 const struct hda_fixup *fix, int action) 6195 { 6196 if (action == HDA_FIXUP_ACT_BUILD) { 6197 struct alc_spec *spec = codec->spec; 6198 spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps; 6199 } 6200 } 6201 6202 /* avoid D3 for keeping GPIO up */ 6203 static unsigned int gpio_led_power_filter(struct hda_codec *codec, 6204 hda_nid_t nid, 6205 unsigned int power_state) 6206 { 6207 struct alc_spec *spec = codec->spec; 6208 if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_led) 6209 return AC_PWRST_D0; 6210 return power_state; 6211 } 6212 6213 static void alc662_fixup_led_gpio1(struct hda_codec *codec, 6214 const struct hda_fixup *fix, int action) 6215 { 6216 struct alc_spec *spec = codec->spec; 6217 static const struct hda_verb gpio_init[] = { 6218 { 0x01, AC_VERB_SET_GPIO_MASK, 0x01 }, 6219 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01 }, 6220 {} 6221 }; 6222 6223 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 6224 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook; 6225 spec->gpio_led = 0; 6226 spec->mute_led_polarity = 1; 6227 spec->gpio_mute_led_mask = 0x01; 6228 snd_hda_add_verbs(codec, gpio_init); 6229 codec->power_filter = gpio_led_power_filter; 6230 } 6231 } 6232 6233 static struct coef_fw alc668_coefs[] = { 6234 WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03, 0x0), 6235 WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06, 0x0), WRITE_COEF(0x07, 0x0f80), 6236 WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b, 0x0), 6237 WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f), 6238 WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001), 6239 WRITE_COEF(0x13, 0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940), 6240 WRITE_COEF(0x19, 0x0), WRITE_COEF(0x1a, 0x0), WRITE_COEF(0x1b, 0x0), 6241 WRITE_COEF(0x1c, 0x0), WRITE_COEF(0x1d, 0x0), WRITE_COEF(0x1e, 0x7418), 6242 WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468), 6243 WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418), 6244 WRITE_COEF(0x27, 0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00), 6245 WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000), 6246 WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac, 0x0), 6247 WRITE_COEF(0xad, 0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480), 6248 WRITE_COEF(0xb0, 0x0), WRITE_COEF(0xb1, 0x0), WRITE_COEF(0xb2, 0x0), 6249 WRITE_COEF(0xb3, 0x0), WRITE_COEF(0xb4, 0x0), WRITE_COEF(0xb5, 0x1040), 6250 WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697), 6251 WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab), 6252 WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02), 6253 WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6), 6254 {} 6255 }; 6256 6257 static void alc668_restore_default_value(struct hda_codec *codec) 6258 { 6259 alc_process_coef_fw(codec, alc668_coefs); 6260 } 6261 6262 enum { 6263 ALC662_FIXUP_ASPIRE, 6264 ALC662_FIXUP_LED_GPIO1, 6265 ALC662_FIXUP_IDEAPAD, 6266 ALC272_FIXUP_MARIO, 6267 ALC662_FIXUP_CZC_P10T, 6268 ALC662_FIXUP_SKU_IGNORE, 6269 ALC662_FIXUP_HP_RP5800, 6270 ALC662_FIXUP_ASUS_MODE1, 6271 ALC662_FIXUP_ASUS_MODE2, 6272 ALC662_FIXUP_ASUS_MODE3, 6273 ALC662_FIXUP_ASUS_MODE4, 6274 ALC662_FIXUP_ASUS_MODE5, 6275 ALC662_FIXUP_ASUS_MODE6, 6276 ALC662_FIXUP_ASUS_MODE7, 6277 ALC662_FIXUP_ASUS_MODE8, 6278 ALC662_FIXUP_NO_JACK_DETECT, 6279 ALC662_FIXUP_ZOTAC_Z68, 6280 ALC662_FIXUP_INV_DMIC, 6281 ALC662_FIXUP_DELL_MIC_NO_PRESENCE, 6282 ALC668_FIXUP_DELL_MIC_NO_PRESENCE, 6283 ALC662_FIXUP_HEADSET_MODE, 6284 ALC668_FIXUP_HEADSET_MODE, 6285 ALC662_FIXUP_BASS_MODE4_CHMAP, 6286 ALC662_FIXUP_BASS_16, 6287 ALC662_FIXUP_BASS_1A, 6288 ALC662_FIXUP_BASS_CHMAP, 6289 ALC668_FIXUP_AUTO_MUTE, 6290 ALC668_FIXUP_DELL_DISABLE_AAMIX, 6291 ALC668_FIXUP_DELL_XPS13, 6292 }; 6293 6294 static const struct hda_fixup alc662_fixups[] = { 6295 [ALC662_FIXUP_ASPIRE] = { 6296 .type = HDA_FIXUP_PINS, 6297 .v.pins = (const struct hda_pintbl[]) { 6298 { 0x15, 0x99130112 }, /* subwoofer */ 6299 { } 6300 } 6301 }, 6302 [ALC662_FIXUP_LED_GPIO1] = { 6303 .type = HDA_FIXUP_FUNC, 6304 .v.func = alc662_fixup_led_gpio1, 6305 }, 6306 [ALC662_FIXUP_IDEAPAD] = { 6307 .type = HDA_FIXUP_PINS, 6308 .v.pins = (const struct hda_pintbl[]) { 6309 { 0x17, 0x99130112 }, /* subwoofer */ 6310 { } 6311 }, 6312 .chained = true, 6313 .chain_id = ALC662_FIXUP_LED_GPIO1, 6314 }, 6315 [ALC272_FIXUP_MARIO] = { 6316 .type = HDA_FIXUP_FUNC, 6317 .v.func = alc272_fixup_mario, 6318 }, 6319 [ALC662_FIXUP_CZC_P10T] = { 6320 .type = HDA_FIXUP_VERBS, 6321 .v.verbs = (const struct hda_verb[]) { 6322 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0}, 6323 {} 6324 } 6325 }, 6326 [ALC662_FIXUP_SKU_IGNORE] = { 6327 .type = HDA_FIXUP_FUNC, 6328 .v.func = alc_fixup_sku_ignore, 6329 }, 6330 [ALC662_FIXUP_HP_RP5800] = { 6331 .type = HDA_FIXUP_PINS, 6332 .v.pins = (const struct hda_pintbl[]) { 6333 { 0x14, 0x0221201f }, /* HP out */ 6334 { } 6335 }, 6336 .chained = true, 6337 .chain_id = ALC662_FIXUP_SKU_IGNORE 6338 }, 6339 [ALC662_FIXUP_ASUS_MODE1] = { 6340 .type = HDA_FIXUP_PINS, 6341 .v.pins = (const struct hda_pintbl[]) { 6342 { 0x14, 0x99130110 }, /* speaker */ 6343 { 0x18, 0x01a19c20 }, /* mic */ 6344 { 0x19, 0x99a3092f }, /* int-mic */ 6345 { 0x21, 0x0121401f }, /* HP out */ 6346 { } 6347 }, 6348 .chained = true, 6349 .chain_id = ALC662_FIXUP_SKU_IGNORE 6350 }, 6351 [ALC662_FIXUP_ASUS_MODE2] = { 6352 .type = HDA_FIXUP_PINS, 6353 .v.pins = (const struct hda_pintbl[]) { 6354 { 0x14, 0x99130110 }, /* speaker */ 6355 { 0x18, 0x01a19820 }, /* mic */ 6356 { 0x19, 0x99a3092f }, /* int-mic */ 6357 { 0x1b, 0x0121401f }, /* HP out */ 6358 { } 6359 }, 6360 .chained = true, 6361 .chain_id = ALC662_FIXUP_SKU_IGNORE 6362 }, 6363 [ALC662_FIXUP_ASUS_MODE3] = { 6364 .type = HDA_FIXUP_PINS, 6365 .v.pins = (const struct hda_pintbl[]) { 6366 { 0x14, 0x99130110 }, /* speaker */ 6367 { 0x15, 0x0121441f }, /* HP */ 6368 { 0x18, 0x01a19840 }, /* mic */ 6369 { 0x19, 0x99a3094f }, /* int-mic */ 6370 { 0x21, 0x01211420 }, /* HP2 */ 6371 { } 6372 }, 6373 .chained = true, 6374 .chain_id = ALC662_FIXUP_SKU_IGNORE 6375 }, 6376 [ALC662_FIXUP_ASUS_MODE4] = { 6377 .type = HDA_FIXUP_PINS, 6378 .v.pins = (const struct hda_pintbl[]) { 6379 { 0x14, 0x99130110 }, /* speaker */ 6380 { 0x16, 0x99130111 }, /* speaker */ 6381 { 0x18, 0x01a19840 }, /* mic */ 6382 { 0x19, 0x99a3094f }, /* int-mic */ 6383 { 0x21, 0x0121441f }, /* HP */ 6384 { } 6385 }, 6386 .chained = true, 6387 .chain_id = ALC662_FIXUP_SKU_IGNORE 6388 }, 6389 [ALC662_FIXUP_ASUS_MODE5] = { 6390 .type = HDA_FIXUP_PINS, 6391 .v.pins = (const struct hda_pintbl[]) { 6392 { 0x14, 0x99130110 }, /* speaker */ 6393 { 0x15, 0x0121441f }, /* HP */ 6394 { 0x16, 0x99130111 }, /* speaker */ 6395 { 0x18, 0x01a19840 }, /* mic */ 6396 { 0x19, 0x99a3094f }, /* int-mic */ 6397 { } 6398 }, 6399 .chained = true, 6400 .chain_id = ALC662_FIXUP_SKU_IGNORE 6401 }, 6402 [ALC662_FIXUP_ASUS_MODE6] = { 6403 .type = HDA_FIXUP_PINS, 6404 .v.pins = (const struct hda_pintbl[]) { 6405 { 0x14, 0x99130110 }, /* speaker */ 6406 { 0x15, 0x01211420 }, /* HP2 */ 6407 { 0x18, 0x01a19840 }, /* mic */ 6408 { 0x19, 0x99a3094f }, /* int-mic */ 6409 { 0x1b, 0x0121441f }, /* HP */ 6410 { } 6411 }, 6412 .chained = true, 6413 .chain_id = ALC662_FIXUP_SKU_IGNORE 6414 }, 6415 [ALC662_FIXUP_ASUS_MODE7] = { 6416 .type = HDA_FIXUP_PINS, 6417 .v.pins = (const struct hda_pintbl[]) { 6418 { 0x14, 0x99130110 }, /* speaker */ 6419 { 0x17, 0x99130111 }, /* speaker */ 6420 { 0x18, 0x01a19840 }, /* mic */ 6421 { 0x19, 0x99a3094f }, /* int-mic */ 6422 { 0x1b, 0x01214020 }, /* HP */ 6423 { 0x21, 0x0121401f }, /* HP */ 6424 { } 6425 }, 6426 .chained = true, 6427 .chain_id = ALC662_FIXUP_SKU_IGNORE 6428 }, 6429 [ALC662_FIXUP_ASUS_MODE8] = { 6430 .type = HDA_FIXUP_PINS, 6431 .v.pins = (const struct hda_pintbl[]) { 6432 { 0x14, 0x99130110 }, /* speaker */ 6433 { 0x12, 0x99a30970 }, /* int-mic */ 6434 { 0x15, 0x01214020 }, /* HP */ 6435 { 0x17, 0x99130111 }, /* speaker */ 6436 { 0x18, 0x01a19840 }, /* mic */ 6437 { 0x21, 0x0121401f }, /* HP */ 6438 { } 6439 }, 6440 .chained = true, 6441 .chain_id = ALC662_FIXUP_SKU_IGNORE 6442 }, 6443 [ALC662_FIXUP_NO_JACK_DETECT] = { 6444 .type = HDA_FIXUP_FUNC, 6445 .v.func = alc_fixup_no_jack_detect, 6446 }, 6447 [ALC662_FIXUP_ZOTAC_Z68] = { 6448 .type = HDA_FIXUP_PINS, 6449 .v.pins = (const struct hda_pintbl[]) { 6450 { 0x1b, 0x02214020 }, /* Front HP */ 6451 { } 6452 } 6453 }, 6454 [ALC662_FIXUP_INV_DMIC] = { 6455 .type = HDA_FIXUP_FUNC, 6456 .v.func = alc_fixup_inv_dmic, 6457 }, 6458 [ALC668_FIXUP_DELL_XPS13] = { 6459 .type = HDA_FIXUP_FUNC, 6460 .v.func = alc_fixup_dell_xps13, 6461 .chained = true, 6462 .chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX 6463 }, 6464 [ALC668_FIXUP_DELL_DISABLE_AAMIX] = { 6465 .type = HDA_FIXUP_FUNC, 6466 .v.func = alc_fixup_disable_aamix, 6467 .chained = true, 6468 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE 6469 }, 6470 [ALC668_FIXUP_AUTO_MUTE] = { 6471 .type = HDA_FIXUP_FUNC, 6472 .v.func = alc_fixup_auto_mute_via_amp, 6473 .chained = true, 6474 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE 6475 }, 6476 [ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = { 6477 .type = HDA_FIXUP_PINS, 6478 .v.pins = (const struct hda_pintbl[]) { 6479 { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */ 6480 /* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */ 6481 { } 6482 }, 6483 .chained = true, 6484 .chain_id = ALC662_FIXUP_HEADSET_MODE 6485 }, 6486 [ALC662_FIXUP_HEADSET_MODE] = { 6487 .type = HDA_FIXUP_FUNC, 6488 .v.func = alc_fixup_headset_mode_alc662, 6489 }, 6490 [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = { 6491 .type = HDA_FIXUP_PINS, 6492 .v.pins = (const struct hda_pintbl[]) { 6493 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */ 6494 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */ 6495 { } 6496 }, 6497 .chained = true, 6498 .chain_id = ALC668_FIXUP_HEADSET_MODE 6499 }, 6500 [ALC668_FIXUP_HEADSET_MODE] = { 6501 .type = HDA_FIXUP_FUNC, 6502 .v.func = alc_fixup_headset_mode_alc668, 6503 }, 6504 [ALC662_FIXUP_BASS_MODE4_CHMAP] = { 6505 .type = HDA_FIXUP_FUNC, 6506 .v.func = alc_fixup_bass_chmap, 6507 .chained = true, 6508 .chain_id = ALC662_FIXUP_ASUS_MODE4 6509 }, 6510 [ALC662_FIXUP_BASS_16] = { 6511 .type = HDA_FIXUP_PINS, 6512 .v.pins = (const struct hda_pintbl[]) { 6513 {0x16, 0x80106111}, /* bass speaker */ 6514 {} 6515 }, 6516 .chained = true, 6517 .chain_id = ALC662_FIXUP_BASS_CHMAP, 6518 }, 6519 [ALC662_FIXUP_BASS_1A] = { 6520 .type = HDA_FIXUP_PINS, 6521 .v.pins = (const struct hda_pintbl[]) { 6522 {0x1a, 0x80106111}, /* bass speaker */ 6523 {} 6524 }, 6525 .chained = true, 6526 .chain_id = ALC662_FIXUP_BASS_CHMAP, 6527 }, 6528 [ALC662_FIXUP_BASS_CHMAP] = { 6529 .type = HDA_FIXUP_FUNC, 6530 .v.func = alc_fixup_bass_chmap, 6531 }, 6532 }; 6533 6534 static const struct snd_pci_quirk alc662_fixup_tbl[] = { 6535 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2), 6536 SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC), 6537 SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC), 6538 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE), 6539 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE), 6540 SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC), 6541 SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC), 6542 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE), 6543 SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 6544 SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 6545 SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13), 6546 SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13), 6547 SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13), 6548 SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 6549 SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 6550 SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 6551 SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 6552 SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE), 6553 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800), 6554 SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_BASS_1A), 6555 SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP), 6556 SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16), 6557 SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16), 6558 SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP), 6559 SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT), 6560 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2), 6561 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD), 6562 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD), 6563 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD), 6564 SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68), 6565 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T), 6566 6567 #if 0 6568 /* Below is a quirk table taken from the old code. 6569 * Basically the device should work as is without the fixup table. 6570 * If BIOS doesn't give a proper info, enable the corresponding 6571 * fixup entry. 6572 */ 6573 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1), 6574 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3), 6575 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1), 6576 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3), 6577 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 6578 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 6579 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 6580 SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1), 6581 SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1), 6582 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 6583 SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7), 6584 SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7), 6585 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8), 6586 SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3), 6587 SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1), 6588 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 6589 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2), 6590 SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1), 6591 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 6592 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6), 6593 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6), 6594 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 6595 SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1), 6596 SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3), 6597 SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2), 6598 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 6599 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5), 6600 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6), 6601 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 6602 SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1), 6603 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 6604 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 6605 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3), 6606 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3), 6607 SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1), 6608 SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1), 6609 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1), 6610 SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1), 6611 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1), 6612 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 6613 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2), 6614 SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1), 6615 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 6616 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3), 6617 SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1), 6618 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1), 6619 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1), 6620 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2), 6621 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 6622 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4), 6623 #endif 6624 {} 6625 }; 6626 6627 static const struct hda_model_fixup alc662_fixup_models[] = { 6628 {.id = ALC272_FIXUP_MARIO, .name = "mario"}, 6629 {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"}, 6630 {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"}, 6631 {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"}, 6632 {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"}, 6633 {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"}, 6634 {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"}, 6635 {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"}, 6636 {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"}, 6637 {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"}, 6638 {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"}, 6639 {} 6640 }; 6641 6642 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = { 6643 SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE, 6644 {0x14, 0x01014010}, 6645 {0x18, 0x01a19020}, 6646 {0x1a, 0x0181302f}, 6647 {0x1b, 0x0221401f}), 6648 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE, 6649 {0x12, 0x99a30130}, 6650 {0x14, 0x90170110}, 6651 {0x15, 0x0321101f}, 6652 {0x16, 0x03011020}), 6653 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE, 6654 {0x12, 0x99a30140}, 6655 {0x14, 0x90170110}, 6656 {0x15, 0x0321101f}, 6657 {0x16, 0x03011020}), 6658 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE, 6659 {0x12, 0x99a30150}, 6660 {0x14, 0x90170110}, 6661 {0x15, 0x0321101f}, 6662 {0x16, 0x03011020}), 6663 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE, 6664 {0x14, 0x90170110}, 6665 {0x15, 0x0321101f}, 6666 {0x16, 0x03011020}), 6667 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE, 6668 {0x12, 0x90a60130}, 6669 {0x14, 0x90170110}, 6670 {0x15, 0x0321101f}), 6671 {} 6672 }; 6673 6674 /* 6675 */ 6676 static int patch_alc662(struct hda_codec *codec) 6677 { 6678 struct alc_spec *spec; 6679 int err; 6680 6681 err = alc_alloc_spec(codec, 0x0b); 6682 if (err < 0) 6683 return err; 6684 6685 spec = codec->spec; 6686 6687 spec->shutup = alc_eapd_shutup; 6688 6689 /* handle multiple HPs as is */ 6690 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 6691 6692 alc_fix_pll_init(codec, 0x20, 0x04, 15); 6693 6694 switch (codec->core.vendor_id) { 6695 case 0x10ec0668: 6696 spec->init_hook = alc668_restore_default_value; 6697 break; 6698 } 6699 6700 snd_hda_pick_fixup(codec, alc662_fixup_models, 6701 alc662_fixup_tbl, alc662_fixups); 6702 snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups); 6703 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 6704 6705 alc_auto_parse_customize_define(codec); 6706 6707 if (has_cdefine_beep(codec)) 6708 spec->gen.beep_nid = 0x01; 6709 6710 if ((alc_get_coef0(codec) & (1 << 14)) && 6711 codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 && 6712 spec->cdefine.platform_type == 1) { 6713 err = alc_codec_rename(codec, "ALC272X"); 6714 if (err < 0) 6715 goto error; 6716 } 6717 6718 /* automatic parse from the BIOS config */ 6719 err = alc662_parse_auto_config(codec); 6720 if (err < 0) 6721 goto error; 6722 6723 if (!spec->gen.no_analog && spec->gen.beep_nid) { 6724 switch (codec->core.vendor_id) { 6725 case 0x10ec0662: 6726 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 6727 break; 6728 case 0x10ec0272: 6729 case 0x10ec0663: 6730 case 0x10ec0665: 6731 case 0x10ec0668: 6732 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT); 6733 break; 6734 case 0x10ec0273: 6735 set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT); 6736 break; 6737 } 6738 } 6739 6740 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 6741 6742 return 0; 6743 6744 error: 6745 alc_free(codec); 6746 return err; 6747 } 6748 6749 /* 6750 * ALC680 support 6751 */ 6752 6753 static int alc680_parse_auto_config(struct hda_codec *codec) 6754 { 6755 return alc_parse_auto_config(codec, NULL, NULL); 6756 } 6757 6758 /* 6759 */ 6760 static int patch_alc680(struct hda_codec *codec) 6761 { 6762 int err; 6763 6764 /* ALC680 has no aa-loopback mixer */ 6765 err = alc_alloc_spec(codec, 0); 6766 if (err < 0) 6767 return err; 6768 6769 /* automatic parse from the BIOS config */ 6770 err = alc680_parse_auto_config(codec); 6771 if (err < 0) { 6772 alc_free(codec); 6773 return err; 6774 } 6775 6776 return 0; 6777 } 6778 6779 /* 6780 * patch entries 6781 */ 6782 static const struct hda_device_id snd_hda_id_realtek[] = { 6783 HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269), 6784 HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269), 6785 HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269), 6786 HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269), 6787 HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269), 6788 HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269), 6789 HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260), 6790 HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262), 6791 HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268), 6792 HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268), 6793 HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269), 6794 HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269), 6795 HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662), 6796 HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269), 6797 HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269), 6798 HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269), 6799 HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269), 6800 HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269), 6801 HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269), 6802 HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269), 6803 HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269), 6804 HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269), 6805 HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269), 6806 HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269), 6807 HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269), 6808 HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269), 6809 HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861), 6810 HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd), 6811 HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861), 6812 HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd), 6813 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882), 6814 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662), 6815 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662), 6816 HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662), 6817 HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662), 6818 HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662), 6819 HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662), 6820 HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662), 6821 HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662), 6822 HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680), 6823 HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc882), 6824 HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880), 6825 HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882), 6826 HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882), 6827 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882), 6828 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882), 6829 HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882), 6830 HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882), 6831 HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882), 6832 HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882), 6833 HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882), 6834 HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662), 6835 HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882), 6836 HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882), 6837 {} /* terminator */ 6838 }; 6839 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek); 6840 6841 MODULE_LICENSE("GPL"); 6842 MODULE_DESCRIPTION("Realtek HD-audio codec"); 6843 6844 static struct hda_codec_driver realtek_driver = { 6845 .id = snd_hda_id_realtek, 6846 }; 6847 6848 module_hda_codec_driver(realtek_driver); 6849