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