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