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@physics.adelaide.edu.au> 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/module.h> 31 #include <sound/core.h> 32 #include <sound/jack.h> 33 #include "hda_codec.h" 34 #include "hda_local.h" 35 #include "hda_beep.h" 36 #include "hda_jack.h" 37 38 /* unsol event tags */ 39 #define ALC_FRONT_EVENT 0x01 40 #define ALC_DCVOL_EVENT 0x02 41 #define ALC_HP_EVENT 0x04 42 #define ALC_MIC_EVENT 0x08 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 struct alc_customize_define { 57 unsigned int sku_cfg; 58 unsigned char port_connectivity; 59 unsigned char check_sum; 60 unsigned char customization; 61 unsigned char external_amp; 62 unsigned int enable_pcbeep:1; 63 unsigned int platform_type:1; 64 unsigned int swap:1; 65 unsigned int override:1; 66 unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */ 67 }; 68 69 struct alc_fixup; 70 71 struct alc_multi_io { 72 hda_nid_t pin; /* multi-io widget pin NID */ 73 hda_nid_t dac; /* DAC to be connected */ 74 unsigned int ctl_in; /* cached input-pin control value */ 75 }; 76 77 enum { 78 ALC_AUTOMUTE_PIN, /* change the pin control */ 79 ALC_AUTOMUTE_AMP, /* mute/unmute the pin AMP */ 80 ALC_AUTOMUTE_MIXER, /* mute/unmute mixer widget AMP */ 81 }; 82 83 #define MAX_VOL_NIDS 0x40 84 85 struct alc_spec { 86 /* codec parameterization */ 87 const struct snd_kcontrol_new *mixers[5]; /* mixer arrays */ 88 unsigned int num_mixers; 89 const struct snd_kcontrol_new *cap_mixer; /* capture mixer */ 90 unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */ 91 92 const struct hda_verb *init_verbs[10]; /* initialization verbs 93 * don't forget NULL 94 * termination! 95 */ 96 unsigned int num_init_verbs; 97 98 char stream_name_analog[32]; /* analog PCM stream */ 99 const struct hda_pcm_stream *stream_analog_playback; 100 const struct hda_pcm_stream *stream_analog_capture; 101 const struct hda_pcm_stream *stream_analog_alt_playback; 102 const struct hda_pcm_stream *stream_analog_alt_capture; 103 104 char stream_name_digital[32]; /* digital PCM stream */ 105 const struct hda_pcm_stream *stream_digital_playback; 106 const struct hda_pcm_stream *stream_digital_capture; 107 108 /* playback */ 109 struct hda_multi_out multiout; /* playback set-up 110 * max_channels, dacs must be set 111 * dig_out_nid and hp_nid are optional 112 */ 113 hda_nid_t alt_dac_nid; 114 hda_nid_t slave_dig_outs[3]; /* optional - for auto-parsing */ 115 int dig_out_type; 116 117 /* capture */ 118 unsigned int num_adc_nids; 119 const hda_nid_t *adc_nids; 120 const hda_nid_t *capsrc_nids; 121 hda_nid_t dig_in_nid; /* digital-in NID; optional */ 122 hda_nid_t mixer_nid; /* analog-mixer NID */ 123 DECLARE_BITMAP(vol_ctls, MAX_VOL_NIDS << 1); 124 DECLARE_BITMAP(sw_ctls, MAX_VOL_NIDS << 1); 125 126 /* capture setup for dynamic dual-adc switch */ 127 hda_nid_t cur_adc; 128 unsigned int cur_adc_stream_tag; 129 unsigned int cur_adc_format; 130 131 /* capture source */ 132 unsigned int num_mux_defs; 133 const struct hda_input_mux *input_mux; 134 unsigned int cur_mux[3]; 135 hda_nid_t ext_mic_pin; 136 hda_nid_t dock_mic_pin; 137 hda_nid_t int_mic_pin; 138 139 /* channel model */ 140 const struct hda_channel_mode *channel_mode; 141 int num_channel_mode; 142 int need_dac_fix; 143 int const_channel_count; 144 int ext_channel_count; 145 146 /* PCM information */ 147 struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */ 148 149 /* dynamic controls, init_verbs and input_mux */ 150 struct auto_pin_cfg autocfg; 151 struct alc_customize_define cdefine; 152 struct snd_array kctls; 153 struct hda_input_mux private_imux[3]; 154 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS]; 155 hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS]; 156 hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS]; 157 hda_nid_t imux_pins[HDA_MAX_NUM_INPUTS]; 158 unsigned int dyn_adc_idx[HDA_MAX_NUM_INPUTS]; 159 int int_mic_idx, ext_mic_idx, dock_mic_idx; /* for auto-mic */ 160 161 /* hooks */ 162 void (*init_hook)(struct hda_codec *codec); 163 void (*unsol_event)(struct hda_codec *codec, unsigned int res); 164 #ifdef CONFIG_SND_HDA_POWER_SAVE 165 void (*power_hook)(struct hda_codec *codec); 166 #endif 167 void (*shutup)(struct hda_codec *codec); 168 void (*automute_hook)(struct hda_codec *codec); 169 170 /* for pin sensing */ 171 unsigned int hp_jack_present:1; 172 unsigned int line_jack_present:1; 173 unsigned int master_mute:1; 174 unsigned int auto_mic:1; 175 unsigned int auto_mic_valid_imux:1; /* valid imux for auto-mic */ 176 unsigned int automute_speaker:1; /* automute speaker outputs */ 177 unsigned int automute_lo:1; /* automute LO outputs */ 178 unsigned int detect_hp:1; /* Headphone detection enabled */ 179 unsigned int detect_lo:1; /* Line-out detection enabled */ 180 unsigned int automute_speaker_possible:1; /* there are speakers and either LO or HP */ 181 unsigned int automute_lo_possible:1; /* there are line outs and HP */ 182 unsigned int keep_vref_in_automute:1; /* Don't clear VREF in automute */ 183 184 /* other flags */ 185 unsigned int no_analog :1; /* digital I/O only */ 186 unsigned int dyn_adc_switch:1; /* switch ADCs (for ALC275) */ 187 unsigned int single_input_src:1; 188 unsigned int vol_in_capsrc:1; /* use capsrc volume (ADC has no vol) */ 189 unsigned int parse_flags; /* passed to snd_hda_parse_pin_defcfg() */ 190 unsigned int shared_mic_hp:1; /* HP/Mic-in sharing */ 191 192 /* auto-mute control */ 193 int automute_mode; 194 hda_nid_t automute_mixer_nid[AUTO_CFG_MAX_OUTS]; 195 196 int init_amp; 197 int codec_variant; /* flag for other variants */ 198 199 /* for virtual master */ 200 hda_nid_t vmaster_nid; 201 struct hda_vmaster_mute_hook vmaster_mute; 202 #ifdef CONFIG_SND_HDA_POWER_SAVE 203 struct hda_loopback_check loopback; 204 int num_loopbacks; 205 struct hda_amp_list loopback_list[8]; 206 #endif 207 208 /* for PLL fix */ 209 hda_nid_t pll_nid; 210 unsigned int pll_coef_idx, pll_coef_bit; 211 unsigned int coef0; 212 213 /* fix-up list */ 214 int fixup_id; 215 const struct alc_fixup *fixup_list; 216 const char *fixup_name; 217 218 /* multi-io */ 219 int multi_ios; 220 struct alc_multi_io multi_io[4]; 221 222 /* bind volumes */ 223 struct snd_array bind_ctls; 224 }; 225 226 static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid, 227 int dir, unsigned int bits) 228 { 229 if (!nid) 230 return false; 231 if (get_wcaps(codec, nid) & (1 << (dir + 1))) 232 if (query_amp_caps(codec, nid, dir) & bits) 233 return true; 234 return false; 235 } 236 237 #define nid_has_mute(codec, nid, dir) \ 238 check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE) 239 #define nid_has_volume(codec, nid, dir) \ 240 check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS) 241 242 /* 243 * input MUX handling 244 */ 245 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol, 246 struct snd_ctl_elem_info *uinfo) 247 { 248 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 249 struct alc_spec *spec = codec->spec; 250 unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id); 251 if (mux_idx >= spec->num_mux_defs) 252 mux_idx = 0; 253 if (!spec->input_mux[mux_idx].num_items && mux_idx > 0) 254 mux_idx = 0; 255 return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo); 256 } 257 258 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol, 259 struct snd_ctl_elem_value *ucontrol) 260 { 261 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 262 struct alc_spec *spec = codec->spec; 263 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 264 265 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx]; 266 return 0; 267 } 268 269 static bool alc_dyn_adc_pcm_resetup(struct hda_codec *codec, int cur) 270 { 271 struct alc_spec *spec = codec->spec; 272 hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]]; 273 274 if (spec->cur_adc && spec->cur_adc != new_adc) { 275 /* stream is running, let's swap the current ADC */ 276 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1); 277 spec->cur_adc = new_adc; 278 snd_hda_codec_setup_stream(codec, new_adc, 279 spec->cur_adc_stream_tag, 0, 280 spec->cur_adc_format); 281 return true; 282 } 283 return false; 284 } 285 286 static inline hda_nid_t get_capsrc(struct alc_spec *spec, int idx) 287 { 288 return spec->capsrc_nids ? 289 spec->capsrc_nids[idx] : spec->adc_nids[idx]; 290 } 291 292 static void call_update_outputs(struct hda_codec *codec); 293 294 /* select the given imux item; either unmute exclusively or select the route */ 295 static int alc_mux_select(struct hda_codec *codec, unsigned int adc_idx, 296 unsigned int idx, bool force) 297 { 298 struct alc_spec *spec = codec->spec; 299 const struct hda_input_mux *imux; 300 unsigned int mux_idx; 301 int i, type, num_conns; 302 hda_nid_t nid; 303 304 if (!spec->input_mux) 305 return 0; 306 307 mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx; 308 imux = &spec->input_mux[mux_idx]; 309 if (!imux->num_items && mux_idx > 0) 310 imux = &spec->input_mux[0]; 311 if (!imux->num_items) 312 return 0; 313 314 if (idx >= imux->num_items) 315 idx = imux->num_items - 1; 316 if (spec->cur_mux[adc_idx] == idx && !force) 317 return 0; 318 spec->cur_mux[adc_idx] = idx; 319 320 /* for shared I/O, change the pin-control accordingly */ 321 if (spec->shared_mic_hp) { 322 /* NOTE: this assumes that there are only two inputs, the 323 * first is the real internal mic and the second is HP jack. 324 */ 325 snd_hda_codec_write(codec, spec->autocfg.inputs[1].pin, 0, 326 AC_VERB_SET_PIN_WIDGET_CONTROL, 327 spec->cur_mux[adc_idx] ? 328 PIN_VREF80 : PIN_HP); 329 spec->automute_speaker = !spec->cur_mux[adc_idx]; 330 call_update_outputs(codec); 331 } 332 333 if (spec->dyn_adc_switch) { 334 alc_dyn_adc_pcm_resetup(codec, idx); 335 adc_idx = spec->dyn_adc_idx[idx]; 336 } 337 338 nid = get_capsrc(spec, adc_idx); 339 340 /* no selection? */ 341 num_conns = snd_hda_get_conn_list(codec, nid, NULL); 342 if (num_conns <= 1) 343 return 1; 344 345 type = get_wcaps_type(get_wcaps(codec, nid)); 346 if (type == AC_WID_AUD_MIX) { 347 /* Matrix-mixer style (e.g. ALC882) */ 348 int active = imux->items[idx].index; 349 for (i = 0; i < num_conns; i++) { 350 unsigned int v = (i == active) ? 0 : HDA_AMP_MUTE; 351 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, i, 352 HDA_AMP_MUTE, v); 353 } 354 } else { 355 /* MUX style (e.g. ALC880) */ 356 snd_hda_codec_write_cache(codec, nid, 0, 357 AC_VERB_SET_CONNECT_SEL, 358 imux->items[idx].index); 359 } 360 return 1; 361 } 362 363 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol, 364 struct snd_ctl_elem_value *ucontrol) 365 { 366 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 367 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 368 return alc_mux_select(codec, adc_idx, 369 ucontrol->value.enumerated.item[0], false); 370 } 371 372 /* 373 * set up the input pin config (depending on the given auto-pin type) 374 */ 375 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid, 376 int auto_pin_type) 377 { 378 unsigned int val = PIN_IN; 379 380 if (auto_pin_type == AUTO_PIN_MIC) { 381 unsigned int pincap; 382 unsigned int oldval; 383 oldval = snd_hda_codec_read(codec, nid, 0, 384 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 385 pincap = snd_hda_query_pin_caps(codec, nid); 386 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT; 387 /* if the default pin setup is vref50, we give it priority */ 388 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50) 389 val = PIN_VREF80; 390 else if (pincap & AC_PINCAP_VREF_50) 391 val = PIN_VREF50; 392 else if (pincap & AC_PINCAP_VREF_100) 393 val = PIN_VREF100; 394 else if (pincap & AC_PINCAP_VREF_GRD) 395 val = PIN_VREFGRD; 396 } 397 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val); 398 } 399 400 /* 401 * Append the given mixer and verb elements for the later use 402 * The mixer array is referred in build_controls(), and init_verbs are 403 * called in init(). 404 */ 405 static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix) 406 { 407 if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers))) 408 return; 409 spec->mixers[spec->num_mixers++] = mix; 410 } 411 412 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb) 413 { 414 if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs))) 415 return; 416 spec->init_verbs[spec->num_init_verbs++] = verb; 417 } 418 419 /* 420 * GPIO setup tables, used in initialization 421 */ 422 /* Enable GPIO mask and set output */ 423 static const struct hda_verb alc_gpio1_init_verbs[] = { 424 {0x01, AC_VERB_SET_GPIO_MASK, 0x01}, 425 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, 426 {0x01, AC_VERB_SET_GPIO_DATA, 0x01}, 427 { } 428 }; 429 430 static const struct hda_verb alc_gpio2_init_verbs[] = { 431 {0x01, AC_VERB_SET_GPIO_MASK, 0x02}, 432 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02}, 433 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, 434 { } 435 }; 436 437 static const struct hda_verb alc_gpio3_init_verbs[] = { 438 {0x01, AC_VERB_SET_GPIO_MASK, 0x03}, 439 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03}, 440 {0x01, AC_VERB_SET_GPIO_DATA, 0x03}, 441 { } 442 }; 443 444 /* 445 * Fix hardware PLL issue 446 * On some codecs, the analog PLL gating control must be off while 447 * the default value is 1. 448 */ 449 static void alc_fix_pll(struct hda_codec *codec) 450 { 451 struct alc_spec *spec = codec->spec; 452 unsigned int val; 453 454 if (!spec->pll_nid) 455 return; 456 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX, 457 spec->pll_coef_idx); 458 val = snd_hda_codec_read(codec, spec->pll_nid, 0, 459 AC_VERB_GET_PROC_COEF, 0); 460 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX, 461 spec->pll_coef_idx); 462 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF, 463 val & ~(1 << spec->pll_coef_bit)); 464 } 465 466 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid, 467 unsigned int coef_idx, unsigned int coef_bit) 468 { 469 struct alc_spec *spec = codec->spec; 470 spec->pll_nid = nid; 471 spec->pll_coef_idx = coef_idx; 472 spec->pll_coef_bit = coef_bit; 473 alc_fix_pll(codec); 474 } 475 476 /* 477 * Jack detections for HP auto-mute and mic-switch 478 */ 479 480 /* check each pin in the given array; returns true if any of them is plugged */ 481 static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins) 482 { 483 int i, present = 0; 484 485 for (i = 0; i < num_pins; i++) { 486 hda_nid_t nid = pins[i]; 487 if (!nid) 488 break; 489 present |= snd_hda_jack_detect(codec, nid); 490 } 491 return present; 492 } 493 494 /* standard HP/line-out auto-mute helper */ 495 static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins, 496 bool mute, bool hp_out) 497 { 498 struct alc_spec *spec = codec->spec; 499 unsigned int mute_bits = mute ? HDA_AMP_MUTE : 0; 500 unsigned int pin_bits = mute ? 0 : (hp_out ? PIN_HP : PIN_OUT); 501 int i; 502 503 for (i = 0; i < num_pins; i++) { 504 hda_nid_t nid = pins[i]; 505 unsigned int val; 506 if (!nid) 507 break; 508 switch (spec->automute_mode) { 509 case ALC_AUTOMUTE_PIN: 510 /* don't reset VREF value in case it's controlling 511 * the amp (see alc861_fixup_asus_amp_vref_0f()) 512 */ 513 if (spec->keep_vref_in_automute) { 514 val = snd_hda_codec_read(codec, nid, 0, 515 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 516 val &= ~PIN_HP; 517 } else 518 val = 0; 519 val |= pin_bits; 520 snd_hda_codec_write(codec, nid, 0, 521 AC_VERB_SET_PIN_WIDGET_CONTROL, 522 val); 523 break; 524 case ALC_AUTOMUTE_AMP: 525 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 526 HDA_AMP_MUTE, mute_bits); 527 break; 528 case ALC_AUTOMUTE_MIXER: 529 nid = spec->automute_mixer_nid[i]; 530 if (!nid) 531 break; 532 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0, 533 HDA_AMP_MUTE, mute_bits); 534 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 1, 535 HDA_AMP_MUTE, mute_bits); 536 break; 537 } 538 } 539 } 540 541 /* Toggle outputs muting */ 542 static void update_outputs(struct hda_codec *codec) 543 { 544 struct alc_spec *spec = codec->spec; 545 int on; 546 547 /* Control HP pins/amps depending on master_mute state; 548 * in general, HP pins/amps control should be enabled in all cases, 549 * but currently set only for master_mute, just to be safe 550 */ 551 if (!spec->shared_mic_hp) /* don't change HP-pin when shared with mic */ 552 do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins), 553 spec->autocfg.hp_pins, spec->master_mute, true); 554 555 if (!spec->automute_speaker) 556 on = 0; 557 else 558 on = spec->hp_jack_present | spec->line_jack_present; 559 on |= spec->master_mute; 560 do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins), 561 spec->autocfg.speaker_pins, on, false); 562 563 /* toggle line-out mutes if needed, too */ 564 /* if LO is a copy of either HP or Speaker, don't need to handle it */ 565 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] || 566 spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0]) 567 return; 568 if (!spec->automute_lo) 569 on = 0; 570 else 571 on = spec->hp_jack_present; 572 on |= spec->master_mute; 573 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins), 574 spec->autocfg.line_out_pins, on, false); 575 } 576 577 static void call_update_outputs(struct hda_codec *codec) 578 { 579 struct alc_spec *spec = codec->spec; 580 if (spec->automute_hook) 581 spec->automute_hook(codec); 582 else 583 update_outputs(codec); 584 } 585 586 /* standard HP-automute helper */ 587 static void alc_hp_automute(struct hda_codec *codec) 588 { 589 struct alc_spec *spec = codec->spec; 590 591 spec->hp_jack_present = 592 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.hp_pins), 593 spec->autocfg.hp_pins); 594 if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo)) 595 return; 596 call_update_outputs(codec); 597 } 598 599 /* standard line-out-automute helper */ 600 static void alc_line_automute(struct hda_codec *codec) 601 { 602 struct alc_spec *spec = codec->spec; 603 604 /* check LO jack only when it's different from HP */ 605 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0]) 606 return; 607 608 spec->line_jack_present = 609 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins), 610 spec->autocfg.line_out_pins); 611 if (!spec->automute_speaker || !spec->detect_lo) 612 return; 613 call_update_outputs(codec); 614 } 615 616 #define get_connection_index(codec, mux, nid) \ 617 snd_hda_get_conn_index(codec, mux, nid, 0) 618 619 /* standard mic auto-switch helper */ 620 static void alc_mic_automute(struct hda_codec *codec) 621 { 622 struct alc_spec *spec = codec->spec; 623 hda_nid_t *pins = spec->imux_pins; 624 625 if (!spec->auto_mic || !spec->auto_mic_valid_imux) 626 return; 627 if (snd_BUG_ON(!spec->adc_nids)) 628 return; 629 if (snd_BUG_ON(spec->int_mic_idx < 0 || spec->ext_mic_idx < 0)) 630 return; 631 632 if (snd_hda_jack_detect(codec, pins[spec->ext_mic_idx])) 633 alc_mux_select(codec, 0, spec->ext_mic_idx, false); 634 else if (spec->dock_mic_idx >= 0 && 635 snd_hda_jack_detect(codec, pins[spec->dock_mic_idx])) 636 alc_mux_select(codec, 0, spec->dock_mic_idx, false); 637 else 638 alc_mux_select(codec, 0, spec->int_mic_idx, false); 639 } 640 641 /* handle the specified unsol action (ALC_XXX_EVENT) */ 642 static void alc_exec_unsol_event(struct hda_codec *codec, int action) 643 { 644 switch (action) { 645 case ALC_HP_EVENT: 646 alc_hp_automute(codec); 647 break; 648 case ALC_FRONT_EVENT: 649 alc_line_automute(codec); 650 break; 651 case ALC_MIC_EVENT: 652 alc_mic_automute(codec); 653 break; 654 } 655 snd_hda_jack_report_sync(codec); 656 } 657 658 /* update the master volume per volume-knob's unsol event */ 659 static void alc_update_knob_master(struct hda_codec *codec, hda_nid_t nid) 660 { 661 unsigned int val; 662 struct snd_kcontrol *kctl; 663 struct snd_ctl_elem_value *uctl; 664 665 kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume"); 666 if (!kctl) 667 return; 668 uctl = kzalloc(sizeof(*uctl), GFP_KERNEL); 669 if (!uctl) 670 return; 671 val = snd_hda_codec_read(codec, nid, 0, 672 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0); 673 val &= HDA_AMP_VOLMASK; 674 uctl->value.integer.value[0] = val; 675 uctl->value.integer.value[1] = val; 676 kctl->put(kctl, uctl); 677 kfree(uctl); 678 } 679 680 /* unsolicited event for HP jack sensing */ 681 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res) 682 { 683 int action; 684 685 if (codec->vendor_id == 0x10ec0880) 686 res >>= 28; 687 else 688 res >>= 26; 689 action = snd_hda_jack_get_action(codec, res); 690 if (action == ALC_DCVOL_EVENT) { 691 /* Execute the dc-vol event here as it requires the NID 692 * but we don't pass NID to alc_exec_unsol_event(). 693 * Once when we convert all static quirks to the auto-parser, 694 * this can be integerated into there. 695 */ 696 struct hda_jack_tbl *jack; 697 jack = snd_hda_jack_tbl_get_from_tag(codec, res); 698 if (jack) 699 alc_update_knob_master(codec, jack->nid); 700 return; 701 } 702 alc_exec_unsol_event(codec, action); 703 } 704 705 /* call init functions of standard auto-mute helpers */ 706 static void alc_inithook(struct hda_codec *codec) 707 { 708 alc_hp_automute(codec); 709 alc_line_automute(codec); 710 alc_mic_automute(codec); 711 } 712 713 /* additional initialization for ALC888 variants */ 714 static void alc888_coef_init(struct hda_codec *codec) 715 { 716 unsigned int tmp; 717 718 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0); 719 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0); 720 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7); 721 if ((tmp & 0xf0) == 0x20) 722 /* alc888S-VC */ 723 snd_hda_codec_read(codec, 0x20, 0, 724 AC_VERB_SET_PROC_COEF, 0x830); 725 else 726 /* alc888-VB */ 727 snd_hda_codec_read(codec, 0x20, 0, 728 AC_VERB_SET_PROC_COEF, 0x3030); 729 } 730 731 /* additional initialization for ALC889 variants */ 732 static void alc889_coef_init(struct hda_codec *codec) 733 { 734 unsigned int tmp; 735 736 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7); 737 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0); 738 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7); 739 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010); 740 } 741 742 /* turn on/off EAPD control (only if available) */ 743 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on) 744 { 745 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN) 746 return; 747 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD) 748 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE, 749 on ? 2 : 0); 750 } 751 752 /* turn on/off EAPD controls of the codec */ 753 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on) 754 { 755 /* We currently only handle front, HP */ 756 static hda_nid_t pins[] = { 757 0x0f, 0x10, 0x14, 0x15, 0 758 }; 759 hda_nid_t *p; 760 for (p = pins; *p; p++) 761 set_eapd(codec, *p, on); 762 } 763 764 /* generic shutup callback; 765 * just turning off EPAD and a little pause for avoiding pop-noise 766 */ 767 static void alc_eapd_shutup(struct hda_codec *codec) 768 { 769 alc_auto_setup_eapd(codec, false); 770 msleep(200); 771 } 772 773 /* generic EAPD initialization */ 774 static void alc_auto_init_amp(struct hda_codec *codec, int type) 775 { 776 unsigned int tmp; 777 778 alc_auto_setup_eapd(codec, true); 779 switch (type) { 780 case ALC_INIT_GPIO1: 781 snd_hda_sequence_write(codec, alc_gpio1_init_verbs); 782 break; 783 case ALC_INIT_GPIO2: 784 snd_hda_sequence_write(codec, alc_gpio2_init_verbs); 785 break; 786 case ALC_INIT_GPIO3: 787 snd_hda_sequence_write(codec, alc_gpio3_init_verbs); 788 break; 789 case ALC_INIT_DEFAULT: 790 switch (codec->vendor_id) { 791 case 0x10ec0260: 792 snd_hda_codec_write(codec, 0x1a, 0, 793 AC_VERB_SET_COEF_INDEX, 7); 794 tmp = snd_hda_codec_read(codec, 0x1a, 0, 795 AC_VERB_GET_PROC_COEF, 0); 796 snd_hda_codec_write(codec, 0x1a, 0, 797 AC_VERB_SET_COEF_INDEX, 7); 798 snd_hda_codec_write(codec, 0x1a, 0, 799 AC_VERB_SET_PROC_COEF, 800 tmp | 0x2010); 801 break; 802 case 0x10ec0262: 803 case 0x10ec0880: 804 case 0x10ec0882: 805 case 0x10ec0883: 806 case 0x10ec0885: 807 case 0x10ec0887: 808 /*case 0x10ec0889:*/ /* this causes an SPDIF problem */ 809 alc889_coef_init(codec); 810 break; 811 case 0x10ec0888: 812 alc888_coef_init(codec); 813 break; 814 #if 0 /* XXX: This may cause the silent output on speaker on some machines */ 815 case 0x10ec0267: 816 case 0x10ec0268: 817 snd_hda_codec_write(codec, 0x20, 0, 818 AC_VERB_SET_COEF_INDEX, 7); 819 tmp = snd_hda_codec_read(codec, 0x20, 0, 820 AC_VERB_GET_PROC_COEF, 0); 821 snd_hda_codec_write(codec, 0x20, 0, 822 AC_VERB_SET_COEF_INDEX, 7); 823 snd_hda_codec_write(codec, 0x20, 0, 824 AC_VERB_SET_PROC_COEF, 825 tmp | 0x3000); 826 break; 827 #endif /* XXX */ 828 } 829 break; 830 } 831 } 832 833 /* 834 * Auto-Mute mode mixer enum support 835 */ 836 static int alc_automute_mode_info(struct snd_kcontrol *kcontrol, 837 struct snd_ctl_elem_info *uinfo) 838 { 839 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 840 struct alc_spec *spec = codec->spec; 841 static const char * const texts2[] = { 842 "Disabled", "Enabled" 843 }; 844 static const char * const texts3[] = { 845 "Disabled", "Speaker Only", "Line Out+Speaker" 846 }; 847 const char * const *texts; 848 849 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 850 uinfo->count = 1; 851 if (spec->automute_speaker_possible && spec->automute_lo_possible) { 852 uinfo->value.enumerated.items = 3; 853 texts = texts3; 854 } else { 855 uinfo->value.enumerated.items = 2; 856 texts = texts2; 857 } 858 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items) 859 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1; 860 strcpy(uinfo->value.enumerated.name, 861 texts[uinfo->value.enumerated.item]); 862 return 0; 863 } 864 865 static int alc_automute_mode_get(struct snd_kcontrol *kcontrol, 866 struct snd_ctl_elem_value *ucontrol) 867 { 868 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 869 struct alc_spec *spec = codec->spec; 870 unsigned int val = 0; 871 if (spec->automute_speaker) 872 val++; 873 if (spec->automute_lo) 874 val++; 875 876 ucontrol->value.enumerated.item[0] = val; 877 return 0; 878 } 879 880 static int alc_automute_mode_put(struct snd_kcontrol *kcontrol, 881 struct snd_ctl_elem_value *ucontrol) 882 { 883 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 884 struct alc_spec *spec = codec->spec; 885 886 switch (ucontrol->value.enumerated.item[0]) { 887 case 0: 888 if (!spec->automute_speaker && !spec->automute_lo) 889 return 0; 890 spec->automute_speaker = 0; 891 spec->automute_lo = 0; 892 break; 893 case 1: 894 if (spec->automute_speaker_possible) { 895 if (!spec->automute_lo && spec->automute_speaker) 896 return 0; 897 spec->automute_speaker = 1; 898 spec->automute_lo = 0; 899 } else if (spec->automute_lo_possible) { 900 if (spec->automute_lo) 901 return 0; 902 spec->automute_lo = 1; 903 } else 904 return -EINVAL; 905 break; 906 case 2: 907 if (!spec->automute_lo_possible || !spec->automute_speaker_possible) 908 return -EINVAL; 909 if (spec->automute_speaker && spec->automute_lo) 910 return 0; 911 spec->automute_speaker = 1; 912 spec->automute_lo = 1; 913 break; 914 default: 915 return -EINVAL; 916 } 917 call_update_outputs(codec); 918 return 1; 919 } 920 921 static const struct snd_kcontrol_new alc_automute_mode_enum = { 922 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 923 .name = "Auto-Mute Mode", 924 .info = alc_automute_mode_info, 925 .get = alc_automute_mode_get, 926 .put = alc_automute_mode_put, 927 }; 928 929 static struct snd_kcontrol_new *alc_kcontrol_new(struct alc_spec *spec) 930 { 931 snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32); 932 return snd_array_new(&spec->kctls); 933 } 934 935 static int alc_add_automute_mode_enum(struct hda_codec *codec) 936 { 937 struct alc_spec *spec = codec->spec; 938 struct snd_kcontrol_new *knew; 939 940 knew = alc_kcontrol_new(spec); 941 if (!knew) 942 return -ENOMEM; 943 *knew = alc_automute_mode_enum; 944 knew->name = kstrdup("Auto-Mute Mode", GFP_KERNEL); 945 if (!knew->name) 946 return -ENOMEM; 947 return 0; 948 } 949 950 /* 951 * Check the availability of HP/line-out auto-mute; 952 * Set up appropriately if really supported 953 */ 954 static void alc_init_automute(struct hda_codec *codec) 955 { 956 struct alc_spec *spec = codec->spec; 957 struct auto_pin_cfg *cfg = &spec->autocfg; 958 int present = 0; 959 int i; 960 961 if (cfg->hp_pins[0]) 962 present++; 963 if (cfg->line_out_pins[0]) 964 present++; 965 if (cfg->speaker_pins[0]) 966 present++; 967 if (present < 2) /* need two different output types */ 968 return; 969 970 if (!cfg->speaker_pins[0] && 971 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) { 972 memcpy(cfg->speaker_pins, cfg->line_out_pins, 973 sizeof(cfg->speaker_pins)); 974 cfg->speaker_outs = cfg->line_outs; 975 } 976 977 if (!cfg->hp_pins[0] && 978 cfg->line_out_type == AUTO_PIN_HP_OUT) { 979 memcpy(cfg->hp_pins, cfg->line_out_pins, 980 sizeof(cfg->hp_pins)); 981 cfg->hp_outs = cfg->line_outs; 982 } 983 984 spec->automute_mode = ALC_AUTOMUTE_PIN; 985 986 for (i = 0; i < cfg->hp_outs; i++) { 987 hda_nid_t nid = cfg->hp_pins[i]; 988 if (!is_jack_detectable(codec, nid)) 989 continue; 990 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n", 991 nid); 992 snd_hda_jack_detect_enable(codec, nid, ALC_HP_EVENT); 993 spec->detect_hp = 1; 994 } 995 996 if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) { 997 if (cfg->speaker_outs) 998 for (i = 0; i < cfg->line_outs; i++) { 999 hda_nid_t nid = cfg->line_out_pins[i]; 1000 if (!is_jack_detectable(codec, nid)) 1001 continue; 1002 snd_printdd("realtek: Enable Line-Out " 1003 "auto-muting on NID 0x%x\n", nid); 1004 snd_hda_jack_detect_enable(codec, nid, 1005 ALC_FRONT_EVENT); 1006 spec->detect_lo = 1; 1007 } 1008 spec->automute_lo_possible = spec->detect_hp; 1009 } 1010 1011 spec->automute_speaker_possible = cfg->speaker_outs && 1012 (spec->detect_hp || spec->detect_lo); 1013 1014 spec->automute_lo = spec->automute_lo_possible; 1015 spec->automute_speaker = spec->automute_speaker_possible; 1016 1017 if (spec->automute_speaker_possible || spec->automute_lo_possible) { 1018 /* create a control for automute mode */ 1019 alc_add_automute_mode_enum(codec); 1020 spec->unsol_event = alc_sku_unsol_event; 1021 } 1022 } 1023 1024 /* return the position of NID in the list, or -1 if not found */ 1025 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums) 1026 { 1027 int i; 1028 for (i = 0; i < nums; i++) 1029 if (list[i] == nid) 1030 return i; 1031 return -1; 1032 } 1033 1034 /* check whether dynamic ADC-switching is available */ 1035 static bool alc_check_dyn_adc_switch(struct hda_codec *codec) 1036 { 1037 struct alc_spec *spec = codec->spec; 1038 struct hda_input_mux *imux = &spec->private_imux[0]; 1039 int i, n, idx; 1040 hda_nid_t cap, pin; 1041 1042 if (imux != spec->input_mux) /* no dynamic imux? */ 1043 return false; 1044 1045 for (n = 0; n < spec->num_adc_nids; n++) { 1046 cap = spec->private_capsrc_nids[n]; 1047 for (i = 0; i < imux->num_items; i++) { 1048 pin = spec->imux_pins[i]; 1049 if (!pin) 1050 return false; 1051 if (get_connection_index(codec, cap, pin) < 0) 1052 break; 1053 } 1054 if (i >= imux->num_items) 1055 return true; /* no ADC-switch is needed */ 1056 } 1057 1058 for (i = 0; i < imux->num_items; i++) { 1059 pin = spec->imux_pins[i]; 1060 for (n = 0; n < spec->num_adc_nids; n++) { 1061 cap = spec->private_capsrc_nids[n]; 1062 idx = get_connection_index(codec, cap, pin); 1063 if (idx >= 0) { 1064 imux->items[i].index = idx; 1065 spec->dyn_adc_idx[i] = n; 1066 break; 1067 } 1068 } 1069 } 1070 1071 snd_printdd("realtek: enabling ADC switching\n"); 1072 spec->dyn_adc_switch = 1; 1073 return true; 1074 } 1075 1076 /* check whether all auto-mic pins are valid; setup indices if OK */ 1077 static bool alc_auto_mic_check_imux(struct hda_codec *codec) 1078 { 1079 struct alc_spec *spec = codec->spec; 1080 const struct hda_input_mux *imux; 1081 1082 if (!spec->auto_mic) 1083 return false; 1084 if (spec->auto_mic_valid_imux) 1085 return true; /* already checked */ 1086 1087 /* fill up imux indices */ 1088 if (!alc_check_dyn_adc_switch(codec)) { 1089 spec->auto_mic = 0; 1090 return false; 1091 } 1092 1093 imux = spec->input_mux; 1094 spec->ext_mic_idx = find_idx_in_nid_list(spec->ext_mic_pin, 1095 spec->imux_pins, imux->num_items); 1096 spec->int_mic_idx = find_idx_in_nid_list(spec->int_mic_pin, 1097 spec->imux_pins, imux->num_items); 1098 spec->dock_mic_idx = find_idx_in_nid_list(spec->dock_mic_pin, 1099 spec->imux_pins, imux->num_items); 1100 if (spec->ext_mic_idx < 0 || spec->int_mic_idx < 0) { 1101 spec->auto_mic = 0; 1102 return false; /* no corresponding imux */ 1103 } 1104 1105 snd_hda_jack_detect_enable(codec, spec->ext_mic_pin, ALC_MIC_EVENT); 1106 if (spec->dock_mic_pin) 1107 snd_hda_jack_detect_enable(codec, spec->dock_mic_pin, 1108 ALC_MIC_EVENT); 1109 1110 spec->auto_mic_valid_imux = 1; 1111 spec->auto_mic = 1; 1112 return true; 1113 } 1114 1115 /* 1116 * Check the availability of auto-mic switch; 1117 * Set up if really supported 1118 */ 1119 static void alc_init_auto_mic(struct hda_codec *codec) 1120 { 1121 struct alc_spec *spec = codec->spec; 1122 struct auto_pin_cfg *cfg = &spec->autocfg; 1123 hda_nid_t fixed, ext, dock; 1124 int i; 1125 1126 if (spec->shared_mic_hp) 1127 return; /* no auto-mic for the shared I/O */ 1128 1129 spec->ext_mic_idx = spec->int_mic_idx = spec->dock_mic_idx = -1; 1130 1131 fixed = ext = dock = 0; 1132 for (i = 0; i < cfg->num_inputs; i++) { 1133 hda_nid_t nid = cfg->inputs[i].pin; 1134 unsigned int defcfg; 1135 defcfg = snd_hda_codec_get_pincfg(codec, nid); 1136 switch (snd_hda_get_input_pin_attr(defcfg)) { 1137 case INPUT_PIN_ATTR_INT: 1138 if (fixed) 1139 return; /* already occupied */ 1140 if (cfg->inputs[i].type != AUTO_PIN_MIC) 1141 return; /* invalid type */ 1142 fixed = nid; 1143 break; 1144 case INPUT_PIN_ATTR_UNUSED: 1145 return; /* invalid entry */ 1146 case INPUT_PIN_ATTR_DOCK: 1147 if (dock) 1148 return; /* already occupied */ 1149 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN) 1150 return; /* invalid type */ 1151 dock = nid; 1152 break; 1153 default: 1154 if (ext) 1155 return; /* already occupied */ 1156 if (cfg->inputs[i].type != AUTO_PIN_MIC) 1157 return; /* invalid type */ 1158 ext = nid; 1159 break; 1160 } 1161 } 1162 if (!ext && dock) { 1163 ext = dock; 1164 dock = 0; 1165 } 1166 if (!ext || !fixed) 1167 return; 1168 if (!is_jack_detectable(codec, ext)) 1169 return; /* no unsol support */ 1170 if (dock && !is_jack_detectable(codec, dock)) 1171 return; /* no unsol support */ 1172 1173 /* check imux indices */ 1174 spec->ext_mic_pin = ext; 1175 spec->int_mic_pin = fixed; 1176 spec->dock_mic_pin = dock; 1177 1178 spec->auto_mic = 1; 1179 if (!alc_auto_mic_check_imux(codec)) 1180 return; 1181 1182 snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n", 1183 ext, fixed, dock); 1184 spec->unsol_event = alc_sku_unsol_event; 1185 } 1186 1187 /* check the availabilities of auto-mute and auto-mic switches */ 1188 static void alc_auto_check_switches(struct hda_codec *codec) 1189 { 1190 alc_init_automute(codec); 1191 alc_init_auto_mic(codec); 1192 } 1193 1194 /* 1195 * Realtek SSID verification 1196 */ 1197 1198 /* Could be any non-zero and even value. When used as fixup, tells 1199 * the driver to ignore any present sku defines. 1200 */ 1201 #define ALC_FIXUP_SKU_IGNORE (2) 1202 1203 static int alc_auto_parse_customize_define(struct hda_codec *codec) 1204 { 1205 unsigned int ass, tmp, i; 1206 unsigned nid = 0; 1207 struct alc_spec *spec = codec->spec; 1208 1209 spec->cdefine.enable_pcbeep = 1; /* assume always enabled */ 1210 1211 if (spec->cdefine.fixup) { 1212 ass = spec->cdefine.sku_cfg; 1213 if (ass == ALC_FIXUP_SKU_IGNORE) 1214 return -1; 1215 goto do_sku; 1216 } 1217 1218 ass = codec->subsystem_id & 0xffff; 1219 if (ass != codec->bus->pci->subsystem_device && (ass & 1)) 1220 goto do_sku; 1221 1222 nid = 0x1d; 1223 if (codec->vendor_id == 0x10ec0260) 1224 nid = 0x17; 1225 ass = snd_hda_codec_get_pincfg(codec, nid); 1226 1227 if (!(ass & 1)) { 1228 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n", 1229 codec->chip_name, ass); 1230 return -1; 1231 } 1232 1233 /* check sum */ 1234 tmp = 0; 1235 for (i = 1; i < 16; i++) { 1236 if ((ass >> i) & 1) 1237 tmp++; 1238 } 1239 if (((ass >> 16) & 0xf) != tmp) 1240 return -1; 1241 1242 spec->cdefine.port_connectivity = ass >> 30; 1243 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20; 1244 spec->cdefine.check_sum = (ass >> 16) & 0xf; 1245 spec->cdefine.customization = ass >> 8; 1246 do_sku: 1247 spec->cdefine.sku_cfg = ass; 1248 spec->cdefine.external_amp = (ass & 0x38) >> 3; 1249 spec->cdefine.platform_type = (ass & 0x4) >> 2; 1250 spec->cdefine.swap = (ass & 0x2) >> 1; 1251 spec->cdefine.override = ass & 0x1; 1252 1253 snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n", 1254 nid, spec->cdefine.sku_cfg); 1255 snd_printd("SKU: port_connectivity=0x%x\n", 1256 spec->cdefine.port_connectivity); 1257 snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep); 1258 snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum); 1259 snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization); 1260 snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp); 1261 snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type); 1262 snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap); 1263 snd_printd("SKU: override=0x%x\n", spec->cdefine.override); 1264 1265 return 0; 1266 } 1267 1268 /* return true if the given NID is found in the list */ 1269 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums) 1270 { 1271 return find_idx_in_nid_list(nid, list, nums) >= 0; 1272 } 1273 1274 /* check subsystem ID and set up device-specific initialization; 1275 * return 1 if initialized, 0 if invalid SSID 1276 */ 1277 /* 32-bit subsystem ID for BIOS loading in HD Audio codec. 1278 * 31 ~ 16 : Manufacture ID 1279 * 15 ~ 8 : SKU ID 1280 * 7 ~ 0 : Assembly ID 1281 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36 1282 */ 1283 static int alc_subsystem_id(struct hda_codec *codec, 1284 hda_nid_t porta, hda_nid_t porte, 1285 hda_nid_t portd, hda_nid_t porti) 1286 { 1287 unsigned int ass, tmp, i; 1288 unsigned nid; 1289 struct alc_spec *spec = codec->spec; 1290 1291 if (spec->cdefine.fixup) { 1292 ass = spec->cdefine.sku_cfg; 1293 if (ass == ALC_FIXUP_SKU_IGNORE) 1294 return 0; 1295 goto do_sku; 1296 } 1297 1298 ass = codec->subsystem_id & 0xffff; 1299 if ((ass != codec->bus->pci->subsystem_device) && (ass & 1)) 1300 goto do_sku; 1301 1302 /* invalid SSID, check the special NID pin defcfg instead */ 1303 /* 1304 * 31~30 : port connectivity 1305 * 29~21 : reserve 1306 * 20 : PCBEEP input 1307 * 19~16 : Check sum (15:1) 1308 * 15~1 : Custom 1309 * 0 : override 1310 */ 1311 nid = 0x1d; 1312 if (codec->vendor_id == 0x10ec0260) 1313 nid = 0x17; 1314 ass = snd_hda_codec_get_pincfg(codec, nid); 1315 snd_printd("realtek: No valid SSID, " 1316 "checking pincfg 0x%08x for NID 0x%x\n", 1317 ass, nid); 1318 if (!(ass & 1)) 1319 return 0; 1320 if ((ass >> 30) != 1) /* no physical connection */ 1321 return 0; 1322 1323 /* check sum */ 1324 tmp = 0; 1325 for (i = 1; i < 16; i++) { 1326 if ((ass >> i) & 1) 1327 tmp++; 1328 } 1329 if (((ass >> 16) & 0xf) != tmp) 1330 return 0; 1331 do_sku: 1332 snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n", 1333 ass & 0xffff, codec->vendor_id); 1334 /* 1335 * 0 : override 1336 * 1 : Swap Jack 1337 * 2 : 0 --> Desktop, 1 --> Laptop 1338 * 3~5 : External Amplifier control 1339 * 7~6 : Reserved 1340 */ 1341 tmp = (ass & 0x38) >> 3; /* external Amp control */ 1342 switch (tmp) { 1343 case 1: 1344 spec->init_amp = ALC_INIT_GPIO1; 1345 break; 1346 case 3: 1347 spec->init_amp = ALC_INIT_GPIO2; 1348 break; 1349 case 7: 1350 spec->init_amp = ALC_INIT_GPIO3; 1351 break; 1352 case 5: 1353 default: 1354 spec->init_amp = ALC_INIT_DEFAULT; 1355 break; 1356 } 1357 1358 /* is laptop or Desktop and enable the function "Mute internal speaker 1359 * when the external headphone out jack is plugged" 1360 */ 1361 if (!(ass & 0x8000)) 1362 return 1; 1363 /* 1364 * 10~8 : Jack location 1365 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered 1366 * 14~13: Resvered 1367 * 15 : 1 --> enable the function "Mute internal speaker 1368 * when the external headphone out jack is plugged" 1369 */ 1370 if (!spec->autocfg.hp_pins[0] && 1371 !(spec->autocfg.line_out_pins[0] && 1372 spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)) { 1373 hda_nid_t nid; 1374 tmp = (ass >> 11) & 0x3; /* HP to chassis */ 1375 if (tmp == 0) 1376 nid = porta; 1377 else if (tmp == 1) 1378 nid = porte; 1379 else if (tmp == 2) 1380 nid = portd; 1381 else if (tmp == 3) 1382 nid = porti; 1383 else 1384 return 1; 1385 if (found_in_nid_list(nid, spec->autocfg.line_out_pins, 1386 spec->autocfg.line_outs)) 1387 return 1; 1388 spec->autocfg.hp_pins[0] = nid; 1389 } 1390 return 1; 1391 } 1392 1393 /* Check the validity of ALC subsystem-id 1394 * ports contains an array of 4 pin NIDs for port-A, E, D and I */ 1395 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports) 1396 { 1397 if (!alc_subsystem_id(codec, ports[0], ports[1], ports[2], ports[3])) { 1398 struct alc_spec *spec = codec->spec; 1399 snd_printd("realtek: " 1400 "Enable default setup for auto mode as fallback\n"); 1401 spec->init_amp = ALC_INIT_DEFAULT; 1402 } 1403 } 1404 1405 /* 1406 * Fix-up pin default configurations and add default verbs 1407 */ 1408 1409 struct alc_pincfg { 1410 hda_nid_t nid; 1411 u32 val; 1412 }; 1413 1414 struct alc_model_fixup { 1415 const int id; 1416 const char *name; 1417 }; 1418 1419 struct alc_fixup { 1420 int type; 1421 bool chained; 1422 int chain_id; 1423 union { 1424 unsigned int sku; 1425 const struct alc_pincfg *pins; 1426 const struct hda_verb *verbs; 1427 void (*func)(struct hda_codec *codec, 1428 const struct alc_fixup *fix, 1429 int action); 1430 } v; 1431 }; 1432 1433 enum { 1434 ALC_FIXUP_INVALID, 1435 ALC_FIXUP_SKU, 1436 ALC_FIXUP_PINS, 1437 ALC_FIXUP_VERBS, 1438 ALC_FIXUP_FUNC, 1439 }; 1440 1441 enum { 1442 ALC_FIXUP_ACT_PRE_PROBE, 1443 ALC_FIXUP_ACT_PROBE, 1444 ALC_FIXUP_ACT_INIT, 1445 ALC_FIXUP_ACT_BUILD, 1446 }; 1447 1448 static void alc_apply_pincfgs(struct hda_codec *codec, 1449 const struct alc_pincfg *cfg) 1450 { 1451 for (; cfg->nid; cfg++) 1452 snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val); 1453 } 1454 1455 static void alc_apply_fixup(struct hda_codec *codec, int action) 1456 { 1457 struct alc_spec *spec = codec->spec; 1458 int id = spec->fixup_id; 1459 #ifdef CONFIG_SND_DEBUG_VERBOSE 1460 const char *modelname = spec->fixup_name; 1461 #endif 1462 int depth = 0; 1463 1464 if (!spec->fixup_list) 1465 return; 1466 1467 while (id >= 0) { 1468 const struct alc_fixup *fix = spec->fixup_list + id; 1469 const struct alc_pincfg *cfg; 1470 1471 switch (fix->type) { 1472 case ALC_FIXUP_SKU: 1473 if (action != ALC_FIXUP_ACT_PRE_PROBE || !fix->v.sku) 1474 break; 1475 snd_printdd(KERN_INFO "hda_codec: %s: " 1476 "Apply sku override for %s\n", 1477 codec->chip_name, modelname); 1478 spec->cdefine.sku_cfg = fix->v.sku; 1479 spec->cdefine.fixup = 1; 1480 break; 1481 case ALC_FIXUP_PINS: 1482 cfg = fix->v.pins; 1483 if (action != ALC_FIXUP_ACT_PRE_PROBE || !cfg) 1484 break; 1485 snd_printdd(KERN_INFO "hda_codec: %s: " 1486 "Apply pincfg for %s\n", 1487 codec->chip_name, modelname); 1488 alc_apply_pincfgs(codec, cfg); 1489 break; 1490 case ALC_FIXUP_VERBS: 1491 if (action != ALC_FIXUP_ACT_PROBE || !fix->v.verbs) 1492 break; 1493 snd_printdd(KERN_INFO "hda_codec: %s: " 1494 "Apply fix-verbs for %s\n", 1495 codec->chip_name, modelname); 1496 add_verb(codec->spec, fix->v.verbs); 1497 break; 1498 case ALC_FIXUP_FUNC: 1499 if (!fix->v.func) 1500 break; 1501 snd_printdd(KERN_INFO "hda_codec: %s: " 1502 "Apply fix-func for %s\n", 1503 codec->chip_name, modelname); 1504 fix->v.func(codec, fix, action); 1505 break; 1506 default: 1507 snd_printk(KERN_ERR "hda_codec: %s: " 1508 "Invalid fixup type %d\n", 1509 codec->chip_name, fix->type); 1510 break; 1511 } 1512 if (!fix->chained) 1513 break; 1514 if (++depth > 10) 1515 break; 1516 id = fix->chain_id; 1517 } 1518 } 1519 1520 static void alc_pick_fixup(struct hda_codec *codec, 1521 const struct alc_model_fixup *models, 1522 const struct snd_pci_quirk *quirk, 1523 const struct alc_fixup *fixlist) 1524 { 1525 struct alc_spec *spec = codec->spec; 1526 const struct snd_pci_quirk *q; 1527 int id = -1; 1528 const char *name = NULL; 1529 1530 /* when model=nofixup is given, don't pick up any fixups */ 1531 if (codec->modelname && !strcmp(codec->modelname, "nofixup")) { 1532 spec->fixup_list = NULL; 1533 spec->fixup_id = -1; 1534 return; 1535 } 1536 1537 if (codec->modelname && models) { 1538 while (models->name) { 1539 if (!strcmp(codec->modelname, models->name)) { 1540 id = models->id; 1541 name = models->name; 1542 break; 1543 } 1544 models++; 1545 } 1546 } 1547 if (id < 0) { 1548 q = snd_pci_quirk_lookup(codec->bus->pci, quirk); 1549 if (q) { 1550 id = q->value; 1551 #ifdef CONFIG_SND_DEBUG_VERBOSE 1552 name = q->name; 1553 #endif 1554 } 1555 } 1556 if (id < 0) { 1557 for (q = quirk; q->subvendor; q++) { 1558 unsigned int vendorid = 1559 q->subdevice | (q->subvendor << 16); 1560 if (vendorid == codec->subsystem_id) { 1561 id = q->value; 1562 #ifdef CONFIG_SND_DEBUG_VERBOSE 1563 name = q->name; 1564 #endif 1565 break; 1566 } 1567 } 1568 } 1569 1570 spec->fixup_id = id; 1571 if (id >= 0) { 1572 spec->fixup_list = fixlist; 1573 spec->fixup_name = name; 1574 } 1575 } 1576 1577 /* 1578 * COEF access helper functions 1579 */ 1580 static int alc_read_coef_idx(struct hda_codec *codec, 1581 unsigned int coef_idx) 1582 { 1583 unsigned int val; 1584 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 1585 coef_idx); 1586 val = snd_hda_codec_read(codec, 0x20, 0, 1587 AC_VERB_GET_PROC_COEF, 0); 1588 return val; 1589 } 1590 1591 static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx, 1592 unsigned int coef_val) 1593 { 1594 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 1595 coef_idx); 1596 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 1597 coef_val); 1598 } 1599 1600 /* a special bypass for COEF 0; read the cached value at the second time */ 1601 static unsigned int alc_get_coef0(struct hda_codec *codec) 1602 { 1603 struct alc_spec *spec = codec->spec; 1604 if (!spec->coef0) 1605 spec->coef0 = alc_read_coef_idx(codec, 0); 1606 return spec->coef0; 1607 } 1608 1609 /* 1610 * Digital I/O handling 1611 */ 1612 1613 /* set right pin controls for digital I/O */ 1614 static void alc_auto_init_digital(struct hda_codec *codec) 1615 { 1616 struct alc_spec *spec = codec->spec; 1617 int i; 1618 hda_nid_t pin, dac; 1619 1620 for (i = 0; i < spec->autocfg.dig_outs; i++) { 1621 pin = spec->autocfg.dig_out_pins[i]; 1622 if (!pin) 1623 continue; 1624 snd_hda_codec_write(codec, pin, 0, 1625 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 1626 if (!i) 1627 dac = spec->multiout.dig_out_nid; 1628 else 1629 dac = spec->slave_dig_outs[i - 1]; 1630 if (!dac || !(get_wcaps(codec, dac) & AC_WCAP_OUT_AMP)) 1631 continue; 1632 snd_hda_codec_write(codec, dac, 0, 1633 AC_VERB_SET_AMP_GAIN_MUTE, 1634 AMP_OUT_UNMUTE); 1635 } 1636 pin = spec->autocfg.dig_in_pin; 1637 if (pin) 1638 snd_hda_codec_write(codec, pin, 0, 1639 AC_VERB_SET_PIN_WIDGET_CONTROL, 1640 PIN_IN); 1641 } 1642 1643 /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */ 1644 static void alc_auto_parse_digital(struct hda_codec *codec) 1645 { 1646 struct alc_spec *spec = codec->spec; 1647 int i, err, nums; 1648 hda_nid_t dig_nid; 1649 1650 /* support multiple SPDIFs; the secondary is set up as a slave */ 1651 nums = 0; 1652 for (i = 0; i < spec->autocfg.dig_outs; i++) { 1653 hda_nid_t conn[4]; 1654 err = snd_hda_get_connections(codec, 1655 spec->autocfg.dig_out_pins[i], 1656 conn, ARRAY_SIZE(conn)); 1657 if (err <= 0) 1658 continue; 1659 dig_nid = conn[0]; /* assume the first element is audio-out */ 1660 if (!nums) { 1661 spec->multiout.dig_out_nid = dig_nid; 1662 spec->dig_out_type = spec->autocfg.dig_out_type[0]; 1663 } else { 1664 spec->multiout.slave_dig_outs = spec->slave_dig_outs; 1665 if (nums >= ARRAY_SIZE(spec->slave_dig_outs) - 1) 1666 break; 1667 spec->slave_dig_outs[nums - 1] = dig_nid; 1668 } 1669 nums++; 1670 } 1671 1672 if (spec->autocfg.dig_in_pin) { 1673 dig_nid = codec->start_nid; 1674 for (i = 0; i < codec->num_nodes; i++, dig_nid++) { 1675 unsigned int wcaps = get_wcaps(codec, dig_nid); 1676 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN) 1677 continue; 1678 if (!(wcaps & AC_WCAP_DIGITAL)) 1679 continue; 1680 if (!(wcaps & AC_WCAP_CONN_LIST)) 1681 continue; 1682 err = get_connection_index(codec, dig_nid, 1683 spec->autocfg.dig_in_pin); 1684 if (err >= 0) { 1685 spec->dig_in_nid = dig_nid; 1686 break; 1687 } 1688 } 1689 } 1690 } 1691 1692 /* 1693 * capture mixer elements 1694 */ 1695 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol, 1696 struct snd_ctl_elem_info *uinfo) 1697 { 1698 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1699 struct alc_spec *spec = codec->spec; 1700 unsigned long val; 1701 int err; 1702 1703 mutex_lock(&codec->control_mutex); 1704 if (spec->vol_in_capsrc) 1705 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT); 1706 else 1707 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT); 1708 kcontrol->private_value = val; 1709 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo); 1710 mutex_unlock(&codec->control_mutex); 1711 return err; 1712 } 1713 1714 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag, 1715 unsigned int size, unsigned int __user *tlv) 1716 { 1717 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1718 struct alc_spec *spec = codec->spec; 1719 unsigned long val; 1720 int err; 1721 1722 mutex_lock(&codec->control_mutex); 1723 if (spec->vol_in_capsrc) 1724 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT); 1725 else 1726 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT); 1727 kcontrol->private_value = val; 1728 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv); 1729 mutex_unlock(&codec->control_mutex); 1730 return err; 1731 } 1732 1733 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol, 1734 struct snd_ctl_elem_value *ucontrol); 1735 1736 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol, 1737 struct snd_ctl_elem_value *ucontrol, 1738 getput_call_t func, bool check_adc_switch) 1739 { 1740 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1741 struct alc_spec *spec = codec->spec; 1742 int i, err = 0; 1743 1744 mutex_lock(&codec->control_mutex); 1745 if (check_adc_switch && spec->dyn_adc_switch) { 1746 for (i = 0; i < spec->num_adc_nids; i++) { 1747 kcontrol->private_value = 1748 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i], 1749 3, 0, HDA_INPUT); 1750 err = func(kcontrol, ucontrol); 1751 if (err < 0) 1752 goto error; 1753 } 1754 } else { 1755 i = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 1756 if (spec->vol_in_capsrc) 1757 kcontrol->private_value = 1758 HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[i], 1759 3, 0, HDA_OUTPUT); 1760 else 1761 kcontrol->private_value = 1762 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i], 1763 3, 0, HDA_INPUT); 1764 err = func(kcontrol, ucontrol); 1765 } 1766 error: 1767 mutex_unlock(&codec->control_mutex); 1768 return err; 1769 } 1770 1771 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol, 1772 struct snd_ctl_elem_value *ucontrol) 1773 { 1774 return alc_cap_getput_caller(kcontrol, ucontrol, 1775 snd_hda_mixer_amp_volume_get, false); 1776 } 1777 1778 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol, 1779 struct snd_ctl_elem_value *ucontrol) 1780 { 1781 return alc_cap_getput_caller(kcontrol, ucontrol, 1782 snd_hda_mixer_amp_volume_put, true); 1783 } 1784 1785 /* capture mixer elements */ 1786 #define alc_cap_sw_info snd_ctl_boolean_stereo_info 1787 1788 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol, 1789 struct snd_ctl_elem_value *ucontrol) 1790 { 1791 return alc_cap_getput_caller(kcontrol, ucontrol, 1792 snd_hda_mixer_amp_switch_get, false); 1793 } 1794 1795 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol, 1796 struct snd_ctl_elem_value *ucontrol) 1797 { 1798 return alc_cap_getput_caller(kcontrol, ucontrol, 1799 snd_hda_mixer_amp_switch_put, true); 1800 } 1801 1802 #define _DEFINE_CAPMIX(num) \ 1803 { \ 1804 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 1805 .name = "Capture Switch", \ 1806 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \ 1807 .count = num, \ 1808 .info = alc_cap_sw_info, \ 1809 .get = alc_cap_sw_get, \ 1810 .put = alc_cap_sw_put, \ 1811 }, \ 1812 { \ 1813 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 1814 .name = "Capture Volume", \ 1815 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \ 1816 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \ 1817 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \ 1818 .count = num, \ 1819 .info = alc_cap_vol_info, \ 1820 .get = alc_cap_vol_get, \ 1821 .put = alc_cap_vol_put, \ 1822 .tlv = { .c = alc_cap_vol_tlv }, \ 1823 } 1824 1825 #define _DEFINE_CAPSRC(num) \ 1826 { \ 1827 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 1828 /* .name = "Capture Source", */ \ 1829 .name = "Input Source", \ 1830 .count = num, \ 1831 .info = alc_mux_enum_info, \ 1832 .get = alc_mux_enum_get, \ 1833 .put = alc_mux_enum_put, \ 1834 } 1835 1836 #define DEFINE_CAPMIX(num) \ 1837 static const struct snd_kcontrol_new alc_capture_mixer ## num[] = { \ 1838 _DEFINE_CAPMIX(num), \ 1839 _DEFINE_CAPSRC(num), \ 1840 { } /* end */ \ 1841 } 1842 1843 #define DEFINE_CAPMIX_NOSRC(num) \ 1844 static const struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \ 1845 _DEFINE_CAPMIX(num), \ 1846 { } /* end */ \ 1847 } 1848 1849 /* up to three ADCs */ 1850 DEFINE_CAPMIX(1); 1851 DEFINE_CAPMIX(2); 1852 DEFINE_CAPMIX(3); 1853 DEFINE_CAPMIX_NOSRC(1); 1854 DEFINE_CAPMIX_NOSRC(2); 1855 DEFINE_CAPMIX_NOSRC(3); 1856 1857 /* 1858 * virtual master controls 1859 */ 1860 1861 /* 1862 * slave controls for virtual master 1863 */ 1864 static const char * const alc_slave_pfxs[] = { 1865 "Front", "Surround", "Center", "LFE", "Side", 1866 "Headphone", "Speaker", "Mono", "Line Out", 1867 "CLFE", "Bass Speaker", "PCM", 1868 NULL, 1869 }; 1870 1871 /* 1872 * build control elements 1873 */ 1874 1875 #define NID_MAPPING (-1) 1876 1877 #define SUBDEV_SPEAKER_ (0 << 6) 1878 #define SUBDEV_HP_ (1 << 6) 1879 #define SUBDEV_LINE_ (2 << 6) 1880 #define SUBDEV_SPEAKER(x) (SUBDEV_SPEAKER_ | ((x) & 0x3f)) 1881 #define SUBDEV_HP(x) (SUBDEV_HP_ | ((x) & 0x3f)) 1882 #define SUBDEV_LINE(x) (SUBDEV_LINE_ | ((x) & 0x3f)) 1883 1884 static void alc_free_kctls(struct hda_codec *codec); 1885 1886 #ifdef CONFIG_SND_HDA_INPUT_BEEP 1887 /* additional beep mixers; the actual parameters are overwritten at build */ 1888 static const struct snd_kcontrol_new alc_beep_mixer[] = { 1889 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT), 1890 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT), 1891 { } /* end */ 1892 }; 1893 #endif 1894 1895 static int __alc_build_controls(struct hda_codec *codec) 1896 { 1897 struct alc_spec *spec = codec->spec; 1898 struct snd_kcontrol *kctl = NULL; 1899 const struct snd_kcontrol_new *knew; 1900 int i, j, err; 1901 unsigned int u; 1902 hda_nid_t nid; 1903 1904 for (i = 0; i < spec->num_mixers; i++) { 1905 err = snd_hda_add_new_ctls(codec, spec->mixers[i]); 1906 if (err < 0) 1907 return err; 1908 } 1909 if (spec->cap_mixer) { 1910 err = snd_hda_add_new_ctls(codec, spec->cap_mixer); 1911 if (err < 0) 1912 return err; 1913 } 1914 if (spec->multiout.dig_out_nid) { 1915 err = snd_hda_create_spdif_out_ctls(codec, 1916 spec->multiout.dig_out_nid, 1917 spec->multiout.dig_out_nid); 1918 if (err < 0) 1919 return err; 1920 if (!spec->no_analog) { 1921 err = snd_hda_create_spdif_share_sw(codec, 1922 &spec->multiout); 1923 if (err < 0) 1924 return err; 1925 spec->multiout.share_spdif = 1; 1926 } 1927 } 1928 if (spec->dig_in_nid) { 1929 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid); 1930 if (err < 0) 1931 return err; 1932 } 1933 1934 #ifdef CONFIG_SND_HDA_INPUT_BEEP 1935 /* create beep controls if needed */ 1936 if (spec->beep_amp) { 1937 const struct snd_kcontrol_new *knew; 1938 for (knew = alc_beep_mixer; knew->name; knew++) { 1939 struct snd_kcontrol *kctl; 1940 kctl = snd_ctl_new1(knew, codec); 1941 if (!kctl) 1942 return -ENOMEM; 1943 kctl->private_value = spec->beep_amp; 1944 err = snd_hda_ctl_add(codec, 0, kctl); 1945 if (err < 0) 1946 return err; 1947 } 1948 } 1949 #endif 1950 1951 /* if we have no master control, let's create it */ 1952 if (!spec->no_analog && 1953 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) { 1954 unsigned int vmaster_tlv[4]; 1955 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid, 1956 HDA_OUTPUT, vmaster_tlv); 1957 err = snd_hda_add_vmaster(codec, "Master Playback Volume", 1958 vmaster_tlv, alc_slave_pfxs, 1959 "Playback Volume"); 1960 if (err < 0) 1961 return err; 1962 } 1963 if (!spec->no_analog && 1964 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) { 1965 err = __snd_hda_add_vmaster(codec, "Master Playback Switch", 1966 NULL, alc_slave_pfxs, 1967 "Playback Switch", 1968 true, &spec->vmaster_mute.sw_kctl); 1969 if (err < 0) 1970 return err; 1971 } 1972 1973 /* assign Capture Source enums to NID */ 1974 if (spec->capsrc_nids || spec->adc_nids) { 1975 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source"); 1976 if (!kctl) 1977 kctl = snd_hda_find_mixer_ctl(codec, "Input Source"); 1978 for (i = 0; kctl && i < kctl->count; i++) { 1979 err = snd_hda_add_nid(codec, kctl, i, 1980 get_capsrc(spec, i)); 1981 if (err < 0) 1982 return err; 1983 } 1984 } 1985 if (spec->cap_mixer && spec->adc_nids) { 1986 const char *kname = kctl ? kctl->id.name : NULL; 1987 for (knew = spec->cap_mixer; knew->name; knew++) { 1988 if (kname && strcmp(knew->name, kname) == 0) 1989 continue; 1990 kctl = snd_hda_find_mixer_ctl(codec, knew->name); 1991 for (i = 0; kctl && i < kctl->count; i++) { 1992 err = snd_hda_add_nid(codec, kctl, i, 1993 spec->adc_nids[i]); 1994 if (err < 0) 1995 return err; 1996 } 1997 } 1998 } 1999 2000 /* other nid->control mapping */ 2001 for (i = 0; i < spec->num_mixers; i++) { 2002 for (knew = spec->mixers[i]; knew->name; knew++) { 2003 if (knew->iface != NID_MAPPING) 2004 continue; 2005 kctl = snd_hda_find_mixer_ctl(codec, knew->name); 2006 if (kctl == NULL) 2007 continue; 2008 u = knew->subdevice; 2009 for (j = 0; j < 4; j++, u >>= 8) { 2010 nid = u & 0x3f; 2011 if (nid == 0) 2012 continue; 2013 switch (u & 0xc0) { 2014 case SUBDEV_SPEAKER_: 2015 nid = spec->autocfg.speaker_pins[nid]; 2016 break; 2017 case SUBDEV_LINE_: 2018 nid = spec->autocfg.line_out_pins[nid]; 2019 break; 2020 case SUBDEV_HP_: 2021 nid = spec->autocfg.hp_pins[nid]; 2022 break; 2023 default: 2024 continue; 2025 } 2026 err = snd_hda_add_nid(codec, kctl, 0, nid); 2027 if (err < 0) 2028 return err; 2029 } 2030 u = knew->private_value; 2031 for (j = 0; j < 4; j++, u >>= 8) { 2032 nid = u & 0xff; 2033 if (nid == 0) 2034 continue; 2035 err = snd_hda_add_nid(codec, kctl, 0, nid); 2036 if (err < 0) 2037 return err; 2038 } 2039 } 2040 } 2041 2042 alc_free_kctls(codec); /* no longer needed */ 2043 2044 return 0; 2045 } 2046 2047 static int alc_build_controls(struct hda_codec *codec) 2048 { 2049 struct alc_spec *spec = codec->spec; 2050 int err = __alc_build_controls(codec); 2051 if (err < 0) 2052 return err; 2053 err = snd_hda_jack_add_kctls(codec, &spec->autocfg); 2054 if (err < 0) 2055 return err; 2056 alc_apply_fixup(codec, ALC_FIXUP_ACT_BUILD); 2057 return 0; 2058 } 2059 2060 2061 /* 2062 * Common callbacks 2063 */ 2064 2065 static void alc_init_special_input_src(struct hda_codec *codec); 2066 static void alc_auto_init_std(struct hda_codec *codec); 2067 2068 static int alc_init(struct hda_codec *codec) 2069 { 2070 struct alc_spec *spec = codec->spec; 2071 unsigned int i; 2072 2073 if (spec->init_hook) 2074 spec->init_hook(codec); 2075 2076 alc_fix_pll(codec); 2077 alc_auto_init_amp(codec, spec->init_amp); 2078 2079 for (i = 0; i < spec->num_init_verbs; i++) 2080 snd_hda_sequence_write(codec, spec->init_verbs[i]); 2081 alc_init_special_input_src(codec); 2082 alc_auto_init_std(codec); 2083 2084 alc_apply_fixup(codec, ALC_FIXUP_ACT_INIT); 2085 2086 snd_hda_jack_report_sync(codec); 2087 2088 hda_call_check_power_status(codec, 0x01); 2089 return 0; 2090 } 2091 2092 static void alc_unsol_event(struct hda_codec *codec, unsigned int res) 2093 { 2094 struct alc_spec *spec = codec->spec; 2095 2096 if (spec->unsol_event) 2097 spec->unsol_event(codec, res); 2098 } 2099 2100 #ifdef CONFIG_SND_HDA_POWER_SAVE 2101 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid) 2102 { 2103 struct alc_spec *spec = codec->spec; 2104 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid); 2105 } 2106 #endif 2107 2108 /* 2109 * Analog playback callbacks 2110 */ 2111 static int alc_playback_pcm_open(struct hda_pcm_stream *hinfo, 2112 struct hda_codec *codec, 2113 struct snd_pcm_substream *substream) 2114 { 2115 struct alc_spec *spec = codec->spec; 2116 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, 2117 hinfo); 2118 } 2119 2120 static int alc_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 2121 struct hda_codec *codec, 2122 unsigned int stream_tag, 2123 unsigned int format, 2124 struct snd_pcm_substream *substream) 2125 { 2126 struct alc_spec *spec = codec->spec; 2127 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, 2128 stream_tag, format, substream); 2129 } 2130 2131 static int alc_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 2132 struct hda_codec *codec, 2133 struct snd_pcm_substream *substream) 2134 { 2135 struct alc_spec *spec = codec->spec; 2136 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); 2137 } 2138 2139 /* 2140 * Digital out 2141 */ 2142 static int alc_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, 2143 struct hda_codec *codec, 2144 struct snd_pcm_substream *substream) 2145 { 2146 struct alc_spec *spec = codec->spec; 2147 return snd_hda_multi_out_dig_open(codec, &spec->multiout); 2148 } 2149 2150 static int alc_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 2151 struct hda_codec *codec, 2152 unsigned int stream_tag, 2153 unsigned int format, 2154 struct snd_pcm_substream *substream) 2155 { 2156 struct alc_spec *spec = codec->spec; 2157 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, 2158 stream_tag, format, substream); 2159 } 2160 2161 static int alc_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 2162 struct hda_codec *codec, 2163 struct snd_pcm_substream *substream) 2164 { 2165 struct alc_spec *spec = codec->spec; 2166 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout); 2167 } 2168 2169 static int alc_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, 2170 struct hda_codec *codec, 2171 struct snd_pcm_substream *substream) 2172 { 2173 struct alc_spec *spec = codec->spec; 2174 return snd_hda_multi_out_dig_close(codec, &spec->multiout); 2175 } 2176 2177 /* 2178 * Analog capture 2179 */ 2180 static int alc_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 2181 struct hda_codec *codec, 2182 unsigned int stream_tag, 2183 unsigned int format, 2184 struct snd_pcm_substream *substream) 2185 { 2186 struct alc_spec *spec = codec->spec; 2187 2188 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1], 2189 stream_tag, 0, format); 2190 return 0; 2191 } 2192 2193 static int alc_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 2194 struct hda_codec *codec, 2195 struct snd_pcm_substream *substream) 2196 { 2197 struct alc_spec *spec = codec->spec; 2198 2199 snd_hda_codec_cleanup_stream(codec, 2200 spec->adc_nids[substream->number + 1]); 2201 return 0; 2202 } 2203 2204 /* analog capture with dynamic dual-adc changes */ 2205 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 2206 struct hda_codec *codec, 2207 unsigned int stream_tag, 2208 unsigned int format, 2209 struct snd_pcm_substream *substream) 2210 { 2211 struct alc_spec *spec = codec->spec; 2212 spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]]; 2213 spec->cur_adc_stream_tag = stream_tag; 2214 spec->cur_adc_format = format; 2215 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format); 2216 return 0; 2217 } 2218 2219 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 2220 struct hda_codec *codec, 2221 struct snd_pcm_substream *substream) 2222 { 2223 struct alc_spec *spec = codec->spec; 2224 snd_hda_codec_cleanup_stream(codec, spec->cur_adc); 2225 spec->cur_adc = 0; 2226 return 0; 2227 } 2228 2229 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = { 2230 .substreams = 1, 2231 .channels_min = 2, 2232 .channels_max = 2, 2233 .nid = 0, /* fill later */ 2234 .ops = { 2235 .prepare = dyn_adc_capture_pcm_prepare, 2236 .cleanup = dyn_adc_capture_pcm_cleanup 2237 }, 2238 }; 2239 2240 /* 2241 */ 2242 static const struct hda_pcm_stream alc_pcm_analog_playback = { 2243 .substreams = 1, 2244 .channels_min = 2, 2245 .channels_max = 8, 2246 /* NID is set in alc_build_pcms */ 2247 .ops = { 2248 .open = alc_playback_pcm_open, 2249 .prepare = alc_playback_pcm_prepare, 2250 .cleanup = alc_playback_pcm_cleanup 2251 }, 2252 }; 2253 2254 static const struct hda_pcm_stream alc_pcm_analog_capture = { 2255 .substreams = 1, 2256 .channels_min = 2, 2257 .channels_max = 2, 2258 /* NID is set in alc_build_pcms */ 2259 }; 2260 2261 static const struct hda_pcm_stream alc_pcm_analog_alt_playback = { 2262 .substreams = 1, 2263 .channels_min = 2, 2264 .channels_max = 2, 2265 /* NID is set in alc_build_pcms */ 2266 }; 2267 2268 static const struct hda_pcm_stream alc_pcm_analog_alt_capture = { 2269 .substreams = 2, /* can be overridden */ 2270 .channels_min = 2, 2271 .channels_max = 2, 2272 /* NID is set in alc_build_pcms */ 2273 .ops = { 2274 .prepare = alc_alt_capture_pcm_prepare, 2275 .cleanup = alc_alt_capture_pcm_cleanup 2276 }, 2277 }; 2278 2279 static const struct hda_pcm_stream alc_pcm_digital_playback = { 2280 .substreams = 1, 2281 .channels_min = 2, 2282 .channels_max = 2, 2283 /* NID is set in alc_build_pcms */ 2284 .ops = { 2285 .open = alc_dig_playback_pcm_open, 2286 .close = alc_dig_playback_pcm_close, 2287 .prepare = alc_dig_playback_pcm_prepare, 2288 .cleanup = alc_dig_playback_pcm_cleanup 2289 }, 2290 }; 2291 2292 static const struct hda_pcm_stream alc_pcm_digital_capture = { 2293 .substreams = 1, 2294 .channels_min = 2, 2295 .channels_max = 2, 2296 /* NID is set in alc_build_pcms */ 2297 }; 2298 2299 /* Used by alc_build_pcms to flag that a PCM has no playback stream */ 2300 static const struct hda_pcm_stream alc_pcm_null_stream = { 2301 .substreams = 0, 2302 .channels_min = 0, 2303 .channels_max = 0, 2304 }; 2305 2306 static int alc_build_pcms(struct hda_codec *codec) 2307 { 2308 struct alc_spec *spec = codec->spec; 2309 struct hda_pcm *info = spec->pcm_rec; 2310 const struct hda_pcm_stream *p; 2311 bool have_multi_adcs; 2312 int i; 2313 2314 codec->num_pcms = 1; 2315 codec->pcm_info = info; 2316 2317 if (spec->no_analog) 2318 goto skip_analog; 2319 2320 snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog), 2321 "%s Analog", codec->chip_name); 2322 info->name = spec->stream_name_analog; 2323 2324 if (spec->multiout.num_dacs > 0) { 2325 p = spec->stream_analog_playback; 2326 if (!p) 2327 p = &alc_pcm_analog_playback; 2328 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p; 2329 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0]; 2330 } 2331 if (spec->adc_nids) { 2332 p = spec->stream_analog_capture; 2333 if (!p) { 2334 if (spec->dyn_adc_switch) 2335 p = &dyn_adc_pcm_analog_capture; 2336 else 2337 p = &alc_pcm_analog_capture; 2338 } 2339 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p; 2340 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; 2341 } 2342 2343 if (spec->channel_mode) { 2344 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0; 2345 for (i = 0; i < spec->num_channel_mode; i++) { 2346 if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) { 2347 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels; 2348 } 2349 } 2350 } 2351 2352 skip_analog: 2353 /* SPDIF for stream index #1 */ 2354 if (spec->multiout.dig_out_nid || spec->dig_in_nid) { 2355 snprintf(spec->stream_name_digital, 2356 sizeof(spec->stream_name_digital), 2357 "%s Digital", codec->chip_name); 2358 codec->num_pcms = 2; 2359 codec->slave_dig_outs = spec->multiout.slave_dig_outs; 2360 info = spec->pcm_rec + 1; 2361 info->name = spec->stream_name_digital; 2362 if (spec->dig_out_type) 2363 info->pcm_type = spec->dig_out_type; 2364 else 2365 info->pcm_type = HDA_PCM_TYPE_SPDIF; 2366 if (spec->multiout.dig_out_nid) { 2367 p = spec->stream_digital_playback; 2368 if (!p) 2369 p = &alc_pcm_digital_playback; 2370 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p; 2371 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid; 2372 } 2373 if (spec->dig_in_nid) { 2374 p = spec->stream_digital_capture; 2375 if (!p) 2376 p = &alc_pcm_digital_capture; 2377 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p; 2378 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid; 2379 } 2380 /* FIXME: do we need this for all Realtek codec models? */ 2381 codec->spdif_status_reset = 1; 2382 } 2383 2384 if (spec->no_analog) 2385 return 0; 2386 2387 /* If the use of more than one ADC is requested for the current 2388 * model, configure a second analog capture-only PCM. 2389 */ 2390 have_multi_adcs = (spec->num_adc_nids > 1) && 2391 !spec->dyn_adc_switch && !spec->auto_mic && 2392 (!spec->input_mux || spec->input_mux->num_items > 1); 2393 /* Additional Analaog capture for index #2 */ 2394 if (spec->alt_dac_nid || have_multi_adcs) { 2395 codec->num_pcms = 3; 2396 info = spec->pcm_rec + 2; 2397 info->name = spec->stream_name_analog; 2398 if (spec->alt_dac_nid) { 2399 p = spec->stream_analog_alt_playback; 2400 if (!p) 2401 p = &alc_pcm_analog_alt_playback; 2402 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p; 2403 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 2404 spec->alt_dac_nid; 2405 } else { 2406 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 2407 alc_pcm_null_stream; 2408 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0; 2409 } 2410 if (have_multi_adcs) { 2411 p = spec->stream_analog_alt_capture; 2412 if (!p) 2413 p = &alc_pcm_analog_alt_capture; 2414 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p; 2415 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 2416 spec->adc_nids[1]; 2417 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 2418 spec->num_adc_nids - 1; 2419 } else { 2420 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 2421 alc_pcm_null_stream; 2422 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0; 2423 } 2424 } 2425 2426 return 0; 2427 } 2428 2429 static inline void alc_shutup(struct hda_codec *codec) 2430 { 2431 struct alc_spec *spec = codec->spec; 2432 2433 if (spec && spec->shutup) 2434 spec->shutup(codec); 2435 snd_hda_shutup_pins(codec); 2436 } 2437 2438 static void alc_free_kctls(struct hda_codec *codec) 2439 { 2440 struct alc_spec *spec = codec->spec; 2441 2442 if (spec->kctls.list) { 2443 struct snd_kcontrol_new *kctl = spec->kctls.list; 2444 int i; 2445 for (i = 0; i < spec->kctls.used; i++) 2446 kfree(kctl[i].name); 2447 } 2448 snd_array_free(&spec->kctls); 2449 } 2450 2451 static void alc_free_bind_ctls(struct hda_codec *codec) 2452 { 2453 struct alc_spec *spec = codec->spec; 2454 if (spec->bind_ctls.list) { 2455 struct hda_bind_ctls **ctl = spec->bind_ctls.list; 2456 int i; 2457 for (i = 0; i < spec->bind_ctls.used; i++) 2458 kfree(ctl[i]); 2459 } 2460 snd_array_free(&spec->bind_ctls); 2461 } 2462 2463 static void alc_free(struct hda_codec *codec) 2464 { 2465 struct alc_spec *spec = codec->spec; 2466 2467 if (!spec) 2468 return; 2469 2470 alc_shutup(codec); 2471 alc_free_kctls(codec); 2472 alc_free_bind_ctls(codec); 2473 kfree(spec); 2474 snd_hda_detach_beep_device(codec); 2475 } 2476 2477 #ifdef CONFIG_SND_HDA_POWER_SAVE 2478 static void alc_power_eapd(struct hda_codec *codec) 2479 { 2480 alc_auto_setup_eapd(codec, false); 2481 } 2482 2483 static int alc_suspend(struct hda_codec *codec, pm_message_t state) 2484 { 2485 struct alc_spec *spec = codec->spec; 2486 alc_shutup(codec); 2487 if (spec && spec->power_hook) 2488 spec->power_hook(codec); 2489 return 0; 2490 } 2491 #endif 2492 2493 #ifdef CONFIG_PM 2494 static int alc_resume(struct hda_codec *codec) 2495 { 2496 msleep(150); /* to avoid pop noise */ 2497 codec->patch_ops.init(codec); 2498 snd_hda_codec_resume_amp(codec); 2499 snd_hda_codec_resume_cache(codec); 2500 hda_call_check_power_status(codec, 0x01); 2501 return 0; 2502 } 2503 #endif 2504 2505 /* 2506 */ 2507 static const struct hda_codec_ops alc_patch_ops = { 2508 .build_controls = alc_build_controls, 2509 .build_pcms = alc_build_pcms, 2510 .init = alc_init, 2511 .free = alc_free, 2512 .unsol_event = alc_unsol_event, 2513 #ifdef CONFIG_PM 2514 .resume = alc_resume, 2515 #endif 2516 #ifdef CONFIG_SND_HDA_POWER_SAVE 2517 .suspend = alc_suspend, 2518 .check_power_status = alc_check_power_status, 2519 #endif 2520 .reboot_notify = alc_shutup, 2521 }; 2522 2523 /* replace the codec chip_name with the given string */ 2524 static int alc_codec_rename(struct hda_codec *codec, const char *name) 2525 { 2526 kfree(codec->chip_name); 2527 codec->chip_name = kstrdup(name, GFP_KERNEL); 2528 if (!codec->chip_name) { 2529 alc_free(codec); 2530 return -ENOMEM; 2531 } 2532 return 0; 2533 } 2534 2535 /* 2536 * Rename codecs appropriately from COEF value 2537 */ 2538 struct alc_codec_rename_table { 2539 unsigned int vendor_id; 2540 unsigned short coef_mask; 2541 unsigned short coef_bits; 2542 const char *name; 2543 }; 2544 2545 static struct alc_codec_rename_table rename_tbl[] = { 2546 { 0x10ec0269, 0xfff0, 0x3010, "ALC277" }, 2547 { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" }, 2548 { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" }, 2549 { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" }, 2550 { 0x10ec0269, 0xffff, 0xa023, "ALC259" }, 2551 { 0x10ec0269, 0xffff, 0x6023, "ALC281X" }, 2552 { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" }, 2553 { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" }, 2554 { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" }, 2555 { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" }, 2556 { 0x10ec0899, 0x2000, 0x2000, "ALC899" }, 2557 { 0x10ec0892, 0xffff, 0x8020, "ALC661" }, 2558 { 0x10ec0892, 0xffff, 0x8011, "ALC661" }, 2559 { 0x10ec0892, 0xffff, 0x4011, "ALC656" }, 2560 { } /* terminator */ 2561 }; 2562 2563 static int alc_codec_rename_from_preset(struct hda_codec *codec) 2564 { 2565 const struct alc_codec_rename_table *p; 2566 2567 for (p = rename_tbl; p->vendor_id; p++) { 2568 if (p->vendor_id != codec->vendor_id) 2569 continue; 2570 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits) 2571 return alc_codec_rename(codec, p->name); 2572 } 2573 return 0; 2574 } 2575 2576 /* 2577 * Automatic parse of I/O pins from the BIOS configuration 2578 */ 2579 2580 enum { 2581 ALC_CTL_WIDGET_VOL, 2582 ALC_CTL_WIDGET_MUTE, 2583 ALC_CTL_BIND_MUTE, 2584 ALC_CTL_BIND_VOL, 2585 ALC_CTL_BIND_SW, 2586 }; 2587 static const struct snd_kcontrol_new alc_control_templates[] = { 2588 HDA_CODEC_VOLUME(NULL, 0, 0, 0), 2589 HDA_CODEC_MUTE(NULL, 0, 0, 0), 2590 HDA_BIND_MUTE(NULL, 0, 0, 0), 2591 HDA_BIND_VOL(NULL, 0), 2592 HDA_BIND_SW(NULL, 0), 2593 }; 2594 2595 /* add dynamic controls */ 2596 static int add_control(struct alc_spec *spec, int type, const char *name, 2597 int cidx, unsigned long val) 2598 { 2599 struct snd_kcontrol_new *knew; 2600 2601 knew = alc_kcontrol_new(spec); 2602 if (!knew) 2603 return -ENOMEM; 2604 *knew = alc_control_templates[type]; 2605 knew->name = kstrdup(name, GFP_KERNEL); 2606 if (!knew->name) 2607 return -ENOMEM; 2608 knew->index = cidx; 2609 if (get_amp_nid_(val)) 2610 knew->subdevice = HDA_SUBDEV_AMP_FLAG; 2611 knew->private_value = val; 2612 return 0; 2613 } 2614 2615 static int add_control_with_pfx(struct alc_spec *spec, int type, 2616 const char *pfx, const char *dir, 2617 const char *sfx, int cidx, unsigned long val) 2618 { 2619 char name[32]; 2620 snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx); 2621 return add_control(spec, type, name, cidx, val); 2622 } 2623 2624 #define add_pb_vol_ctrl(spec, type, pfx, val) \ 2625 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val) 2626 #define add_pb_sw_ctrl(spec, type, pfx, val) \ 2627 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val) 2628 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \ 2629 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val) 2630 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \ 2631 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val) 2632 2633 static const char * const channel_name[4] = { 2634 "Front", "Surround", "CLFE", "Side" 2635 }; 2636 2637 static const char *alc_get_line_out_pfx(struct alc_spec *spec, int ch, 2638 bool can_be_master, int *index) 2639 { 2640 struct auto_pin_cfg *cfg = &spec->autocfg; 2641 2642 *index = 0; 2643 if (cfg->line_outs == 1 && !spec->multi_ios && 2644 !cfg->hp_outs && !cfg->speaker_outs && can_be_master) 2645 return "Master"; 2646 2647 switch (cfg->line_out_type) { 2648 case AUTO_PIN_SPEAKER_OUT: 2649 if (cfg->line_outs == 1) 2650 return "Speaker"; 2651 if (cfg->line_outs == 2) 2652 return ch ? "Bass Speaker" : "Speaker"; 2653 break; 2654 case AUTO_PIN_HP_OUT: 2655 /* for multi-io case, only the primary out */ 2656 if (ch && spec->multi_ios) 2657 break; 2658 *index = ch; 2659 return "Headphone"; 2660 default: 2661 if (cfg->line_outs == 1 && !spec->multi_ios) 2662 return "PCM"; 2663 break; 2664 } 2665 if (snd_BUG_ON(ch >= ARRAY_SIZE(channel_name))) 2666 return "PCM"; 2667 2668 return channel_name[ch]; 2669 } 2670 2671 #ifdef CONFIG_SND_HDA_POWER_SAVE 2672 /* add the powersave loopback-list entry */ 2673 static void add_loopback_list(struct alc_spec *spec, hda_nid_t mix, int idx) 2674 { 2675 struct hda_amp_list *list; 2676 2677 if (spec->num_loopbacks >= ARRAY_SIZE(spec->loopback_list) - 1) 2678 return; 2679 list = spec->loopback_list + spec->num_loopbacks; 2680 list->nid = mix; 2681 list->dir = HDA_INPUT; 2682 list->idx = idx; 2683 spec->num_loopbacks++; 2684 spec->loopback.amplist = spec->loopback_list; 2685 } 2686 #else 2687 #define add_loopback_list(spec, mix, idx) /* NOP */ 2688 #endif 2689 2690 /* create input playback/capture controls for the given pin */ 2691 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin, 2692 const char *ctlname, int ctlidx, 2693 int idx, hda_nid_t mix_nid) 2694 { 2695 int err; 2696 2697 err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx, 2698 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); 2699 if (err < 0) 2700 return err; 2701 err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx, 2702 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); 2703 if (err < 0) 2704 return err; 2705 add_loopback_list(spec, mix_nid, idx); 2706 return 0; 2707 } 2708 2709 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid) 2710 { 2711 unsigned int pincap = snd_hda_query_pin_caps(codec, nid); 2712 return (pincap & AC_PINCAP_IN) != 0; 2713 } 2714 2715 /* Parse the codec tree and retrieve ADCs and corresponding capsrc MUXs */ 2716 static int alc_auto_fill_adc_caps(struct hda_codec *codec) 2717 { 2718 struct alc_spec *spec = codec->spec; 2719 hda_nid_t nid; 2720 hda_nid_t *adc_nids = spec->private_adc_nids; 2721 hda_nid_t *cap_nids = spec->private_capsrc_nids; 2722 int max_nums = ARRAY_SIZE(spec->private_adc_nids); 2723 int i, nums = 0; 2724 2725 nid = codec->start_nid; 2726 for (i = 0; i < codec->num_nodes; i++, nid++) { 2727 hda_nid_t src; 2728 const hda_nid_t *list; 2729 unsigned int caps = get_wcaps(codec, nid); 2730 int type = get_wcaps_type(caps); 2731 2732 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL)) 2733 continue; 2734 adc_nids[nums] = nid; 2735 cap_nids[nums] = nid; 2736 src = nid; 2737 for (;;) { 2738 int n; 2739 type = get_wcaps_type(get_wcaps(codec, src)); 2740 if (type == AC_WID_PIN) 2741 break; 2742 if (type == AC_WID_AUD_SEL) { 2743 cap_nids[nums] = src; 2744 break; 2745 } 2746 n = snd_hda_get_conn_list(codec, src, &list); 2747 if (n > 1) { 2748 cap_nids[nums] = src; 2749 break; 2750 } else if (n != 1) 2751 break; 2752 src = *list; 2753 } 2754 if (++nums >= max_nums) 2755 break; 2756 } 2757 spec->adc_nids = spec->private_adc_nids; 2758 spec->capsrc_nids = spec->private_capsrc_nids; 2759 spec->num_adc_nids = nums; 2760 return nums; 2761 } 2762 2763 /* create playback/capture controls for input pins */ 2764 static int alc_auto_create_input_ctls(struct hda_codec *codec) 2765 { 2766 struct alc_spec *spec = codec->spec; 2767 const struct auto_pin_cfg *cfg = &spec->autocfg; 2768 hda_nid_t mixer = spec->mixer_nid; 2769 struct hda_input_mux *imux = &spec->private_imux[0]; 2770 int num_adcs; 2771 int i, c, err, idx, type_idx = 0; 2772 const char *prev_label = NULL; 2773 2774 num_adcs = alc_auto_fill_adc_caps(codec); 2775 if (num_adcs < 0) 2776 return 0; 2777 2778 for (i = 0; i < cfg->num_inputs; i++) { 2779 hda_nid_t pin; 2780 const char *label; 2781 2782 pin = cfg->inputs[i].pin; 2783 if (!alc_is_input_pin(codec, pin)) 2784 continue; 2785 2786 label = hda_get_autocfg_input_label(codec, cfg, i); 2787 if (spec->shared_mic_hp && !strcmp(label, "Misc")) 2788 label = "Headphone Mic"; 2789 if (prev_label && !strcmp(label, prev_label)) 2790 type_idx++; 2791 else 2792 type_idx = 0; 2793 prev_label = label; 2794 2795 if (mixer) { 2796 idx = get_connection_index(codec, mixer, pin); 2797 if (idx >= 0) { 2798 err = new_analog_input(spec, pin, 2799 label, type_idx, 2800 idx, mixer); 2801 if (err < 0) 2802 return err; 2803 } 2804 } 2805 2806 for (c = 0; c < num_adcs; c++) { 2807 hda_nid_t cap = get_capsrc(spec, c); 2808 idx = get_connection_index(codec, cap, pin); 2809 if (idx >= 0) { 2810 spec->imux_pins[imux->num_items] = pin; 2811 snd_hda_add_imux_item(imux, label, idx, NULL); 2812 break; 2813 } 2814 } 2815 } 2816 2817 spec->num_mux_defs = 1; 2818 spec->input_mux = imux; 2819 2820 return 0; 2821 } 2822 2823 /* create a shared input with the headphone out */ 2824 static int alc_auto_create_shared_input(struct hda_codec *codec) 2825 { 2826 struct alc_spec *spec = codec->spec; 2827 struct auto_pin_cfg *cfg = &spec->autocfg; 2828 unsigned int defcfg; 2829 hda_nid_t nid; 2830 2831 /* only one internal input pin? */ 2832 if (cfg->num_inputs != 1) 2833 return 0; 2834 defcfg = snd_hda_codec_get_pincfg(codec, cfg->inputs[0].pin); 2835 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT) 2836 return 0; 2837 2838 if (cfg->hp_outs == 1 && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) 2839 nid = cfg->hp_pins[0]; /* OK, we have a single HP-out */ 2840 else if (cfg->line_outs == 1 && cfg->line_out_type == AUTO_PIN_HP_OUT) 2841 nid = cfg->line_out_pins[0]; /* OK, we have a single line-out */ 2842 else 2843 return 0; /* both not available */ 2844 2845 if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_IN)) 2846 return 0; /* no input */ 2847 2848 cfg->inputs[1].pin = nid; 2849 cfg->inputs[1].type = AUTO_PIN_MIC; 2850 cfg->num_inputs = 2; 2851 spec->shared_mic_hp = 1; 2852 snd_printdd("realtek: Enable shared I/O jack on NID 0x%x\n", nid); 2853 return 0; 2854 } 2855 2856 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid, 2857 unsigned int pin_type) 2858 { 2859 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 2860 pin_type); 2861 /* unmute pin */ 2862 if (nid_has_mute(codec, nid, HDA_OUTPUT)) 2863 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, 2864 AMP_OUT_UNMUTE); 2865 } 2866 2867 static int get_pin_type(int line_out_type) 2868 { 2869 if (line_out_type == AUTO_PIN_HP_OUT) 2870 return PIN_HP; 2871 else 2872 return PIN_OUT; 2873 } 2874 2875 static void alc_auto_init_analog_input(struct hda_codec *codec) 2876 { 2877 struct alc_spec *spec = codec->spec; 2878 struct auto_pin_cfg *cfg = &spec->autocfg; 2879 int i; 2880 2881 for (i = 0; i < cfg->num_inputs; i++) { 2882 hda_nid_t nid = cfg->inputs[i].pin; 2883 if (alc_is_input_pin(codec, nid)) { 2884 alc_set_input_pin(codec, nid, cfg->inputs[i].type); 2885 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) 2886 snd_hda_codec_write(codec, nid, 0, 2887 AC_VERB_SET_AMP_GAIN_MUTE, 2888 AMP_OUT_MUTE); 2889 } 2890 } 2891 2892 /* mute all loopback inputs */ 2893 if (spec->mixer_nid) { 2894 int nums = snd_hda_get_conn_list(codec, spec->mixer_nid, NULL); 2895 for (i = 0; i < nums; i++) 2896 snd_hda_codec_write(codec, spec->mixer_nid, 0, 2897 AC_VERB_SET_AMP_GAIN_MUTE, 2898 AMP_IN_MUTE(i)); 2899 } 2900 } 2901 2902 /* convert from MIX nid to DAC */ 2903 static hda_nid_t alc_auto_mix_to_dac(struct hda_codec *codec, hda_nid_t nid) 2904 { 2905 hda_nid_t list[5]; 2906 int i, num; 2907 2908 if (get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_AUD_OUT) 2909 return nid; 2910 num = snd_hda_get_connections(codec, nid, list, ARRAY_SIZE(list)); 2911 for (i = 0; i < num; i++) { 2912 if (get_wcaps_type(get_wcaps(codec, list[i])) == AC_WID_AUD_OUT) 2913 return list[i]; 2914 } 2915 return 0; 2916 } 2917 2918 /* go down to the selector widget before the mixer */ 2919 static hda_nid_t alc_go_down_to_selector(struct hda_codec *codec, hda_nid_t pin) 2920 { 2921 hda_nid_t srcs[5]; 2922 int num = snd_hda_get_connections(codec, pin, srcs, 2923 ARRAY_SIZE(srcs)); 2924 if (num != 1 || 2925 get_wcaps_type(get_wcaps(codec, srcs[0])) != AC_WID_AUD_SEL) 2926 return pin; 2927 return srcs[0]; 2928 } 2929 2930 /* get MIX nid connected to the given pin targeted to DAC */ 2931 static hda_nid_t alc_auto_dac_to_mix(struct hda_codec *codec, hda_nid_t pin, 2932 hda_nid_t dac) 2933 { 2934 hda_nid_t mix[5]; 2935 int i, num; 2936 2937 pin = alc_go_down_to_selector(codec, pin); 2938 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix)); 2939 for (i = 0; i < num; i++) { 2940 if (alc_auto_mix_to_dac(codec, mix[i]) == dac) 2941 return mix[i]; 2942 } 2943 return 0; 2944 } 2945 2946 /* select the connection from pin to DAC if needed */ 2947 static int alc_auto_select_dac(struct hda_codec *codec, hda_nid_t pin, 2948 hda_nid_t dac) 2949 { 2950 hda_nid_t mix[5]; 2951 int i, num; 2952 2953 pin = alc_go_down_to_selector(codec, pin); 2954 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix)); 2955 if (num < 2) 2956 return 0; 2957 for (i = 0; i < num; i++) { 2958 if (alc_auto_mix_to_dac(codec, mix[i]) == dac) { 2959 snd_hda_codec_update_cache(codec, pin, 0, 2960 AC_VERB_SET_CONNECT_SEL, i); 2961 return 0; 2962 } 2963 } 2964 return 0; 2965 } 2966 2967 static bool alc_is_dac_already_used(struct hda_codec *codec, hda_nid_t nid) 2968 { 2969 struct alc_spec *spec = codec->spec; 2970 int i; 2971 if (found_in_nid_list(nid, spec->multiout.dac_nids, 2972 ARRAY_SIZE(spec->private_dac_nids)) || 2973 found_in_nid_list(nid, spec->multiout.hp_out_nid, 2974 ARRAY_SIZE(spec->multiout.hp_out_nid)) || 2975 found_in_nid_list(nid, spec->multiout.extra_out_nid, 2976 ARRAY_SIZE(spec->multiout.extra_out_nid))) 2977 return true; 2978 for (i = 0; i < spec->multi_ios; i++) { 2979 if (spec->multi_io[i].dac == nid) 2980 return true; 2981 } 2982 return false; 2983 } 2984 2985 /* look for an empty DAC slot */ 2986 static hda_nid_t alc_auto_look_for_dac(struct hda_codec *codec, hda_nid_t pin) 2987 { 2988 hda_nid_t srcs[5]; 2989 int i, num; 2990 2991 pin = alc_go_down_to_selector(codec, pin); 2992 num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs)); 2993 for (i = 0; i < num; i++) { 2994 hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]); 2995 if (!nid) 2996 continue; 2997 if (!alc_is_dac_already_used(codec, nid)) 2998 return nid; 2999 } 3000 return 0; 3001 } 3002 3003 /* check whether the DAC is reachable from the pin */ 3004 static bool alc_auto_is_dac_reachable(struct hda_codec *codec, 3005 hda_nid_t pin, hda_nid_t dac) 3006 { 3007 hda_nid_t srcs[5]; 3008 int i, num; 3009 3010 if (!pin || !dac) 3011 return false; 3012 pin = alc_go_down_to_selector(codec, pin); 3013 num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs)); 3014 for (i = 0; i < num; i++) { 3015 hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]); 3016 if (nid == dac) 3017 return true; 3018 } 3019 return false; 3020 } 3021 3022 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin) 3023 { 3024 struct alc_spec *spec = codec->spec; 3025 hda_nid_t sel = alc_go_down_to_selector(codec, pin); 3026 hda_nid_t nid, nid_found, srcs[5]; 3027 int i, num = snd_hda_get_connections(codec, sel, srcs, 3028 ARRAY_SIZE(srcs)); 3029 if (num == 1) 3030 return alc_auto_look_for_dac(codec, pin); 3031 nid_found = 0; 3032 for (i = 0; i < num; i++) { 3033 if (srcs[i] == spec->mixer_nid) 3034 continue; 3035 nid = alc_auto_mix_to_dac(codec, srcs[i]); 3036 if (nid && !alc_is_dac_already_used(codec, nid)) { 3037 if (nid_found) 3038 return 0; 3039 nid_found = nid; 3040 } 3041 } 3042 return nid_found; 3043 } 3044 3045 /* mark up volume and mute control NIDs: used during badness parsing and 3046 * at creating actual controls 3047 */ 3048 static inline unsigned int get_ctl_pos(unsigned int data) 3049 { 3050 hda_nid_t nid = get_amp_nid_(data); 3051 unsigned int dir; 3052 if (snd_BUG_ON(nid >= MAX_VOL_NIDS)) 3053 return 0; 3054 dir = get_amp_direction_(data); 3055 return (nid << 1) | dir; 3056 } 3057 3058 #define is_ctl_used(bits, data) \ 3059 test_bit(get_ctl_pos(data), bits) 3060 #define mark_ctl_usage(bits, data) \ 3061 set_bit(get_ctl_pos(data), bits) 3062 3063 static void clear_vol_marks(struct hda_codec *codec) 3064 { 3065 struct alc_spec *spec = codec->spec; 3066 memset(spec->vol_ctls, 0, sizeof(spec->vol_ctls)); 3067 memset(spec->sw_ctls, 0, sizeof(spec->sw_ctls)); 3068 } 3069 3070 /* badness definition */ 3071 enum { 3072 /* No primary DAC is found for the main output */ 3073 BAD_NO_PRIMARY_DAC = 0x10000, 3074 /* No DAC is found for the extra output */ 3075 BAD_NO_DAC = 0x4000, 3076 /* No possible multi-ios */ 3077 BAD_MULTI_IO = 0x103, 3078 /* No individual DAC for extra output */ 3079 BAD_NO_EXTRA_DAC = 0x102, 3080 /* No individual DAC for extra surrounds */ 3081 BAD_NO_EXTRA_SURR_DAC = 0x101, 3082 /* Primary DAC shared with main surrounds */ 3083 BAD_SHARED_SURROUND = 0x100, 3084 /* Primary DAC shared with main CLFE */ 3085 BAD_SHARED_CLFE = 0x10, 3086 /* Primary DAC shared with extra surrounds */ 3087 BAD_SHARED_EXTRA_SURROUND = 0x10, 3088 /* Volume widget is shared */ 3089 BAD_SHARED_VOL = 0x10, 3090 }; 3091 3092 static hda_nid_t alc_look_for_out_mute_nid(struct hda_codec *codec, 3093 hda_nid_t pin, hda_nid_t dac); 3094 static hda_nid_t alc_look_for_out_vol_nid(struct hda_codec *codec, 3095 hda_nid_t pin, hda_nid_t dac); 3096 3097 static int eval_shared_vol_badness(struct hda_codec *codec, hda_nid_t pin, 3098 hda_nid_t dac) 3099 { 3100 struct alc_spec *spec = codec->spec; 3101 hda_nid_t nid; 3102 unsigned int val; 3103 int badness = 0; 3104 3105 nid = alc_look_for_out_vol_nid(codec, pin, dac); 3106 if (nid) { 3107 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 3108 if (is_ctl_used(spec->vol_ctls, nid)) 3109 badness += BAD_SHARED_VOL; 3110 else 3111 mark_ctl_usage(spec->vol_ctls, val); 3112 } else 3113 badness += BAD_SHARED_VOL; 3114 nid = alc_look_for_out_mute_nid(codec, pin, dac); 3115 if (nid) { 3116 unsigned int wid_type = get_wcaps_type(get_wcaps(codec, nid)); 3117 if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT) 3118 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 3119 else 3120 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT); 3121 if (is_ctl_used(spec->sw_ctls, val)) 3122 badness += BAD_SHARED_VOL; 3123 else 3124 mark_ctl_usage(spec->sw_ctls, val); 3125 } else 3126 badness += BAD_SHARED_VOL; 3127 return badness; 3128 } 3129 3130 struct badness_table { 3131 int no_primary_dac; /* no primary DAC */ 3132 int no_dac; /* no secondary DACs */ 3133 int shared_primary; /* primary DAC is shared with main output */ 3134 int shared_surr; /* secondary DAC shared with main or primary */ 3135 int shared_clfe; /* third DAC shared with main or primary */ 3136 int shared_surr_main; /* secondary DAC sahred with main/DAC0 */ 3137 }; 3138 3139 static struct badness_table main_out_badness = { 3140 .no_primary_dac = BAD_NO_PRIMARY_DAC, 3141 .no_dac = BAD_NO_DAC, 3142 .shared_primary = BAD_NO_PRIMARY_DAC, 3143 .shared_surr = BAD_SHARED_SURROUND, 3144 .shared_clfe = BAD_SHARED_CLFE, 3145 .shared_surr_main = BAD_SHARED_SURROUND, 3146 }; 3147 3148 static struct badness_table extra_out_badness = { 3149 .no_primary_dac = BAD_NO_DAC, 3150 .no_dac = BAD_NO_DAC, 3151 .shared_primary = BAD_NO_EXTRA_DAC, 3152 .shared_surr = BAD_SHARED_EXTRA_SURROUND, 3153 .shared_clfe = BAD_SHARED_EXTRA_SURROUND, 3154 .shared_surr_main = BAD_NO_EXTRA_SURR_DAC, 3155 }; 3156 3157 /* try to assign DACs to pins and return the resultant badness */ 3158 static int alc_auto_fill_dacs(struct hda_codec *codec, int num_outs, 3159 const hda_nid_t *pins, hda_nid_t *dacs, 3160 const struct badness_table *bad) 3161 { 3162 struct alc_spec *spec = codec->spec; 3163 struct auto_pin_cfg *cfg = &spec->autocfg; 3164 int i, j; 3165 int badness = 0; 3166 hda_nid_t dac; 3167 3168 if (!num_outs) 3169 return 0; 3170 3171 for (i = 0; i < num_outs; i++) { 3172 hda_nid_t pin = pins[i]; 3173 if (!dacs[i]) 3174 dacs[i] = alc_auto_look_for_dac(codec, pin); 3175 if (!dacs[i] && !i) { 3176 for (j = 1; j < num_outs; j++) { 3177 if (alc_auto_is_dac_reachable(codec, pin, dacs[j])) { 3178 dacs[0] = dacs[j]; 3179 dacs[j] = 0; 3180 break; 3181 } 3182 } 3183 } 3184 dac = dacs[i]; 3185 if (!dac) { 3186 if (alc_auto_is_dac_reachable(codec, pin, dacs[0])) 3187 dac = dacs[0]; 3188 else if (cfg->line_outs > i && 3189 alc_auto_is_dac_reachable(codec, pin, 3190 spec->private_dac_nids[i])) 3191 dac = spec->private_dac_nids[i]; 3192 if (dac) { 3193 if (!i) 3194 badness += bad->shared_primary; 3195 else if (i == 1) 3196 badness += bad->shared_surr; 3197 else 3198 badness += bad->shared_clfe; 3199 } else if (alc_auto_is_dac_reachable(codec, pin, 3200 spec->private_dac_nids[0])) { 3201 dac = spec->private_dac_nids[0]; 3202 badness += bad->shared_surr_main; 3203 } else if (!i) 3204 badness += bad->no_primary_dac; 3205 else 3206 badness += bad->no_dac; 3207 } 3208 if (dac) 3209 badness += eval_shared_vol_badness(codec, pin, dac); 3210 } 3211 3212 return badness; 3213 } 3214 3215 static int alc_auto_fill_multi_ios(struct hda_codec *codec, 3216 hda_nid_t reference_pin, 3217 bool hardwired, int offset); 3218 3219 static bool alc_map_singles(struct hda_codec *codec, int outs, 3220 const hda_nid_t *pins, hda_nid_t *dacs) 3221 { 3222 int i; 3223 bool found = false; 3224 for (i = 0; i < outs; i++) { 3225 if (dacs[i]) 3226 continue; 3227 dacs[i] = get_dac_if_single(codec, pins[i]); 3228 if (dacs[i]) 3229 found = true; 3230 } 3231 return found; 3232 } 3233 3234 /* fill in the dac_nids table from the parsed pin configuration */ 3235 static int fill_and_eval_dacs(struct hda_codec *codec, 3236 bool fill_hardwired, 3237 bool fill_mio_first) 3238 { 3239 struct alc_spec *spec = codec->spec; 3240 struct auto_pin_cfg *cfg = &spec->autocfg; 3241 int i, err, badness; 3242 3243 /* set num_dacs once to full for alc_auto_look_for_dac() */ 3244 spec->multiout.num_dacs = cfg->line_outs; 3245 spec->multiout.dac_nids = spec->private_dac_nids; 3246 memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids)); 3247 memset(spec->multiout.hp_out_nid, 0, sizeof(spec->multiout.hp_out_nid)); 3248 memset(spec->multiout.extra_out_nid, 0, sizeof(spec->multiout.extra_out_nid)); 3249 spec->multi_ios = 0; 3250 clear_vol_marks(codec); 3251 badness = 0; 3252 3253 /* fill hard-wired DACs first */ 3254 if (fill_hardwired) { 3255 bool mapped; 3256 do { 3257 mapped = alc_map_singles(codec, cfg->line_outs, 3258 cfg->line_out_pins, 3259 spec->private_dac_nids); 3260 mapped |= alc_map_singles(codec, cfg->hp_outs, 3261 cfg->hp_pins, 3262 spec->multiout.hp_out_nid); 3263 mapped |= alc_map_singles(codec, cfg->speaker_outs, 3264 cfg->speaker_pins, 3265 spec->multiout.extra_out_nid); 3266 if (fill_mio_first && cfg->line_outs == 1 && 3267 cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) { 3268 err = alc_auto_fill_multi_ios(codec, cfg->line_out_pins[0], true, 0); 3269 if (!err) 3270 mapped = true; 3271 } 3272 } while (mapped); 3273 } 3274 3275 badness += alc_auto_fill_dacs(codec, cfg->line_outs, cfg->line_out_pins, 3276 spec->private_dac_nids, 3277 &main_out_badness); 3278 3279 /* re-count num_dacs and squash invalid entries */ 3280 spec->multiout.num_dacs = 0; 3281 for (i = 0; i < cfg->line_outs; i++) { 3282 if (spec->private_dac_nids[i]) 3283 spec->multiout.num_dacs++; 3284 else { 3285 memmove(spec->private_dac_nids + i, 3286 spec->private_dac_nids + i + 1, 3287 sizeof(hda_nid_t) * (cfg->line_outs - i - 1)); 3288 spec->private_dac_nids[cfg->line_outs - 1] = 0; 3289 } 3290 } 3291 3292 if (fill_mio_first && 3293 cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) { 3294 /* try to fill multi-io first */ 3295 err = alc_auto_fill_multi_ios(codec, cfg->line_out_pins[0], false, 0); 3296 if (err < 0) 3297 return err; 3298 /* we don't count badness at this stage yet */ 3299 } 3300 3301 if (cfg->line_out_type != AUTO_PIN_HP_OUT) { 3302 err = alc_auto_fill_dacs(codec, cfg->hp_outs, cfg->hp_pins, 3303 spec->multiout.hp_out_nid, 3304 &extra_out_badness); 3305 if (err < 0) 3306 return err; 3307 badness += err; 3308 } 3309 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) { 3310 err = alc_auto_fill_dacs(codec, cfg->speaker_outs, 3311 cfg->speaker_pins, 3312 spec->multiout.extra_out_nid, 3313 &extra_out_badness); 3314 if (err < 0) 3315 return err; 3316 badness += err; 3317 } 3318 if (cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) { 3319 err = alc_auto_fill_multi_ios(codec, cfg->line_out_pins[0], false, 0); 3320 if (err < 0) 3321 return err; 3322 badness += err; 3323 } 3324 if (cfg->hp_outs && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) { 3325 /* try multi-ios with HP + inputs */ 3326 int offset = 0; 3327 if (cfg->line_outs >= 3) 3328 offset = 1; 3329 err = alc_auto_fill_multi_ios(codec, cfg->hp_pins[0], false, 3330 offset); 3331 if (err < 0) 3332 return err; 3333 badness += err; 3334 } 3335 3336 if (spec->multi_ios == 2) { 3337 for (i = 0; i < 2; i++) 3338 spec->private_dac_nids[spec->multiout.num_dacs++] = 3339 spec->multi_io[i].dac; 3340 spec->ext_channel_count = 2; 3341 } else if (spec->multi_ios) { 3342 spec->multi_ios = 0; 3343 badness += BAD_MULTI_IO; 3344 } 3345 3346 return badness; 3347 } 3348 3349 #define DEBUG_BADNESS 3350 3351 #ifdef DEBUG_BADNESS 3352 #define debug_badness snd_printdd 3353 #else 3354 #define debug_badness(...) 3355 #endif 3356 3357 static void debug_show_configs(struct alc_spec *spec, struct auto_pin_cfg *cfg) 3358 { 3359 debug_badness("multi_outs = %x/%x/%x/%x : %x/%x/%x/%x\n", 3360 cfg->line_out_pins[0], cfg->line_out_pins[1], 3361 cfg->line_out_pins[2], cfg->line_out_pins[2], 3362 spec->multiout.dac_nids[0], 3363 spec->multiout.dac_nids[1], 3364 spec->multiout.dac_nids[2], 3365 spec->multiout.dac_nids[3]); 3366 if (spec->multi_ios > 0) 3367 debug_badness("multi_ios(%d) = %x/%x : %x/%x\n", 3368 spec->multi_ios, 3369 spec->multi_io[0].pin, spec->multi_io[1].pin, 3370 spec->multi_io[0].dac, spec->multi_io[1].dac); 3371 debug_badness("hp_outs = %x/%x/%x/%x : %x/%x/%x/%x\n", 3372 cfg->hp_pins[0], cfg->hp_pins[1], 3373 cfg->hp_pins[2], cfg->hp_pins[2], 3374 spec->multiout.hp_out_nid[0], 3375 spec->multiout.hp_out_nid[1], 3376 spec->multiout.hp_out_nid[2], 3377 spec->multiout.hp_out_nid[3]); 3378 debug_badness("spk_outs = %x/%x/%x/%x : %x/%x/%x/%x\n", 3379 cfg->speaker_pins[0], cfg->speaker_pins[1], 3380 cfg->speaker_pins[2], cfg->speaker_pins[3], 3381 spec->multiout.extra_out_nid[0], 3382 spec->multiout.extra_out_nid[1], 3383 spec->multiout.extra_out_nid[2], 3384 spec->multiout.extra_out_nid[3]); 3385 } 3386 3387 static int alc_auto_fill_dac_nids(struct hda_codec *codec) 3388 { 3389 struct alc_spec *spec = codec->spec; 3390 struct auto_pin_cfg *cfg = &spec->autocfg; 3391 struct auto_pin_cfg *best_cfg; 3392 int best_badness = INT_MAX; 3393 int badness; 3394 bool fill_hardwired = true, fill_mio_first = true; 3395 bool best_wired = true, best_mio = true; 3396 bool hp_spk_swapped = false; 3397 3398 best_cfg = kmalloc(sizeof(*best_cfg), GFP_KERNEL); 3399 if (!best_cfg) 3400 return -ENOMEM; 3401 *best_cfg = *cfg; 3402 3403 for (;;) { 3404 badness = fill_and_eval_dacs(codec, fill_hardwired, 3405 fill_mio_first); 3406 if (badness < 0) { 3407 kfree(best_cfg); 3408 return badness; 3409 } 3410 debug_badness("==> lo_type=%d, wired=%d, mio=%d, badness=0x%x\n", 3411 cfg->line_out_type, fill_hardwired, fill_mio_first, 3412 badness); 3413 debug_show_configs(spec, cfg); 3414 if (badness < best_badness) { 3415 best_badness = badness; 3416 *best_cfg = *cfg; 3417 best_wired = fill_hardwired; 3418 best_mio = fill_mio_first; 3419 } 3420 if (!badness) 3421 break; 3422 fill_mio_first = !fill_mio_first; 3423 if (!fill_mio_first) 3424 continue; 3425 fill_hardwired = !fill_hardwired; 3426 if (!fill_hardwired) 3427 continue; 3428 if (hp_spk_swapped) 3429 break; 3430 hp_spk_swapped = true; 3431 if (cfg->speaker_outs > 0 && 3432 cfg->line_out_type == AUTO_PIN_HP_OUT) { 3433 cfg->hp_outs = cfg->line_outs; 3434 memcpy(cfg->hp_pins, cfg->line_out_pins, 3435 sizeof(cfg->hp_pins)); 3436 cfg->line_outs = cfg->speaker_outs; 3437 memcpy(cfg->line_out_pins, cfg->speaker_pins, 3438 sizeof(cfg->speaker_pins)); 3439 cfg->speaker_outs = 0; 3440 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins)); 3441 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT; 3442 fill_hardwired = true; 3443 continue; 3444 } 3445 if (cfg->hp_outs > 0 && 3446 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) { 3447 cfg->speaker_outs = cfg->line_outs; 3448 memcpy(cfg->speaker_pins, cfg->line_out_pins, 3449 sizeof(cfg->speaker_pins)); 3450 cfg->line_outs = cfg->hp_outs; 3451 memcpy(cfg->line_out_pins, cfg->hp_pins, 3452 sizeof(cfg->hp_pins)); 3453 cfg->hp_outs = 0; 3454 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins)); 3455 cfg->line_out_type = AUTO_PIN_HP_OUT; 3456 fill_hardwired = true; 3457 continue; 3458 } 3459 break; 3460 } 3461 3462 if (badness) { 3463 *cfg = *best_cfg; 3464 fill_and_eval_dacs(codec, best_wired, best_mio); 3465 } 3466 debug_badness("==> Best config: lo_type=%d, wired=%d, mio=%d\n", 3467 cfg->line_out_type, best_wired, best_mio); 3468 debug_show_configs(spec, cfg); 3469 3470 if (cfg->line_out_pins[0]) 3471 spec->vmaster_nid = 3472 alc_look_for_out_vol_nid(codec, cfg->line_out_pins[0], 3473 spec->multiout.dac_nids[0]); 3474 3475 /* clear the bitmap flags for creating controls */ 3476 clear_vol_marks(codec); 3477 kfree(best_cfg); 3478 return 0; 3479 } 3480 3481 static int alc_auto_add_vol_ctl(struct hda_codec *codec, 3482 const char *pfx, int cidx, 3483 hda_nid_t nid, unsigned int chs) 3484 { 3485 struct alc_spec *spec = codec->spec; 3486 unsigned int val; 3487 if (!nid) 3488 return 0; 3489 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT); 3490 if (is_ctl_used(spec->vol_ctls, val) && chs != 2) /* exclude LFE */ 3491 return 0; 3492 mark_ctl_usage(spec->vol_ctls, val); 3493 return __add_pb_vol_ctrl(codec->spec, ALC_CTL_WIDGET_VOL, pfx, cidx, 3494 val); 3495 } 3496 3497 static int alc_auto_add_stereo_vol(struct hda_codec *codec, 3498 const char *pfx, int cidx, 3499 hda_nid_t nid) 3500 { 3501 int chs = 1; 3502 if (get_wcaps(codec, nid) & AC_WCAP_STEREO) 3503 chs = 3; 3504 return alc_auto_add_vol_ctl(codec, pfx, cidx, nid, chs); 3505 } 3506 3507 /* create a mute-switch for the given mixer widget; 3508 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute 3509 */ 3510 static int alc_auto_add_sw_ctl(struct hda_codec *codec, 3511 const char *pfx, int cidx, 3512 hda_nid_t nid, unsigned int chs) 3513 { 3514 struct alc_spec *spec = codec->spec; 3515 int wid_type; 3516 int type; 3517 unsigned long val; 3518 if (!nid) 3519 return 0; 3520 wid_type = get_wcaps_type(get_wcaps(codec, nid)); 3521 if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT) { 3522 type = ALC_CTL_WIDGET_MUTE; 3523 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT); 3524 } else if (snd_hda_get_conn_list(codec, nid, NULL) == 1) { 3525 type = ALC_CTL_WIDGET_MUTE; 3526 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT); 3527 } else { 3528 type = ALC_CTL_BIND_MUTE; 3529 val = HDA_COMPOSE_AMP_VAL(nid, chs, 2, HDA_INPUT); 3530 } 3531 if (is_ctl_used(spec->sw_ctls, val) && chs != 2) /* exclude LFE */ 3532 return 0; 3533 mark_ctl_usage(spec->sw_ctls, val); 3534 return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val); 3535 } 3536 3537 static int alc_auto_add_stereo_sw(struct hda_codec *codec, const char *pfx, 3538 int cidx, hda_nid_t nid) 3539 { 3540 int chs = 1; 3541 if (get_wcaps(codec, nid) & AC_WCAP_STEREO) 3542 chs = 3; 3543 return alc_auto_add_sw_ctl(codec, pfx, cidx, nid, chs); 3544 } 3545 3546 static hda_nid_t alc_look_for_out_mute_nid(struct hda_codec *codec, 3547 hda_nid_t pin, hda_nid_t dac) 3548 { 3549 hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac); 3550 if (nid_has_mute(codec, pin, HDA_OUTPUT)) 3551 return pin; 3552 else if (mix && nid_has_mute(codec, mix, HDA_INPUT)) 3553 return mix; 3554 else if (nid_has_mute(codec, dac, HDA_OUTPUT)) 3555 return dac; 3556 return 0; 3557 } 3558 3559 static hda_nid_t alc_look_for_out_vol_nid(struct hda_codec *codec, 3560 hda_nid_t pin, hda_nid_t dac) 3561 { 3562 hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac); 3563 if (nid_has_volume(codec, dac, HDA_OUTPUT)) 3564 return dac; 3565 else if (nid_has_volume(codec, mix, HDA_OUTPUT)) 3566 return mix; 3567 else if (nid_has_volume(codec, pin, HDA_OUTPUT)) 3568 return pin; 3569 return 0; 3570 } 3571 3572 /* add playback controls from the parsed DAC table */ 3573 static int alc_auto_create_multi_out_ctls(struct hda_codec *codec, 3574 const struct auto_pin_cfg *cfg) 3575 { 3576 struct alc_spec *spec = codec->spec; 3577 int i, err, noutputs; 3578 3579 noutputs = cfg->line_outs; 3580 if (spec->multi_ios > 0 && cfg->line_outs < 3) 3581 noutputs += spec->multi_ios; 3582 3583 for (i = 0; i < noutputs; i++) { 3584 const char *name; 3585 int index; 3586 hda_nid_t dac, pin; 3587 hda_nid_t sw, vol; 3588 3589 dac = spec->multiout.dac_nids[i]; 3590 if (!dac) 3591 continue; 3592 if (i >= cfg->line_outs) { 3593 pin = spec->multi_io[i - 1].pin; 3594 index = 0; 3595 name = channel_name[i]; 3596 } else { 3597 pin = cfg->line_out_pins[i]; 3598 name = alc_get_line_out_pfx(spec, i, true, &index); 3599 } 3600 3601 sw = alc_look_for_out_mute_nid(codec, pin, dac); 3602 vol = alc_look_for_out_vol_nid(codec, pin, dac); 3603 if (!name || !strcmp(name, "CLFE")) { 3604 /* Center/LFE */ 3605 err = alc_auto_add_vol_ctl(codec, "Center", 0, vol, 1); 3606 if (err < 0) 3607 return err; 3608 err = alc_auto_add_vol_ctl(codec, "LFE", 0, vol, 2); 3609 if (err < 0) 3610 return err; 3611 err = alc_auto_add_sw_ctl(codec, "Center", 0, sw, 1); 3612 if (err < 0) 3613 return err; 3614 err = alc_auto_add_sw_ctl(codec, "LFE", 0, sw, 2); 3615 if (err < 0) 3616 return err; 3617 } else { 3618 err = alc_auto_add_stereo_vol(codec, name, index, vol); 3619 if (err < 0) 3620 return err; 3621 err = alc_auto_add_stereo_sw(codec, name, index, sw); 3622 if (err < 0) 3623 return err; 3624 } 3625 } 3626 return 0; 3627 } 3628 3629 static int alc_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin, 3630 hda_nid_t dac, const char *pfx, 3631 int cidx) 3632 { 3633 struct alc_spec *spec = codec->spec; 3634 hda_nid_t sw, vol; 3635 int err; 3636 3637 if (!dac) { 3638 unsigned int val; 3639 /* the corresponding DAC is already occupied */ 3640 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP)) 3641 return 0; /* no way */ 3642 /* create a switch only */ 3643 val = HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT); 3644 if (is_ctl_used(spec->sw_ctls, val)) 3645 return 0; /* already created */ 3646 mark_ctl_usage(spec->sw_ctls, val); 3647 return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, cidx, val); 3648 } 3649 3650 sw = alc_look_for_out_mute_nid(codec, pin, dac); 3651 vol = alc_look_for_out_vol_nid(codec, pin, dac); 3652 err = alc_auto_add_stereo_vol(codec, pfx, cidx, vol); 3653 if (err < 0) 3654 return err; 3655 err = alc_auto_add_stereo_sw(codec, pfx, cidx, sw); 3656 if (err < 0) 3657 return err; 3658 return 0; 3659 } 3660 3661 static struct hda_bind_ctls *new_bind_ctl(struct hda_codec *codec, 3662 unsigned int nums, 3663 struct hda_ctl_ops *ops) 3664 { 3665 struct alc_spec *spec = codec->spec; 3666 struct hda_bind_ctls **ctlp, *ctl; 3667 snd_array_init(&spec->bind_ctls, sizeof(ctl), 8); 3668 ctlp = snd_array_new(&spec->bind_ctls); 3669 if (!ctlp) 3670 return NULL; 3671 ctl = kzalloc(sizeof(*ctl) + sizeof(long) * (nums + 1), GFP_KERNEL); 3672 *ctlp = ctl; 3673 if (ctl) 3674 ctl->ops = ops; 3675 return ctl; 3676 } 3677 3678 /* add playback controls for speaker and HP outputs */ 3679 static int alc_auto_create_extra_outs(struct hda_codec *codec, int num_pins, 3680 const hda_nid_t *pins, 3681 const hda_nid_t *dacs, 3682 const char *pfx) 3683 { 3684 struct alc_spec *spec = codec->spec; 3685 struct hda_bind_ctls *ctl; 3686 char name[32]; 3687 int i, n, err; 3688 3689 if (!num_pins || !pins[0]) 3690 return 0; 3691 3692 if (num_pins == 1) { 3693 hda_nid_t dac = *dacs; 3694 if (!dac) 3695 dac = spec->multiout.dac_nids[0]; 3696 return alc_auto_create_extra_out(codec, *pins, dac, pfx, 0); 3697 } 3698 3699 for (i = 0; i < num_pins; i++) { 3700 hda_nid_t dac; 3701 if (dacs[num_pins - 1]) 3702 dac = dacs[i]; /* with individual volumes */ 3703 else 3704 dac = 0; 3705 if (num_pins == 2 && i == 1 && !strcmp(pfx, "Speaker")) { 3706 err = alc_auto_create_extra_out(codec, pins[i], dac, 3707 "Bass Speaker", 0); 3708 } else if (num_pins >= 3) { 3709 snprintf(name, sizeof(name), "%s %s", 3710 pfx, channel_name[i]); 3711 err = alc_auto_create_extra_out(codec, pins[i], dac, 3712 name, 0); 3713 } else { 3714 err = alc_auto_create_extra_out(codec, pins[i], dac, 3715 pfx, i); 3716 } 3717 if (err < 0) 3718 return err; 3719 } 3720 if (dacs[num_pins - 1]) 3721 return 0; 3722 3723 /* Let's create a bind-controls for volumes */ 3724 ctl = new_bind_ctl(codec, num_pins, &snd_hda_bind_vol); 3725 if (!ctl) 3726 return -ENOMEM; 3727 n = 0; 3728 for (i = 0; i < num_pins; i++) { 3729 hda_nid_t vol; 3730 if (!pins[i] || !dacs[i]) 3731 continue; 3732 vol = alc_look_for_out_vol_nid(codec, pins[i], dacs[i]); 3733 if (vol) 3734 ctl->values[n++] = 3735 HDA_COMPOSE_AMP_VAL(vol, 3, 0, HDA_OUTPUT); 3736 } 3737 if (n) { 3738 snprintf(name, sizeof(name), "%s Playback Volume", pfx); 3739 err = add_control(spec, ALC_CTL_BIND_VOL, name, 0, (long)ctl); 3740 if (err < 0) 3741 return err; 3742 } 3743 return 0; 3744 } 3745 3746 static int alc_auto_create_hp_out(struct hda_codec *codec) 3747 { 3748 struct alc_spec *spec = codec->spec; 3749 return alc_auto_create_extra_outs(codec, spec->autocfg.hp_outs, 3750 spec->autocfg.hp_pins, 3751 spec->multiout.hp_out_nid, 3752 "Headphone"); 3753 } 3754 3755 static int alc_auto_create_speaker_out(struct hda_codec *codec) 3756 { 3757 struct alc_spec *spec = codec->spec; 3758 return alc_auto_create_extra_outs(codec, spec->autocfg.speaker_outs, 3759 spec->autocfg.speaker_pins, 3760 spec->multiout.extra_out_nid, 3761 "Speaker"); 3762 } 3763 3764 static void alc_auto_set_output_and_unmute(struct hda_codec *codec, 3765 hda_nid_t pin, int pin_type, 3766 hda_nid_t dac) 3767 { 3768 int i, num; 3769 hda_nid_t nid, mix = 0; 3770 hda_nid_t srcs[HDA_MAX_CONNECTIONS]; 3771 3772 alc_set_pin_output(codec, pin, pin_type); 3773 nid = alc_go_down_to_selector(codec, pin); 3774 num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs)); 3775 for (i = 0; i < num; i++) { 3776 if (alc_auto_mix_to_dac(codec, srcs[i]) != dac) 3777 continue; 3778 mix = srcs[i]; 3779 break; 3780 } 3781 if (!mix) 3782 return; 3783 3784 /* need the manual connection? */ 3785 if (num > 1) 3786 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i); 3787 /* unmute mixer widget inputs */ 3788 if (nid_has_mute(codec, mix, HDA_INPUT)) { 3789 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE, 3790 AMP_IN_UNMUTE(0)); 3791 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE, 3792 AMP_IN_UNMUTE(1)); 3793 } 3794 /* initialize volume */ 3795 nid = alc_look_for_out_vol_nid(codec, pin, dac); 3796 if (nid) 3797 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, 3798 AMP_OUT_ZERO); 3799 3800 /* unmute DAC if it's not assigned to a mixer */ 3801 nid = alc_look_for_out_mute_nid(codec, pin, dac); 3802 if (nid == mix && nid_has_mute(codec, dac, HDA_OUTPUT)) 3803 snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE, 3804 AMP_OUT_ZERO); 3805 } 3806 3807 static void alc_auto_init_multi_out(struct hda_codec *codec) 3808 { 3809 struct alc_spec *spec = codec->spec; 3810 int pin_type = get_pin_type(spec->autocfg.line_out_type); 3811 int i; 3812 3813 for (i = 0; i <= HDA_SIDE; i++) { 3814 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 3815 if (nid) 3816 alc_auto_set_output_and_unmute(codec, nid, pin_type, 3817 spec->multiout.dac_nids[i]); 3818 } 3819 } 3820 3821 static void alc_auto_init_extra_out(struct hda_codec *codec) 3822 { 3823 struct alc_spec *spec = codec->spec; 3824 int i; 3825 hda_nid_t pin, dac; 3826 3827 for (i = 0; i < spec->autocfg.hp_outs; i++) { 3828 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT) 3829 break; 3830 pin = spec->autocfg.hp_pins[i]; 3831 if (!pin) 3832 break; 3833 dac = spec->multiout.hp_out_nid[i]; 3834 if (!dac) { 3835 if (i > 0 && spec->multiout.hp_out_nid[0]) 3836 dac = spec->multiout.hp_out_nid[0]; 3837 else 3838 dac = spec->multiout.dac_nids[0]; 3839 } 3840 alc_auto_set_output_and_unmute(codec, pin, PIN_HP, dac); 3841 } 3842 for (i = 0; i < spec->autocfg.speaker_outs; i++) { 3843 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT) 3844 break; 3845 pin = spec->autocfg.speaker_pins[i]; 3846 if (!pin) 3847 break; 3848 dac = spec->multiout.extra_out_nid[i]; 3849 if (!dac) { 3850 if (i > 0 && spec->multiout.extra_out_nid[0]) 3851 dac = spec->multiout.extra_out_nid[0]; 3852 else 3853 dac = spec->multiout.dac_nids[0]; 3854 } 3855 alc_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac); 3856 } 3857 } 3858 3859 /* check whether the given pin can be a multi-io pin */ 3860 static bool can_be_multiio_pin(struct hda_codec *codec, 3861 unsigned int location, hda_nid_t nid) 3862 { 3863 unsigned int defcfg, caps; 3864 3865 defcfg = snd_hda_codec_get_pincfg(codec, nid); 3866 if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX) 3867 return false; 3868 if (location && get_defcfg_location(defcfg) != location) 3869 return false; 3870 caps = snd_hda_query_pin_caps(codec, nid); 3871 if (!(caps & AC_PINCAP_OUT)) 3872 return false; 3873 return true; 3874 } 3875 3876 /* 3877 * multi-io helper 3878 * 3879 * When hardwired is set, try to fill ony hardwired pins, and returns 3880 * zero if any pins are filled, non-zero if nothing found. 3881 * When hardwired is off, try to fill possible input pins, and returns 3882 * the badness value. 3883 */ 3884 static int alc_auto_fill_multi_ios(struct hda_codec *codec, 3885 hda_nid_t reference_pin, 3886 bool hardwired, int offset) 3887 { 3888 struct alc_spec *spec = codec->spec; 3889 struct auto_pin_cfg *cfg = &spec->autocfg; 3890 int type, i, j, dacs, num_pins, old_pins; 3891 unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin); 3892 unsigned int location = get_defcfg_location(defcfg); 3893 int badness = 0; 3894 3895 old_pins = spec->multi_ios; 3896 if (old_pins >= 2) 3897 goto end_fill; 3898 3899 num_pins = 0; 3900 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) { 3901 for (i = 0; i < cfg->num_inputs; i++) { 3902 if (cfg->inputs[i].type != type) 3903 continue; 3904 if (can_be_multiio_pin(codec, location, 3905 cfg->inputs[i].pin)) 3906 num_pins++; 3907 } 3908 } 3909 if (num_pins < 2) 3910 goto end_fill; 3911 3912 dacs = spec->multiout.num_dacs; 3913 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) { 3914 for (i = 0; i < cfg->num_inputs; i++) { 3915 hda_nid_t nid = cfg->inputs[i].pin; 3916 hda_nid_t dac = 0; 3917 3918 if (cfg->inputs[i].type != type) 3919 continue; 3920 if (!can_be_multiio_pin(codec, location, nid)) 3921 continue; 3922 for (j = 0; j < spec->multi_ios; j++) { 3923 if (nid == spec->multi_io[j].pin) 3924 break; 3925 } 3926 if (j < spec->multi_ios) 3927 continue; 3928 3929 if (offset && offset + spec->multi_ios < dacs) { 3930 dac = spec->private_dac_nids[offset + spec->multi_ios]; 3931 if (!alc_auto_is_dac_reachable(codec, nid, dac)) 3932 dac = 0; 3933 } 3934 if (hardwired) 3935 dac = get_dac_if_single(codec, nid); 3936 else if (!dac) 3937 dac = alc_auto_look_for_dac(codec, nid); 3938 if (!dac) { 3939 badness++; 3940 continue; 3941 } 3942 spec->multi_io[spec->multi_ios].pin = nid; 3943 spec->multi_io[spec->multi_ios].dac = dac; 3944 spec->multi_ios++; 3945 if (spec->multi_ios >= 2) 3946 break; 3947 } 3948 } 3949 end_fill: 3950 if (badness) 3951 badness = BAD_MULTI_IO; 3952 if (old_pins == spec->multi_ios) { 3953 if (hardwired) 3954 return 1; /* nothing found */ 3955 else 3956 return badness; /* no badness if nothing found */ 3957 } 3958 if (!hardwired && spec->multi_ios < 2) { 3959 spec->multi_ios = old_pins; 3960 return badness; 3961 } 3962 3963 return 0; 3964 } 3965 3966 static int alc_auto_ch_mode_info(struct snd_kcontrol *kcontrol, 3967 struct snd_ctl_elem_info *uinfo) 3968 { 3969 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3970 struct alc_spec *spec = codec->spec; 3971 3972 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 3973 uinfo->count = 1; 3974 uinfo->value.enumerated.items = spec->multi_ios + 1; 3975 if (uinfo->value.enumerated.item > spec->multi_ios) 3976 uinfo->value.enumerated.item = spec->multi_ios; 3977 sprintf(uinfo->value.enumerated.name, "%dch", 3978 (uinfo->value.enumerated.item + 1) * 2); 3979 return 0; 3980 } 3981 3982 static int alc_auto_ch_mode_get(struct snd_kcontrol *kcontrol, 3983 struct snd_ctl_elem_value *ucontrol) 3984 { 3985 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3986 struct alc_spec *spec = codec->spec; 3987 ucontrol->value.enumerated.item[0] = (spec->ext_channel_count - 1) / 2; 3988 return 0; 3989 } 3990 3991 static int alc_set_multi_io(struct hda_codec *codec, int idx, bool output) 3992 { 3993 struct alc_spec *spec = codec->spec; 3994 hda_nid_t nid = spec->multi_io[idx].pin; 3995 3996 if (!spec->multi_io[idx].ctl_in) 3997 spec->multi_io[idx].ctl_in = 3998 snd_hda_codec_read(codec, nid, 0, 3999 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 4000 if (output) { 4001 snd_hda_codec_update_cache(codec, nid, 0, 4002 AC_VERB_SET_PIN_WIDGET_CONTROL, 4003 PIN_OUT); 4004 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) 4005 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 4006 HDA_AMP_MUTE, 0); 4007 alc_auto_select_dac(codec, nid, spec->multi_io[idx].dac); 4008 } else { 4009 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) 4010 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 4011 HDA_AMP_MUTE, HDA_AMP_MUTE); 4012 snd_hda_codec_update_cache(codec, nid, 0, 4013 AC_VERB_SET_PIN_WIDGET_CONTROL, 4014 spec->multi_io[idx].ctl_in); 4015 } 4016 return 0; 4017 } 4018 4019 static int alc_auto_ch_mode_put(struct snd_kcontrol *kcontrol, 4020 struct snd_ctl_elem_value *ucontrol) 4021 { 4022 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 4023 struct alc_spec *spec = codec->spec; 4024 int i, ch; 4025 4026 ch = ucontrol->value.enumerated.item[0]; 4027 if (ch < 0 || ch > spec->multi_ios) 4028 return -EINVAL; 4029 if (ch == (spec->ext_channel_count - 1) / 2) 4030 return 0; 4031 spec->ext_channel_count = (ch + 1) * 2; 4032 for (i = 0; i < spec->multi_ios; i++) 4033 alc_set_multi_io(codec, i, i < ch); 4034 spec->multiout.max_channels = spec->ext_channel_count; 4035 if (spec->need_dac_fix && !spec->const_channel_count) 4036 spec->multiout.num_dacs = spec->multiout.max_channels / 2; 4037 return 1; 4038 } 4039 4040 static const struct snd_kcontrol_new alc_auto_channel_mode_enum = { 4041 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4042 .name = "Channel Mode", 4043 .info = alc_auto_ch_mode_info, 4044 .get = alc_auto_ch_mode_get, 4045 .put = alc_auto_ch_mode_put, 4046 }; 4047 4048 static int alc_auto_add_multi_channel_mode(struct hda_codec *codec) 4049 { 4050 struct alc_spec *spec = codec->spec; 4051 4052 if (spec->multi_ios > 0) { 4053 struct snd_kcontrol_new *knew; 4054 4055 knew = alc_kcontrol_new(spec); 4056 if (!knew) 4057 return -ENOMEM; 4058 *knew = alc_auto_channel_mode_enum; 4059 knew->name = kstrdup("Channel Mode", GFP_KERNEL); 4060 if (!knew->name) 4061 return -ENOMEM; 4062 } 4063 return 0; 4064 } 4065 4066 /* filter out invalid adc_nids (and capsrc_nids) that don't give all 4067 * active input pins 4068 */ 4069 static void alc_remove_invalid_adc_nids(struct hda_codec *codec) 4070 { 4071 struct alc_spec *spec = codec->spec; 4072 const struct hda_input_mux *imux; 4073 hda_nid_t adc_nids[ARRAY_SIZE(spec->private_adc_nids)]; 4074 hda_nid_t capsrc_nids[ARRAY_SIZE(spec->private_adc_nids)]; 4075 int i, n, nums; 4076 4077 imux = spec->input_mux; 4078 if (!imux) 4079 return; 4080 if (spec->dyn_adc_switch) 4081 return; 4082 4083 again: 4084 nums = 0; 4085 for (n = 0; n < spec->num_adc_nids; n++) { 4086 hda_nid_t cap = spec->private_capsrc_nids[n]; 4087 int num_conns = snd_hda_get_conn_list(codec, cap, NULL); 4088 for (i = 0; i < imux->num_items; i++) { 4089 hda_nid_t pin = spec->imux_pins[i]; 4090 if (pin) { 4091 if (get_connection_index(codec, cap, pin) < 0) 4092 break; 4093 } else if (num_conns <= imux->items[i].index) 4094 break; 4095 } 4096 if (i >= imux->num_items) { 4097 adc_nids[nums] = spec->private_adc_nids[n]; 4098 capsrc_nids[nums++] = cap; 4099 } 4100 } 4101 if (!nums) { 4102 /* check whether ADC-switch is possible */ 4103 if (!alc_check_dyn_adc_switch(codec)) { 4104 if (spec->shared_mic_hp) { 4105 spec->shared_mic_hp = 0; 4106 spec->private_imux[0].num_items = 1; 4107 goto again; 4108 } 4109 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;" 4110 " using fallback 0x%x\n", 4111 codec->chip_name, spec->private_adc_nids[0]); 4112 spec->num_adc_nids = 1; 4113 spec->auto_mic = 0; 4114 return; 4115 } 4116 } else if (nums != spec->num_adc_nids) { 4117 memcpy(spec->private_adc_nids, adc_nids, 4118 nums * sizeof(hda_nid_t)); 4119 memcpy(spec->private_capsrc_nids, capsrc_nids, 4120 nums * sizeof(hda_nid_t)); 4121 spec->num_adc_nids = nums; 4122 } 4123 4124 if (spec->auto_mic) 4125 alc_auto_mic_check_imux(codec); /* check auto-mic setups */ 4126 else if (spec->input_mux->num_items == 1 || spec->shared_mic_hp) 4127 spec->num_adc_nids = 1; /* reduce to a single ADC */ 4128 } 4129 4130 /* 4131 * initialize ADC paths 4132 */ 4133 static void alc_auto_init_adc(struct hda_codec *codec, int adc_idx) 4134 { 4135 struct alc_spec *spec = codec->spec; 4136 hda_nid_t nid; 4137 4138 nid = spec->adc_nids[adc_idx]; 4139 /* mute ADC */ 4140 if (nid_has_mute(codec, nid, HDA_INPUT)) { 4141 snd_hda_codec_write(codec, nid, 0, 4142 AC_VERB_SET_AMP_GAIN_MUTE, 4143 AMP_IN_MUTE(0)); 4144 return; 4145 } 4146 if (!spec->capsrc_nids) 4147 return; 4148 nid = spec->capsrc_nids[adc_idx]; 4149 if (nid_has_mute(codec, nid, HDA_OUTPUT)) 4150 snd_hda_codec_write(codec, nid, 0, 4151 AC_VERB_SET_AMP_GAIN_MUTE, 4152 AMP_OUT_MUTE); 4153 } 4154 4155 static void alc_auto_init_input_src(struct hda_codec *codec) 4156 { 4157 struct alc_spec *spec = codec->spec; 4158 int c, nums; 4159 4160 for (c = 0; c < spec->num_adc_nids; c++) 4161 alc_auto_init_adc(codec, c); 4162 if (spec->dyn_adc_switch) 4163 nums = 1; 4164 else 4165 nums = spec->num_adc_nids; 4166 for (c = 0; c < nums; c++) 4167 alc_mux_select(codec, c, spec->cur_mux[c], true); 4168 } 4169 4170 /* add mic boosts if needed */ 4171 static int alc_auto_add_mic_boost(struct hda_codec *codec) 4172 { 4173 struct alc_spec *spec = codec->spec; 4174 struct auto_pin_cfg *cfg = &spec->autocfg; 4175 int i, err; 4176 int type_idx = 0; 4177 hda_nid_t nid; 4178 const char *prev_label = NULL; 4179 4180 for (i = 0; i < cfg->num_inputs; i++) { 4181 if (cfg->inputs[i].type > AUTO_PIN_MIC) 4182 break; 4183 nid = cfg->inputs[i].pin; 4184 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) { 4185 const char *label; 4186 char boost_label[32]; 4187 4188 label = hda_get_autocfg_input_label(codec, cfg, i); 4189 if (spec->shared_mic_hp && !strcmp(label, "Misc")) 4190 label = "Headphone Mic"; 4191 if (prev_label && !strcmp(label, prev_label)) 4192 type_idx++; 4193 else 4194 type_idx = 0; 4195 prev_label = label; 4196 4197 snprintf(boost_label, sizeof(boost_label), 4198 "%s Boost Volume", label); 4199 err = add_control(spec, ALC_CTL_WIDGET_VOL, 4200 boost_label, type_idx, 4201 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT)); 4202 if (err < 0) 4203 return err; 4204 } 4205 } 4206 return 0; 4207 } 4208 4209 /* select or unmute the given capsrc route */ 4210 static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap, 4211 int idx) 4212 { 4213 if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) { 4214 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx, 4215 HDA_AMP_MUTE, 0); 4216 } else if (snd_hda_get_conn_list(codec, cap, NULL) > 1) { 4217 snd_hda_codec_write_cache(codec, cap, 0, 4218 AC_VERB_SET_CONNECT_SEL, idx); 4219 } 4220 } 4221 4222 /* set the default connection to that pin */ 4223 static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin) 4224 { 4225 struct alc_spec *spec = codec->spec; 4226 int i; 4227 4228 if (!pin) 4229 return 0; 4230 for (i = 0; i < spec->num_adc_nids; i++) { 4231 hda_nid_t cap = get_capsrc(spec, i); 4232 int idx; 4233 4234 idx = get_connection_index(codec, cap, pin); 4235 if (idx < 0) 4236 continue; 4237 select_or_unmute_capsrc(codec, cap, idx); 4238 return i; /* return the found index */ 4239 } 4240 return -1; /* not found */ 4241 } 4242 4243 /* initialize some special cases for input sources */ 4244 static void alc_init_special_input_src(struct hda_codec *codec) 4245 { 4246 struct alc_spec *spec = codec->spec; 4247 int i; 4248 4249 for (i = 0; i < spec->autocfg.num_inputs; i++) 4250 init_capsrc_for_pin(codec, spec->autocfg.inputs[i].pin); 4251 } 4252 4253 /* assign appropriate capture mixers */ 4254 static void set_capture_mixer(struct hda_codec *codec) 4255 { 4256 struct alc_spec *spec = codec->spec; 4257 static const struct snd_kcontrol_new *caps[2][3] = { 4258 { alc_capture_mixer_nosrc1, 4259 alc_capture_mixer_nosrc2, 4260 alc_capture_mixer_nosrc3 }, 4261 { alc_capture_mixer1, 4262 alc_capture_mixer2, 4263 alc_capture_mixer3 }, 4264 }; 4265 4266 /* check whether either of ADC or MUX has a volume control */ 4267 if (!nid_has_volume(codec, spec->adc_nids[0], HDA_INPUT)) { 4268 if (!spec->capsrc_nids) 4269 return; /* no volume */ 4270 if (!nid_has_volume(codec, spec->capsrc_nids[0], HDA_OUTPUT)) 4271 return; /* no volume in capsrc, too */ 4272 spec->vol_in_capsrc = 1; 4273 } 4274 4275 if (spec->num_adc_nids > 0) { 4276 int mux = 0; 4277 int num_adcs = 0; 4278 4279 if (spec->input_mux && spec->input_mux->num_items > 1) 4280 mux = 1; 4281 if (spec->auto_mic) { 4282 num_adcs = 1; 4283 mux = 0; 4284 } else if (spec->dyn_adc_switch) 4285 num_adcs = 1; 4286 if (!num_adcs) { 4287 if (spec->num_adc_nids > 3) 4288 spec->num_adc_nids = 3; 4289 else if (!spec->num_adc_nids) 4290 return; 4291 num_adcs = spec->num_adc_nids; 4292 } 4293 spec->cap_mixer = caps[mux][num_adcs - 1]; 4294 } 4295 } 4296 4297 /* 4298 * standard auto-parser initializations 4299 */ 4300 static void alc_auto_init_std(struct hda_codec *codec) 4301 { 4302 struct alc_spec *spec = codec->spec; 4303 alc_auto_init_multi_out(codec); 4304 alc_auto_init_extra_out(codec); 4305 alc_auto_init_analog_input(codec); 4306 alc_auto_init_input_src(codec); 4307 alc_auto_init_digital(codec); 4308 if (spec->unsol_event) 4309 alc_inithook(codec); 4310 } 4311 4312 /* 4313 * Digital-beep handlers 4314 */ 4315 #ifdef CONFIG_SND_HDA_INPUT_BEEP 4316 #define set_beep_amp(spec, nid, idx, dir) \ 4317 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir)) 4318 4319 static const struct snd_pci_quirk beep_white_list[] = { 4320 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1), 4321 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1), 4322 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1), 4323 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1), 4324 SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1), 4325 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1), 4326 {} 4327 }; 4328 4329 static inline int has_cdefine_beep(struct hda_codec *codec) 4330 { 4331 struct alc_spec *spec = codec->spec; 4332 const struct snd_pci_quirk *q; 4333 q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list); 4334 if (q) 4335 return q->value; 4336 return spec->cdefine.enable_pcbeep; 4337 } 4338 #else 4339 #define set_beep_amp(spec, nid, idx, dir) /* NOP */ 4340 #define has_cdefine_beep(codec) 0 4341 #endif 4342 4343 /* parse the BIOS configuration and set up the alc_spec */ 4344 /* return 1 if successful, 0 if the proper config is not found, 4345 * or a negative error code 4346 */ 4347 static int alc_parse_auto_config(struct hda_codec *codec, 4348 const hda_nid_t *ignore_nids, 4349 const hda_nid_t *ssid_nids) 4350 { 4351 struct alc_spec *spec = codec->spec; 4352 struct auto_pin_cfg *cfg = &spec->autocfg; 4353 int err; 4354 4355 err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids, 4356 spec->parse_flags); 4357 if (err < 0) 4358 return err; 4359 if (!cfg->line_outs) { 4360 if (cfg->dig_outs || cfg->dig_in_pin) { 4361 spec->multiout.max_channels = 2; 4362 spec->no_analog = 1; 4363 goto dig_only; 4364 } 4365 return 0; /* can't find valid BIOS pin config */ 4366 } 4367 4368 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT && 4369 cfg->line_outs <= cfg->hp_outs) { 4370 /* use HP as primary out */ 4371 cfg->speaker_outs = cfg->line_outs; 4372 memcpy(cfg->speaker_pins, cfg->line_out_pins, 4373 sizeof(cfg->speaker_pins)); 4374 cfg->line_outs = cfg->hp_outs; 4375 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins)); 4376 cfg->hp_outs = 0; 4377 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins)); 4378 cfg->line_out_type = AUTO_PIN_HP_OUT; 4379 } 4380 4381 err = alc_auto_fill_dac_nids(codec); 4382 if (err < 0) 4383 return err; 4384 err = alc_auto_add_multi_channel_mode(codec); 4385 if (err < 0) 4386 return err; 4387 err = alc_auto_create_multi_out_ctls(codec, cfg); 4388 if (err < 0) 4389 return err; 4390 err = alc_auto_create_hp_out(codec); 4391 if (err < 0) 4392 return err; 4393 err = alc_auto_create_speaker_out(codec); 4394 if (err < 0) 4395 return err; 4396 err = alc_auto_create_shared_input(codec); 4397 if (err < 0) 4398 return err; 4399 err = alc_auto_create_input_ctls(codec); 4400 if (err < 0) 4401 return err; 4402 4403 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 4404 4405 dig_only: 4406 alc_auto_parse_digital(codec); 4407 4408 if (!spec->no_analog) 4409 alc_remove_invalid_adc_nids(codec); 4410 4411 if (ssid_nids) 4412 alc_ssid_check(codec, ssid_nids); 4413 4414 if (!spec->no_analog) { 4415 alc_auto_check_switches(codec); 4416 err = alc_auto_add_mic_boost(codec); 4417 if (err < 0) 4418 return err; 4419 } 4420 4421 if (spec->kctls.list) 4422 add_mixer(spec, spec->kctls.list); 4423 4424 if (!spec->no_analog && !spec->cap_mixer) 4425 set_capture_mixer(codec); 4426 4427 return 1; 4428 } 4429 4430 static int alc880_parse_auto_config(struct hda_codec *codec) 4431 { 4432 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 }; 4433 static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 4434 return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids); 4435 } 4436 4437 /* 4438 * ALC880 fix-ups 4439 */ 4440 enum { 4441 ALC880_FIXUP_GPIO1, 4442 ALC880_FIXUP_GPIO2, 4443 ALC880_FIXUP_MEDION_RIM, 4444 ALC880_FIXUP_LG, 4445 ALC880_FIXUP_W810, 4446 ALC880_FIXUP_EAPD_COEF, 4447 ALC880_FIXUP_TCL_S700, 4448 ALC880_FIXUP_VOL_KNOB, 4449 ALC880_FIXUP_FUJITSU, 4450 ALC880_FIXUP_F1734, 4451 ALC880_FIXUP_UNIWILL, 4452 ALC880_FIXUP_UNIWILL_DIG, 4453 ALC880_FIXUP_Z71V, 4454 ALC880_FIXUP_3ST_BASE, 4455 ALC880_FIXUP_3ST, 4456 ALC880_FIXUP_3ST_DIG, 4457 ALC880_FIXUP_5ST_BASE, 4458 ALC880_FIXUP_5ST, 4459 ALC880_FIXUP_5ST_DIG, 4460 ALC880_FIXUP_6ST_BASE, 4461 ALC880_FIXUP_6ST, 4462 ALC880_FIXUP_6ST_DIG, 4463 }; 4464 4465 /* enable the volume-knob widget support on NID 0x21 */ 4466 static void alc880_fixup_vol_knob(struct hda_codec *codec, 4467 const struct alc_fixup *fix, int action) 4468 { 4469 if (action == ALC_FIXUP_ACT_PROBE) 4470 snd_hda_jack_detect_enable(codec, 0x21, ALC_DCVOL_EVENT); 4471 } 4472 4473 static const struct alc_fixup alc880_fixups[] = { 4474 [ALC880_FIXUP_GPIO1] = { 4475 .type = ALC_FIXUP_VERBS, 4476 .v.verbs = alc_gpio1_init_verbs, 4477 }, 4478 [ALC880_FIXUP_GPIO2] = { 4479 .type = ALC_FIXUP_VERBS, 4480 .v.verbs = alc_gpio2_init_verbs, 4481 }, 4482 [ALC880_FIXUP_MEDION_RIM] = { 4483 .type = ALC_FIXUP_VERBS, 4484 .v.verbs = (const struct hda_verb[]) { 4485 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 4486 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 }, 4487 { } 4488 }, 4489 .chained = true, 4490 .chain_id = ALC880_FIXUP_GPIO2, 4491 }, 4492 [ALC880_FIXUP_LG] = { 4493 .type = ALC_FIXUP_PINS, 4494 .v.pins = (const struct alc_pincfg[]) { 4495 /* disable bogus unused pins */ 4496 { 0x16, 0x411111f0 }, 4497 { 0x18, 0x411111f0 }, 4498 { 0x1a, 0x411111f0 }, 4499 { } 4500 } 4501 }, 4502 [ALC880_FIXUP_W810] = { 4503 .type = ALC_FIXUP_PINS, 4504 .v.pins = (const struct alc_pincfg[]) { 4505 /* disable bogus unused pins */ 4506 { 0x17, 0x411111f0 }, 4507 { } 4508 }, 4509 .chained = true, 4510 .chain_id = ALC880_FIXUP_GPIO2, 4511 }, 4512 [ALC880_FIXUP_EAPD_COEF] = { 4513 .type = ALC_FIXUP_VERBS, 4514 .v.verbs = (const struct hda_verb[]) { 4515 /* change to EAPD mode */ 4516 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 4517 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 }, 4518 {} 4519 }, 4520 }, 4521 [ALC880_FIXUP_TCL_S700] = { 4522 .type = ALC_FIXUP_VERBS, 4523 .v.verbs = (const struct hda_verb[]) { 4524 /* change to EAPD mode */ 4525 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 4526 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 }, 4527 {} 4528 }, 4529 .chained = true, 4530 .chain_id = ALC880_FIXUP_GPIO2, 4531 }, 4532 [ALC880_FIXUP_VOL_KNOB] = { 4533 .type = ALC_FIXUP_FUNC, 4534 .v.func = alc880_fixup_vol_knob, 4535 }, 4536 [ALC880_FIXUP_FUJITSU] = { 4537 /* override all pins as BIOS on old Amilo is broken */ 4538 .type = ALC_FIXUP_PINS, 4539 .v.pins = (const struct alc_pincfg[]) { 4540 { 0x14, 0x0121411f }, /* HP */ 4541 { 0x15, 0x99030120 }, /* speaker */ 4542 { 0x16, 0x99030130 }, /* bass speaker */ 4543 { 0x17, 0x411111f0 }, /* N/A */ 4544 { 0x18, 0x411111f0 }, /* N/A */ 4545 { 0x19, 0x01a19950 }, /* mic-in */ 4546 { 0x1a, 0x411111f0 }, /* N/A */ 4547 { 0x1b, 0x411111f0 }, /* N/A */ 4548 { 0x1c, 0x411111f0 }, /* N/A */ 4549 { 0x1d, 0x411111f0 }, /* N/A */ 4550 { 0x1e, 0x01454140 }, /* SPDIF out */ 4551 { } 4552 }, 4553 .chained = true, 4554 .chain_id = ALC880_FIXUP_VOL_KNOB, 4555 }, 4556 [ALC880_FIXUP_F1734] = { 4557 /* almost compatible with FUJITSU, but no bass and SPDIF */ 4558 .type = ALC_FIXUP_PINS, 4559 .v.pins = (const struct alc_pincfg[]) { 4560 { 0x14, 0x0121411f }, /* HP */ 4561 { 0x15, 0x99030120 }, /* speaker */ 4562 { 0x16, 0x411111f0 }, /* N/A */ 4563 { 0x17, 0x411111f0 }, /* N/A */ 4564 { 0x18, 0x411111f0 }, /* N/A */ 4565 { 0x19, 0x01a19950 }, /* mic-in */ 4566 { 0x1a, 0x411111f0 }, /* N/A */ 4567 { 0x1b, 0x411111f0 }, /* N/A */ 4568 { 0x1c, 0x411111f0 }, /* N/A */ 4569 { 0x1d, 0x411111f0 }, /* N/A */ 4570 { 0x1e, 0x411111f0 }, /* N/A */ 4571 { } 4572 }, 4573 .chained = true, 4574 .chain_id = ALC880_FIXUP_VOL_KNOB, 4575 }, 4576 [ALC880_FIXUP_UNIWILL] = { 4577 /* need to fix HP and speaker pins to be parsed correctly */ 4578 .type = ALC_FIXUP_PINS, 4579 .v.pins = (const struct alc_pincfg[]) { 4580 { 0x14, 0x0121411f }, /* HP */ 4581 { 0x15, 0x99030120 }, /* speaker */ 4582 { 0x16, 0x99030130 }, /* bass speaker */ 4583 { } 4584 }, 4585 }, 4586 [ALC880_FIXUP_UNIWILL_DIG] = { 4587 .type = ALC_FIXUP_PINS, 4588 .v.pins = (const struct alc_pincfg[]) { 4589 /* disable bogus unused pins */ 4590 { 0x17, 0x411111f0 }, 4591 { 0x19, 0x411111f0 }, 4592 { 0x1b, 0x411111f0 }, 4593 { 0x1f, 0x411111f0 }, 4594 { } 4595 } 4596 }, 4597 [ALC880_FIXUP_Z71V] = { 4598 .type = ALC_FIXUP_PINS, 4599 .v.pins = (const struct alc_pincfg[]) { 4600 /* set up the whole pins as BIOS is utterly broken */ 4601 { 0x14, 0x99030120 }, /* speaker */ 4602 { 0x15, 0x0121411f }, /* HP */ 4603 { 0x16, 0x411111f0 }, /* N/A */ 4604 { 0x17, 0x411111f0 }, /* N/A */ 4605 { 0x18, 0x01a19950 }, /* mic-in */ 4606 { 0x19, 0x411111f0 }, /* N/A */ 4607 { 0x1a, 0x01813031 }, /* line-in */ 4608 { 0x1b, 0x411111f0 }, /* N/A */ 4609 { 0x1c, 0x411111f0 }, /* N/A */ 4610 { 0x1d, 0x411111f0 }, /* N/A */ 4611 { 0x1e, 0x0144111e }, /* SPDIF */ 4612 { } 4613 } 4614 }, 4615 [ALC880_FIXUP_3ST_BASE] = { 4616 .type = ALC_FIXUP_PINS, 4617 .v.pins = (const struct alc_pincfg[]) { 4618 { 0x14, 0x01014010 }, /* line-out */ 4619 { 0x15, 0x411111f0 }, /* N/A */ 4620 { 0x16, 0x411111f0 }, /* N/A */ 4621 { 0x17, 0x411111f0 }, /* N/A */ 4622 { 0x18, 0x01a19c30 }, /* mic-in */ 4623 { 0x19, 0x0121411f }, /* HP */ 4624 { 0x1a, 0x01813031 }, /* line-in */ 4625 { 0x1b, 0x02a19c40 }, /* front-mic */ 4626 { 0x1c, 0x411111f0 }, /* N/A */ 4627 { 0x1d, 0x411111f0 }, /* N/A */ 4628 /* 0x1e is filled in below */ 4629 { 0x1f, 0x411111f0 }, /* N/A */ 4630 { } 4631 } 4632 }, 4633 [ALC880_FIXUP_3ST] = { 4634 .type = ALC_FIXUP_PINS, 4635 .v.pins = (const struct alc_pincfg[]) { 4636 { 0x1e, 0x411111f0 }, /* N/A */ 4637 { } 4638 }, 4639 .chained = true, 4640 .chain_id = ALC880_FIXUP_3ST_BASE, 4641 }, 4642 [ALC880_FIXUP_3ST_DIG] = { 4643 .type = ALC_FIXUP_PINS, 4644 .v.pins = (const struct alc_pincfg[]) { 4645 { 0x1e, 0x0144111e }, /* SPDIF */ 4646 { } 4647 }, 4648 .chained = true, 4649 .chain_id = ALC880_FIXUP_3ST_BASE, 4650 }, 4651 [ALC880_FIXUP_5ST_BASE] = { 4652 .type = ALC_FIXUP_PINS, 4653 .v.pins = (const struct alc_pincfg[]) { 4654 { 0x14, 0x01014010 }, /* front */ 4655 { 0x15, 0x411111f0 }, /* N/A */ 4656 { 0x16, 0x01011411 }, /* CLFE */ 4657 { 0x17, 0x01016412 }, /* surr */ 4658 { 0x18, 0x01a19c30 }, /* mic-in */ 4659 { 0x19, 0x0121411f }, /* HP */ 4660 { 0x1a, 0x01813031 }, /* line-in */ 4661 { 0x1b, 0x02a19c40 }, /* front-mic */ 4662 { 0x1c, 0x411111f0 }, /* N/A */ 4663 { 0x1d, 0x411111f0 }, /* N/A */ 4664 /* 0x1e is filled in below */ 4665 { 0x1f, 0x411111f0 }, /* N/A */ 4666 { } 4667 } 4668 }, 4669 [ALC880_FIXUP_5ST] = { 4670 .type = ALC_FIXUP_PINS, 4671 .v.pins = (const struct alc_pincfg[]) { 4672 { 0x1e, 0x411111f0 }, /* N/A */ 4673 { } 4674 }, 4675 .chained = true, 4676 .chain_id = ALC880_FIXUP_5ST_BASE, 4677 }, 4678 [ALC880_FIXUP_5ST_DIG] = { 4679 .type = ALC_FIXUP_PINS, 4680 .v.pins = (const struct alc_pincfg[]) { 4681 { 0x1e, 0x0144111e }, /* SPDIF */ 4682 { } 4683 }, 4684 .chained = true, 4685 .chain_id = ALC880_FIXUP_5ST_BASE, 4686 }, 4687 [ALC880_FIXUP_6ST_BASE] = { 4688 .type = ALC_FIXUP_PINS, 4689 .v.pins = (const struct alc_pincfg[]) { 4690 { 0x14, 0x01014010 }, /* front */ 4691 { 0x15, 0x01016412 }, /* surr */ 4692 { 0x16, 0x01011411 }, /* CLFE */ 4693 { 0x17, 0x01012414 }, /* side */ 4694 { 0x18, 0x01a19c30 }, /* mic-in */ 4695 { 0x19, 0x02a19c40 }, /* front-mic */ 4696 { 0x1a, 0x01813031 }, /* line-in */ 4697 { 0x1b, 0x0121411f }, /* HP */ 4698 { 0x1c, 0x411111f0 }, /* N/A */ 4699 { 0x1d, 0x411111f0 }, /* N/A */ 4700 /* 0x1e is filled in below */ 4701 { 0x1f, 0x411111f0 }, /* N/A */ 4702 { } 4703 } 4704 }, 4705 [ALC880_FIXUP_6ST] = { 4706 .type = ALC_FIXUP_PINS, 4707 .v.pins = (const struct alc_pincfg[]) { 4708 { 0x1e, 0x411111f0 }, /* N/A */ 4709 { } 4710 }, 4711 .chained = true, 4712 .chain_id = ALC880_FIXUP_6ST_BASE, 4713 }, 4714 [ALC880_FIXUP_6ST_DIG] = { 4715 .type = ALC_FIXUP_PINS, 4716 .v.pins = (const struct alc_pincfg[]) { 4717 { 0x1e, 0x0144111e }, /* SPDIF */ 4718 { } 4719 }, 4720 .chained = true, 4721 .chain_id = ALC880_FIXUP_6ST_BASE, 4722 }, 4723 }; 4724 4725 static const struct snd_pci_quirk alc880_fixup_tbl[] = { 4726 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810), 4727 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V), 4728 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1), 4729 SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2), 4730 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF), 4731 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG), 4732 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734), 4733 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL), 4734 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB), 4735 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810), 4736 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM), 4737 SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_FIXUP_F1734), 4738 SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU), 4739 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734), 4740 SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU), 4741 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG), 4742 SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG), 4743 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG), 4744 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700), 4745 4746 /* Below is the copied entries from alc880_quirks.c. 4747 * It's not quite sure whether BIOS sets the correct pin-config table 4748 * on these machines, thus they are kept to be compatible with 4749 * the old static quirks. Once when it's confirmed to work without 4750 * these overrides, it'd be better to remove. 4751 */ 4752 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG), 4753 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST), 4754 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG), 4755 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG), 4756 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG), 4757 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG), 4758 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG), 4759 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST), 4760 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG), 4761 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST), 4762 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST), 4763 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST), 4764 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST), 4765 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST), 4766 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG), 4767 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG), 4768 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG), 4769 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG), 4770 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG), 4771 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG), 4772 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG), 4773 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */ 4774 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG), 4775 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG), 4776 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG), 4777 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG), 4778 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG), 4779 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG), 4780 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG), 4781 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG), 4782 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG), 4783 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG), 4784 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG), 4785 /* default Intel */ 4786 SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST), 4787 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG), 4788 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG), 4789 {} 4790 }; 4791 4792 static const struct alc_model_fixup alc880_fixup_models[] = { 4793 {.id = ALC880_FIXUP_3ST, .name = "3stack"}, 4794 {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"}, 4795 {.id = ALC880_FIXUP_5ST, .name = "5stack"}, 4796 {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"}, 4797 {.id = ALC880_FIXUP_6ST, .name = "6stack"}, 4798 {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"}, 4799 {} 4800 }; 4801 4802 4803 /* 4804 * OK, here we have finally the patch for ALC880 4805 */ 4806 static int patch_alc880(struct hda_codec *codec) 4807 { 4808 struct alc_spec *spec; 4809 int err; 4810 4811 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 4812 if (spec == NULL) 4813 return -ENOMEM; 4814 4815 codec->spec = spec; 4816 4817 spec->mixer_nid = 0x0b; 4818 spec->need_dac_fix = 1; 4819 4820 alc_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl, 4821 alc880_fixups); 4822 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE); 4823 4824 /* automatic parse from the BIOS config */ 4825 err = alc880_parse_auto_config(codec); 4826 if (err < 0) 4827 goto error; 4828 4829 if (!spec->no_analog) { 4830 err = snd_hda_attach_beep_device(codec, 0x1); 4831 if (err < 0) 4832 goto error; 4833 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 4834 } 4835 4836 codec->patch_ops = alc_patch_ops; 4837 4838 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE); 4839 4840 return 0; 4841 4842 error: 4843 alc_free(codec); 4844 return err; 4845 } 4846 4847 4848 /* 4849 * ALC260 support 4850 */ 4851 static int alc260_parse_auto_config(struct hda_codec *codec) 4852 { 4853 static const hda_nid_t alc260_ignore[] = { 0x17, 0 }; 4854 static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 }; 4855 return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids); 4856 } 4857 4858 /* 4859 * Pin config fixes 4860 */ 4861 enum { 4862 ALC260_FIXUP_HP_DC5750, 4863 ALC260_FIXUP_HP_PIN_0F, 4864 ALC260_FIXUP_COEF, 4865 ALC260_FIXUP_GPIO1, 4866 ALC260_FIXUP_GPIO1_TOGGLE, 4867 ALC260_FIXUP_REPLACER, 4868 ALC260_FIXUP_HP_B1900, 4869 ALC260_FIXUP_KN1, 4870 }; 4871 4872 static void alc260_gpio1_automute(struct hda_codec *codec) 4873 { 4874 struct alc_spec *spec = codec->spec; 4875 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 4876 spec->hp_jack_present); 4877 } 4878 4879 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec, 4880 const struct alc_fixup *fix, int action) 4881 { 4882 struct alc_spec *spec = codec->spec; 4883 if (action == ALC_FIXUP_ACT_PROBE) { 4884 /* although the machine has only one output pin, we need to 4885 * toggle GPIO1 according to the jack state 4886 */ 4887 spec->automute_hook = alc260_gpio1_automute; 4888 spec->detect_hp = 1; 4889 spec->automute_speaker = 1; 4890 spec->autocfg.hp_pins[0] = 0x0f; /* copy it for automute */ 4891 snd_hda_jack_detect_enable(codec, 0x0f, ALC_HP_EVENT); 4892 spec->unsol_event = alc_sku_unsol_event; 4893 add_verb(codec->spec, alc_gpio1_init_verbs); 4894 } 4895 } 4896 4897 static void alc260_fixup_kn1(struct hda_codec *codec, 4898 const struct alc_fixup *fix, int action) 4899 { 4900 struct alc_spec *spec = codec->spec; 4901 static const struct alc_pincfg pincfgs[] = { 4902 { 0x0f, 0x02214000 }, /* HP/speaker */ 4903 { 0x12, 0x90a60160 }, /* int mic */ 4904 { 0x13, 0x02a19000 }, /* ext mic */ 4905 { 0x18, 0x01446000 }, /* SPDIF out */ 4906 /* disable bogus I/O pins */ 4907 { 0x10, 0x411111f0 }, 4908 { 0x11, 0x411111f0 }, 4909 { 0x14, 0x411111f0 }, 4910 { 0x15, 0x411111f0 }, 4911 { 0x16, 0x411111f0 }, 4912 { 0x17, 0x411111f0 }, 4913 { 0x19, 0x411111f0 }, 4914 { } 4915 }; 4916 4917 switch (action) { 4918 case ALC_FIXUP_ACT_PRE_PROBE: 4919 alc_apply_pincfgs(codec, pincfgs); 4920 break; 4921 case ALC_FIXUP_ACT_PROBE: 4922 spec->init_amp = ALC_INIT_NONE; 4923 break; 4924 } 4925 } 4926 4927 static const struct alc_fixup alc260_fixups[] = { 4928 [ALC260_FIXUP_HP_DC5750] = { 4929 .type = ALC_FIXUP_PINS, 4930 .v.pins = (const struct alc_pincfg[]) { 4931 { 0x11, 0x90130110 }, /* speaker */ 4932 { } 4933 } 4934 }, 4935 [ALC260_FIXUP_HP_PIN_0F] = { 4936 .type = ALC_FIXUP_PINS, 4937 .v.pins = (const struct alc_pincfg[]) { 4938 { 0x0f, 0x01214000 }, /* HP */ 4939 { } 4940 } 4941 }, 4942 [ALC260_FIXUP_COEF] = { 4943 .type = ALC_FIXUP_VERBS, 4944 .v.verbs = (const struct hda_verb[]) { 4945 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 4946 { 0x20, AC_VERB_SET_PROC_COEF, 0x3040 }, 4947 { } 4948 }, 4949 .chained = true, 4950 .chain_id = ALC260_FIXUP_HP_PIN_0F, 4951 }, 4952 [ALC260_FIXUP_GPIO1] = { 4953 .type = ALC_FIXUP_VERBS, 4954 .v.verbs = alc_gpio1_init_verbs, 4955 }, 4956 [ALC260_FIXUP_GPIO1_TOGGLE] = { 4957 .type = ALC_FIXUP_FUNC, 4958 .v.func = alc260_fixup_gpio1_toggle, 4959 .chained = true, 4960 .chain_id = ALC260_FIXUP_HP_PIN_0F, 4961 }, 4962 [ALC260_FIXUP_REPLACER] = { 4963 .type = ALC_FIXUP_VERBS, 4964 .v.verbs = (const struct hda_verb[]) { 4965 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 4966 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 }, 4967 { } 4968 }, 4969 .chained = true, 4970 .chain_id = ALC260_FIXUP_GPIO1_TOGGLE, 4971 }, 4972 [ALC260_FIXUP_HP_B1900] = { 4973 .type = ALC_FIXUP_FUNC, 4974 .v.func = alc260_fixup_gpio1_toggle, 4975 .chained = true, 4976 .chain_id = ALC260_FIXUP_COEF, 4977 }, 4978 [ALC260_FIXUP_KN1] = { 4979 .type = ALC_FIXUP_FUNC, 4980 .v.func = alc260_fixup_kn1, 4981 }, 4982 }; 4983 4984 static const struct snd_pci_quirk alc260_fixup_tbl[] = { 4985 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1), 4986 SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF), 4987 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1), 4988 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750), 4989 SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900), 4990 SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1), 4991 SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1), 4992 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER), 4993 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF), 4994 {} 4995 }; 4996 4997 /* 4998 */ 4999 static int patch_alc260(struct hda_codec *codec) 5000 { 5001 struct alc_spec *spec; 5002 int err; 5003 5004 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5005 if (spec == NULL) 5006 return -ENOMEM; 5007 5008 codec->spec = spec; 5009 5010 spec->mixer_nid = 0x07; 5011 5012 alc_pick_fixup(codec, NULL, alc260_fixup_tbl, alc260_fixups); 5013 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE); 5014 5015 /* automatic parse from the BIOS config */ 5016 err = alc260_parse_auto_config(codec); 5017 if (err < 0) 5018 goto error; 5019 5020 if (!spec->no_analog) { 5021 err = snd_hda_attach_beep_device(codec, 0x1); 5022 if (err < 0) 5023 goto error; 5024 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT); 5025 } 5026 5027 codec->patch_ops = alc_patch_ops; 5028 spec->shutup = alc_eapd_shutup; 5029 5030 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE); 5031 5032 return 0; 5033 5034 error: 5035 alc_free(codec); 5036 return err; 5037 } 5038 5039 5040 /* 5041 * ALC882/883/885/888/889 support 5042 * 5043 * ALC882 is almost identical with ALC880 but has cleaner and more flexible 5044 * configuration. Each pin widget can choose any input DACs and a mixer. 5045 * Each ADC is connected from a mixer of all inputs. This makes possible 5046 * 6-channel independent captures. 5047 * 5048 * In addition, an independent DAC for the multi-playback (not used in this 5049 * driver yet). 5050 */ 5051 5052 /* 5053 * Pin config fixes 5054 */ 5055 enum { 5056 ALC882_FIXUP_ABIT_AW9D_MAX, 5057 ALC882_FIXUP_LENOVO_Y530, 5058 ALC882_FIXUP_PB_M5210, 5059 ALC882_FIXUP_ACER_ASPIRE_7736, 5060 ALC882_FIXUP_ASUS_W90V, 5061 ALC889_FIXUP_CD, 5062 ALC889_FIXUP_VAIO_TT, 5063 ALC888_FIXUP_EEE1601, 5064 ALC882_FIXUP_EAPD, 5065 ALC883_FIXUP_EAPD, 5066 ALC883_FIXUP_ACER_EAPD, 5067 ALC882_FIXUP_GPIO1, 5068 ALC882_FIXUP_GPIO2, 5069 ALC882_FIXUP_GPIO3, 5070 ALC889_FIXUP_COEF, 5071 ALC882_FIXUP_ASUS_W2JC, 5072 ALC882_FIXUP_ACER_ASPIRE_4930G, 5073 ALC882_FIXUP_ACER_ASPIRE_8930G, 5074 ALC882_FIXUP_ASPIRE_8930G_VERBS, 5075 ALC885_FIXUP_MACPRO_GPIO, 5076 ALC889_FIXUP_DAC_ROUTE, 5077 ALC889_FIXUP_MBP_VREF, 5078 ALC889_FIXUP_IMAC91_VREF, 5079 }; 5080 5081 static void alc889_fixup_coef(struct hda_codec *codec, 5082 const struct alc_fixup *fix, int action) 5083 { 5084 if (action != ALC_FIXUP_ACT_INIT) 5085 return; 5086 alc889_coef_init(codec); 5087 } 5088 5089 /* toggle speaker-output according to the hp-jack state */ 5090 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted) 5091 { 5092 unsigned int gpiostate, gpiomask, gpiodir; 5093 5094 gpiostate = snd_hda_codec_read(codec, codec->afg, 0, 5095 AC_VERB_GET_GPIO_DATA, 0); 5096 5097 if (!muted) 5098 gpiostate |= (1 << pin); 5099 else 5100 gpiostate &= ~(1 << pin); 5101 5102 gpiomask = snd_hda_codec_read(codec, codec->afg, 0, 5103 AC_VERB_GET_GPIO_MASK, 0); 5104 gpiomask |= (1 << pin); 5105 5106 gpiodir = snd_hda_codec_read(codec, codec->afg, 0, 5107 AC_VERB_GET_GPIO_DIRECTION, 0); 5108 gpiodir |= (1 << pin); 5109 5110 5111 snd_hda_codec_write(codec, codec->afg, 0, 5112 AC_VERB_SET_GPIO_MASK, gpiomask); 5113 snd_hda_codec_write(codec, codec->afg, 0, 5114 AC_VERB_SET_GPIO_DIRECTION, gpiodir); 5115 5116 msleep(1); 5117 5118 snd_hda_codec_write(codec, codec->afg, 0, 5119 AC_VERB_SET_GPIO_DATA, gpiostate); 5120 } 5121 5122 /* set up GPIO at initialization */ 5123 static void alc885_fixup_macpro_gpio(struct hda_codec *codec, 5124 const struct alc_fixup *fix, int action) 5125 { 5126 if (action != ALC_FIXUP_ACT_INIT) 5127 return; 5128 alc882_gpio_mute(codec, 0, 0); 5129 alc882_gpio_mute(codec, 1, 0); 5130 } 5131 5132 /* Fix the connection of some pins for ALC889: 5133 * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't 5134 * work correctly (bko#42740) 5135 */ 5136 static void alc889_fixup_dac_route(struct hda_codec *codec, 5137 const struct alc_fixup *fix, int action) 5138 { 5139 if (action == ALC_FIXUP_ACT_PRE_PROBE) { 5140 /* fake the connections during parsing the tree */ 5141 hda_nid_t conn1[2] = { 0x0c, 0x0d }; 5142 hda_nid_t conn2[2] = { 0x0e, 0x0f }; 5143 snd_hda_override_conn_list(codec, 0x14, 2, conn1); 5144 snd_hda_override_conn_list(codec, 0x15, 2, conn1); 5145 snd_hda_override_conn_list(codec, 0x18, 2, conn2); 5146 snd_hda_override_conn_list(codec, 0x1a, 2, conn2); 5147 } else if (action == ALC_FIXUP_ACT_PROBE) { 5148 /* restore the connections */ 5149 hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 }; 5150 snd_hda_override_conn_list(codec, 0x14, 5, conn); 5151 snd_hda_override_conn_list(codec, 0x15, 5, conn); 5152 snd_hda_override_conn_list(codec, 0x18, 5, conn); 5153 snd_hda_override_conn_list(codec, 0x1a, 5, conn); 5154 } 5155 } 5156 5157 /* Set VREF on HP pin */ 5158 static void alc889_fixup_mbp_vref(struct hda_codec *codec, 5159 const struct alc_fixup *fix, int action) 5160 { 5161 struct alc_spec *spec = codec->spec; 5162 static hda_nid_t nids[2] = { 0x14, 0x15 }; 5163 int i; 5164 5165 if (action != ALC_FIXUP_ACT_INIT) 5166 return; 5167 for (i = 0; i < ARRAY_SIZE(nids); i++) { 5168 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]); 5169 if (get_defcfg_device(val) != AC_JACK_HP_OUT) 5170 continue; 5171 val = snd_hda_codec_read(codec, nids[i], 0, 5172 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 5173 val |= AC_PINCTL_VREF_80; 5174 snd_hda_codec_write(codec, nids[i], 0, 5175 AC_VERB_SET_PIN_WIDGET_CONTROL, val); 5176 spec->keep_vref_in_automute = 1; 5177 break; 5178 } 5179 } 5180 5181 /* Set VREF on speaker pins on imac91 */ 5182 static void alc889_fixup_imac91_vref(struct hda_codec *codec, 5183 const struct alc_fixup *fix, int action) 5184 { 5185 struct alc_spec *spec = codec->spec; 5186 static hda_nid_t nids[2] = { 0x18, 0x1a }; 5187 int i; 5188 5189 if (action != ALC_FIXUP_ACT_INIT) 5190 return; 5191 for (i = 0; i < ARRAY_SIZE(nids); i++) { 5192 unsigned int val; 5193 val = snd_hda_codec_read(codec, nids[i], 0, 5194 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 5195 val |= AC_PINCTL_VREF_50; 5196 snd_hda_codec_write(codec, nids[i], 0, 5197 AC_VERB_SET_PIN_WIDGET_CONTROL, val); 5198 } 5199 spec->keep_vref_in_automute = 1; 5200 } 5201 5202 static const struct alc_fixup alc882_fixups[] = { 5203 [ALC882_FIXUP_ABIT_AW9D_MAX] = { 5204 .type = ALC_FIXUP_PINS, 5205 .v.pins = (const struct alc_pincfg[]) { 5206 { 0x15, 0x01080104 }, /* side */ 5207 { 0x16, 0x01011012 }, /* rear */ 5208 { 0x17, 0x01016011 }, /* clfe */ 5209 { } 5210 } 5211 }, 5212 [ALC882_FIXUP_LENOVO_Y530] = { 5213 .type = ALC_FIXUP_PINS, 5214 .v.pins = (const struct alc_pincfg[]) { 5215 { 0x15, 0x99130112 }, /* rear int speakers */ 5216 { 0x16, 0x99130111 }, /* subwoofer */ 5217 { } 5218 } 5219 }, 5220 [ALC882_FIXUP_PB_M5210] = { 5221 .type = ALC_FIXUP_VERBS, 5222 .v.verbs = (const struct hda_verb[]) { 5223 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 }, 5224 {} 5225 } 5226 }, 5227 [ALC882_FIXUP_ACER_ASPIRE_7736] = { 5228 .type = ALC_FIXUP_SKU, 5229 .v.sku = ALC_FIXUP_SKU_IGNORE, 5230 }, 5231 [ALC882_FIXUP_ASUS_W90V] = { 5232 .type = ALC_FIXUP_PINS, 5233 .v.pins = (const struct alc_pincfg[]) { 5234 { 0x16, 0x99130110 }, /* fix sequence for CLFE */ 5235 { } 5236 } 5237 }, 5238 [ALC889_FIXUP_CD] = { 5239 .type = ALC_FIXUP_PINS, 5240 .v.pins = (const struct alc_pincfg[]) { 5241 { 0x1c, 0x993301f0 }, /* CD */ 5242 { } 5243 } 5244 }, 5245 [ALC889_FIXUP_VAIO_TT] = { 5246 .type = ALC_FIXUP_PINS, 5247 .v.pins = (const struct alc_pincfg[]) { 5248 { 0x17, 0x90170111 }, /* hidden surround speaker */ 5249 { } 5250 } 5251 }, 5252 [ALC888_FIXUP_EEE1601] = { 5253 .type = ALC_FIXUP_VERBS, 5254 .v.verbs = (const struct hda_verb[]) { 5255 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b }, 5256 { 0x20, AC_VERB_SET_PROC_COEF, 0x0838 }, 5257 { } 5258 } 5259 }, 5260 [ALC882_FIXUP_EAPD] = { 5261 .type = ALC_FIXUP_VERBS, 5262 .v.verbs = (const struct hda_verb[]) { 5263 /* change to EAPD mode */ 5264 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 5265 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 }, 5266 { } 5267 } 5268 }, 5269 [ALC883_FIXUP_EAPD] = { 5270 .type = ALC_FIXUP_VERBS, 5271 .v.verbs = (const struct hda_verb[]) { 5272 /* change to EAPD mode */ 5273 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 5274 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 }, 5275 { } 5276 } 5277 }, 5278 [ALC883_FIXUP_ACER_EAPD] = { 5279 .type = ALC_FIXUP_VERBS, 5280 .v.verbs = (const struct hda_verb[]) { 5281 /* eanable EAPD on Acer laptops */ 5282 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 5283 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 }, 5284 { } 5285 } 5286 }, 5287 [ALC882_FIXUP_GPIO1] = { 5288 .type = ALC_FIXUP_VERBS, 5289 .v.verbs = alc_gpio1_init_verbs, 5290 }, 5291 [ALC882_FIXUP_GPIO2] = { 5292 .type = ALC_FIXUP_VERBS, 5293 .v.verbs = alc_gpio2_init_verbs, 5294 }, 5295 [ALC882_FIXUP_GPIO3] = { 5296 .type = ALC_FIXUP_VERBS, 5297 .v.verbs = alc_gpio3_init_verbs, 5298 }, 5299 [ALC882_FIXUP_ASUS_W2JC] = { 5300 .type = ALC_FIXUP_VERBS, 5301 .v.verbs = alc_gpio1_init_verbs, 5302 .chained = true, 5303 .chain_id = ALC882_FIXUP_EAPD, 5304 }, 5305 [ALC889_FIXUP_COEF] = { 5306 .type = ALC_FIXUP_FUNC, 5307 .v.func = alc889_fixup_coef, 5308 }, 5309 [ALC882_FIXUP_ACER_ASPIRE_4930G] = { 5310 .type = ALC_FIXUP_PINS, 5311 .v.pins = (const struct alc_pincfg[]) { 5312 { 0x16, 0x99130111 }, /* CLFE speaker */ 5313 { 0x17, 0x99130112 }, /* surround speaker */ 5314 { } 5315 }, 5316 .chained = true, 5317 .chain_id = ALC882_FIXUP_GPIO1, 5318 }, 5319 [ALC882_FIXUP_ACER_ASPIRE_8930G] = { 5320 .type = ALC_FIXUP_PINS, 5321 .v.pins = (const struct alc_pincfg[]) { 5322 { 0x16, 0x99130111 }, /* CLFE speaker */ 5323 { 0x1b, 0x99130112 }, /* surround speaker */ 5324 { } 5325 }, 5326 .chained = true, 5327 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS, 5328 }, 5329 [ALC882_FIXUP_ASPIRE_8930G_VERBS] = { 5330 /* additional init verbs for Acer Aspire 8930G */ 5331 .type = ALC_FIXUP_VERBS, 5332 .v.verbs = (const struct hda_verb[]) { 5333 /* Enable all DACs */ 5334 /* DAC DISABLE/MUTE 1? */ 5335 /* setting bits 1-5 disables DAC nids 0x02-0x06 5336 * apparently. Init=0x38 */ 5337 { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 }, 5338 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 }, 5339 /* DAC DISABLE/MUTE 2? */ 5340 /* some bit here disables the other DACs. 5341 * Init=0x4900 */ 5342 { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 }, 5343 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 }, 5344 /* DMIC fix 5345 * This laptop has a stereo digital microphone. 5346 * The mics are only 1cm apart which makes the stereo 5347 * useless. However, either the mic or the ALC889 5348 * makes the signal become a difference/sum signal 5349 * instead of standard stereo, which is annoying. 5350 * So instead we flip this bit which makes the 5351 * codec replicate the sum signal to both channels, 5352 * turning it into a normal mono mic. 5353 */ 5354 /* DMIC_CONTROL? Init value = 0x0001 */ 5355 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b }, 5356 { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 }, 5357 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 5358 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 }, 5359 { } 5360 }, 5361 .chained = true, 5362 .chain_id = ALC882_FIXUP_GPIO1, 5363 }, 5364 [ALC885_FIXUP_MACPRO_GPIO] = { 5365 .type = ALC_FIXUP_FUNC, 5366 .v.func = alc885_fixup_macpro_gpio, 5367 }, 5368 [ALC889_FIXUP_DAC_ROUTE] = { 5369 .type = ALC_FIXUP_FUNC, 5370 .v.func = alc889_fixup_dac_route, 5371 }, 5372 [ALC889_FIXUP_MBP_VREF] = { 5373 .type = ALC_FIXUP_FUNC, 5374 .v.func = alc889_fixup_mbp_vref, 5375 .chained = true, 5376 .chain_id = ALC882_FIXUP_GPIO1, 5377 }, 5378 [ALC889_FIXUP_IMAC91_VREF] = { 5379 .type = ALC_FIXUP_FUNC, 5380 .v.func = alc889_fixup_imac91_vref, 5381 .chained = true, 5382 .chain_id = ALC882_FIXUP_GPIO1, 5383 }, 5384 }; 5385 5386 static const struct snd_pci_quirk alc882_fixup_tbl[] = { 5387 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD), 5388 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD), 5389 SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD), 5390 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD), 5391 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD), 5392 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD), 5393 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G", 5394 ALC882_FIXUP_ACER_ASPIRE_4930G), 5395 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G", 5396 ALC882_FIXUP_ACER_ASPIRE_4930G), 5397 SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G", 5398 ALC882_FIXUP_ACER_ASPIRE_8930G), 5399 SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G", 5400 ALC882_FIXUP_ACER_ASPIRE_8930G), 5401 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G", 5402 ALC882_FIXUP_ACER_ASPIRE_4930G), 5403 SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G", 5404 ALC882_FIXUP_ACER_ASPIRE_4930G), 5405 SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G", 5406 ALC882_FIXUP_ACER_ASPIRE_4930G), 5407 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210), 5408 SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G", 5409 ALC882_FIXUP_ACER_ASPIRE_4930G), 5410 SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE), 5411 SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G), 5412 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736), 5413 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD), 5414 SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V), 5415 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC), 5416 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601), 5417 SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT), 5418 5419 /* All Apple entries are in codec SSIDs */ 5420 SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF), 5421 SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF), 5422 SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF), 5423 SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_FIXUP_MACPRO_GPIO), 5424 SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO), 5425 SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO), 5426 SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF), 5427 SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF), 5428 SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD), 5429 SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBP_VREF), 5430 SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBP_VREF), 5431 SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF), 5432 SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF), 5433 SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO), 5434 SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF), 5435 SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF), 5436 SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF), 5437 SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 5,1", ALC885_FIXUP_MACPRO_GPIO), 5438 SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF), 5439 SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF), 5440 SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_IMAC91_VREF), 5441 5442 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD), 5443 SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD), 5444 SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3), 5445 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3", ALC889_FIXUP_CD), 5446 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX), 5447 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD), 5448 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD), 5449 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530), 5450 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF), 5451 {} 5452 }; 5453 5454 static const struct alc_model_fixup alc882_fixup_models[] = { 5455 {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"}, 5456 {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"}, 5457 {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"}, 5458 {} 5459 }; 5460 5461 /* 5462 * BIOS auto configuration 5463 */ 5464 /* almost identical with ALC880 parser... */ 5465 static int alc882_parse_auto_config(struct hda_codec *codec) 5466 { 5467 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 }; 5468 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 5469 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids); 5470 } 5471 5472 /* 5473 */ 5474 static int patch_alc882(struct hda_codec *codec) 5475 { 5476 struct alc_spec *spec; 5477 int err; 5478 5479 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5480 if (spec == NULL) 5481 return -ENOMEM; 5482 5483 codec->spec = spec; 5484 5485 spec->mixer_nid = 0x0b; 5486 5487 switch (codec->vendor_id) { 5488 case 0x10ec0882: 5489 case 0x10ec0885: 5490 break; 5491 default: 5492 /* ALC883 and variants */ 5493 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 5494 break; 5495 } 5496 5497 err = alc_codec_rename_from_preset(codec); 5498 if (err < 0) 5499 goto error; 5500 5501 alc_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl, 5502 alc882_fixups); 5503 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE); 5504 5505 alc_auto_parse_customize_define(codec); 5506 5507 /* automatic parse from the BIOS config */ 5508 err = alc882_parse_auto_config(codec); 5509 if (err < 0) 5510 goto error; 5511 5512 if (!spec->no_analog && has_cdefine_beep(codec)) { 5513 err = snd_hda_attach_beep_device(codec, 0x1); 5514 if (err < 0) 5515 goto error; 5516 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 5517 } 5518 5519 codec->patch_ops = alc_patch_ops; 5520 5521 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE); 5522 5523 return 0; 5524 5525 error: 5526 alc_free(codec); 5527 return err; 5528 } 5529 5530 5531 /* 5532 * ALC262 support 5533 */ 5534 static int alc262_parse_auto_config(struct hda_codec *codec) 5535 { 5536 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 }; 5537 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 5538 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids); 5539 } 5540 5541 /* 5542 * Pin config fixes 5543 */ 5544 enum { 5545 ALC262_FIXUP_FSC_H270, 5546 ALC262_FIXUP_HP_Z200, 5547 ALC262_FIXUP_TYAN, 5548 ALC262_FIXUP_LENOVO_3000, 5549 ALC262_FIXUP_BENQ, 5550 ALC262_FIXUP_BENQ_T31, 5551 }; 5552 5553 static const struct alc_fixup alc262_fixups[] = { 5554 [ALC262_FIXUP_FSC_H270] = { 5555 .type = ALC_FIXUP_PINS, 5556 .v.pins = (const struct alc_pincfg[]) { 5557 { 0x14, 0x99130110 }, /* speaker */ 5558 { 0x15, 0x0221142f }, /* front HP */ 5559 { 0x1b, 0x0121141f }, /* rear HP */ 5560 { } 5561 } 5562 }, 5563 [ALC262_FIXUP_HP_Z200] = { 5564 .type = ALC_FIXUP_PINS, 5565 .v.pins = (const struct alc_pincfg[]) { 5566 { 0x16, 0x99130120 }, /* internal speaker */ 5567 { } 5568 } 5569 }, 5570 [ALC262_FIXUP_TYAN] = { 5571 .type = ALC_FIXUP_PINS, 5572 .v.pins = (const struct alc_pincfg[]) { 5573 { 0x14, 0x1993e1f0 }, /* int AUX */ 5574 { } 5575 } 5576 }, 5577 [ALC262_FIXUP_LENOVO_3000] = { 5578 .type = ALC_FIXUP_VERBS, 5579 .v.verbs = (const struct hda_verb[]) { 5580 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 }, 5581 {} 5582 }, 5583 .chained = true, 5584 .chain_id = ALC262_FIXUP_BENQ, 5585 }, 5586 [ALC262_FIXUP_BENQ] = { 5587 .type = ALC_FIXUP_VERBS, 5588 .v.verbs = (const struct hda_verb[]) { 5589 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 5590 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 }, 5591 {} 5592 } 5593 }, 5594 [ALC262_FIXUP_BENQ_T31] = { 5595 .type = ALC_FIXUP_VERBS, 5596 .v.verbs = (const struct hda_verb[]) { 5597 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, 5598 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 }, 5599 {} 5600 } 5601 }, 5602 }; 5603 5604 static const struct snd_pci_quirk alc262_fixup_tbl[] = { 5605 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200), 5606 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FIXUP_BENQ), 5607 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ), 5608 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN), 5609 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270), 5610 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000), 5611 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ), 5612 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31), 5613 {} 5614 }; 5615 5616 5617 /* 5618 */ 5619 static int patch_alc262(struct hda_codec *codec) 5620 { 5621 struct alc_spec *spec; 5622 int err; 5623 5624 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5625 if (spec == NULL) 5626 return -ENOMEM; 5627 5628 codec->spec = spec; 5629 5630 spec->mixer_nid = 0x0b; 5631 5632 #if 0 5633 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is 5634 * under-run 5635 */ 5636 { 5637 int tmp; 5638 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7); 5639 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0); 5640 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7); 5641 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80); 5642 } 5643 #endif 5644 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 5645 5646 alc_pick_fixup(codec, NULL, alc262_fixup_tbl, alc262_fixups); 5647 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE); 5648 5649 alc_auto_parse_customize_define(codec); 5650 5651 /* automatic parse from the BIOS config */ 5652 err = alc262_parse_auto_config(codec); 5653 if (err < 0) 5654 goto error; 5655 5656 if (!spec->no_analog && has_cdefine_beep(codec)) { 5657 err = snd_hda_attach_beep_device(codec, 0x1); 5658 if (err < 0) 5659 goto error; 5660 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 5661 } 5662 5663 codec->patch_ops = alc_patch_ops; 5664 spec->shutup = alc_eapd_shutup; 5665 5666 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE); 5667 5668 return 0; 5669 5670 error: 5671 alc_free(codec); 5672 return err; 5673 } 5674 5675 /* 5676 * ALC268 5677 */ 5678 /* bind Beep switches of both NID 0x0f and 0x10 */ 5679 static const struct hda_bind_ctls alc268_bind_beep_sw = { 5680 .ops = &snd_hda_bind_sw, 5681 .values = { 5682 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT), 5683 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT), 5684 0 5685 }, 5686 }; 5687 5688 static const struct snd_kcontrol_new alc268_beep_mixer[] = { 5689 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT), 5690 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw), 5691 { } 5692 }; 5693 5694 /* set PCBEEP vol = 0, mute connections */ 5695 static const struct hda_verb alc268_beep_init_verbs[] = { 5696 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5697 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5698 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5699 { } 5700 }; 5701 5702 /* 5703 * BIOS auto configuration 5704 */ 5705 static int alc268_parse_auto_config(struct hda_codec *codec) 5706 { 5707 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 5708 struct alc_spec *spec = codec->spec; 5709 int err = alc_parse_auto_config(codec, NULL, alc268_ssids); 5710 if (err > 0) { 5711 if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d) { 5712 add_mixer(spec, alc268_beep_mixer); 5713 add_verb(spec, alc268_beep_init_verbs); 5714 } 5715 } 5716 return err; 5717 } 5718 5719 /* 5720 */ 5721 static int patch_alc268(struct hda_codec *codec) 5722 { 5723 struct alc_spec *spec; 5724 int i, has_beep, err; 5725 5726 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5727 if (spec == NULL) 5728 return -ENOMEM; 5729 5730 codec->spec = spec; 5731 5732 /* ALC268 has no aa-loopback mixer */ 5733 5734 /* automatic parse from the BIOS config */ 5735 err = alc268_parse_auto_config(codec); 5736 if (err < 0) 5737 goto error; 5738 5739 has_beep = 0; 5740 for (i = 0; i < spec->num_mixers; i++) { 5741 if (spec->mixers[i] == alc268_beep_mixer) { 5742 has_beep = 1; 5743 break; 5744 } 5745 } 5746 5747 if (has_beep) { 5748 err = snd_hda_attach_beep_device(codec, 0x1); 5749 if (err < 0) 5750 goto error; 5751 if (!query_amp_caps(codec, 0x1d, HDA_INPUT)) 5752 /* override the amp caps for beep generator */ 5753 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT, 5754 (0x0c << AC_AMPCAP_OFFSET_SHIFT) | 5755 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) | 5756 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) | 5757 (0 << AC_AMPCAP_MUTE_SHIFT)); 5758 } 5759 5760 codec->patch_ops = alc_patch_ops; 5761 spec->shutup = alc_eapd_shutup; 5762 5763 return 0; 5764 5765 error: 5766 alc_free(codec); 5767 return err; 5768 } 5769 5770 /* 5771 * ALC269 5772 */ 5773 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = { 5774 .substreams = 1, 5775 .channels_min = 2, 5776 .channels_max = 8, 5777 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */ 5778 /* NID is set in alc_build_pcms */ 5779 .ops = { 5780 .open = alc_playback_pcm_open, 5781 .prepare = alc_playback_pcm_prepare, 5782 .cleanup = alc_playback_pcm_cleanup 5783 }, 5784 }; 5785 5786 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = { 5787 .substreams = 1, 5788 .channels_min = 2, 5789 .channels_max = 2, 5790 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */ 5791 /* NID is set in alc_build_pcms */ 5792 }; 5793 5794 /* different alc269-variants */ 5795 enum { 5796 ALC269_TYPE_ALC269VA, 5797 ALC269_TYPE_ALC269VB, 5798 ALC269_TYPE_ALC269VC, 5799 }; 5800 5801 /* 5802 * BIOS auto configuration 5803 */ 5804 static int alc269_parse_auto_config(struct hda_codec *codec) 5805 { 5806 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 }; 5807 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 }; 5808 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 5809 struct alc_spec *spec = codec->spec; 5810 const hda_nid_t *ssids = spec->codec_variant == ALC269_TYPE_ALC269VA ? 5811 alc269va_ssids : alc269_ssids; 5812 5813 return alc_parse_auto_config(codec, alc269_ignore, ssids); 5814 } 5815 5816 static void alc269_toggle_power_output(struct hda_codec *codec, int power_up) 5817 { 5818 int val = alc_read_coef_idx(codec, 0x04); 5819 if (power_up) 5820 val |= 1 << 11; 5821 else 5822 val &= ~(1 << 11); 5823 alc_write_coef_idx(codec, 0x04, val); 5824 } 5825 5826 static void alc269_shutup(struct hda_codec *codec) 5827 { 5828 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) 5829 alc269_toggle_power_output(codec, 0); 5830 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) { 5831 alc269_toggle_power_output(codec, 0); 5832 msleep(150); 5833 } 5834 } 5835 5836 #ifdef CONFIG_PM 5837 static int alc269_resume(struct hda_codec *codec) 5838 { 5839 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) { 5840 alc269_toggle_power_output(codec, 0); 5841 msleep(150); 5842 } 5843 5844 codec->patch_ops.init(codec); 5845 5846 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) { 5847 alc269_toggle_power_output(codec, 1); 5848 msleep(200); 5849 } 5850 5851 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) 5852 alc269_toggle_power_output(codec, 1); 5853 5854 snd_hda_codec_resume_amp(codec); 5855 snd_hda_codec_resume_cache(codec); 5856 hda_call_check_power_status(codec, 0x01); 5857 return 0; 5858 } 5859 #endif /* CONFIG_PM */ 5860 5861 static void alc269_fixup_hweq(struct hda_codec *codec, 5862 const struct alc_fixup *fix, int action) 5863 { 5864 int coef; 5865 5866 if (action != ALC_FIXUP_ACT_INIT) 5867 return; 5868 coef = alc_read_coef_idx(codec, 0x1e); 5869 alc_write_coef_idx(codec, 0x1e, coef | 0x80); 5870 } 5871 5872 static void alc271_fixup_dmic(struct hda_codec *codec, 5873 const struct alc_fixup *fix, int action) 5874 { 5875 static const struct hda_verb verbs[] = { 5876 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d}, 5877 {0x20, AC_VERB_SET_PROC_COEF, 0x4000}, 5878 {} 5879 }; 5880 unsigned int cfg; 5881 5882 if (strcmp(codec->chip_name, "ALC271X")) 5883 return; 5884 cfg = snd_hda_codec_get_pincfg(codec, 0x12); 5885 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED) 5886 snd_hda_sequence_write(codec, verbs); 5887 } 5888 5889 static void alc269_fixup_pcm_44k(struct hda_codec *codec, 5890 const struct alc_fixup *fix, int action) 5891 { 5892 struct alc_spec *spec = codec->spec; 5893 5894 if (action != ALC_FIXUP_ACT_PROBE) 5895 return; 5896 5897 /* Due to a hardware problem on Lenovo Ideadpad, we need to 5898 * fix the sample rate of analog I/O to 44.1kHz 5899 */ 5900 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback; 5901 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture; 5902 } 5903 5904 static void alc269_fixup_stereo_dmic(struct hda_codec *codec, 5905 const struct alc_fixup *fix, int action) 5906 { 5907 int coef; 5908 5909 if (action != ALC_FIXUP_ACT_INIT) 5910 return; 5911 /* The digital-mic unit sends PDM (differential signal) instead of 5912 * the standard PCM, thus you can't record a valid mono stream as is. 5913 * Below is a workaround specific to ALC269 to control the dmic 5914 * signal source as mono. 5915 */ 5916 coef = alc_read_coef_idx(codec, 0x07); 5917 alc_write_coef_idx(codec, 0x07, coef | 0x80); 5918 } 5919 5920 static void alc269_quanta_automute(struct hda_codec *codec) 5921 { 5922 update_outputs(codec); 5923 5924 snd_hda_codec_write(codec, 0x20, 0, 5925 AC_VERB_SET_COEF_INDEX, 0x0c); 5926 snd_hda_codec_write(codec, 0x20, 0, 5927 AC_VERB_SET_PROC_COEF, 0x680); 5928 5929 snd_hda_codec_write(codec, 0x20, 0, 5930 AC_VERB_SET_COEF_INDEX, 0x0c); 5931 snd_hda_codec_write(codec, 0x20, 0, 5932 AC_VERB_SET_PROC_COEF, 0x480); 5933 } 5934 5935 static void alc269_fixup_quanta_mute(struct hda_codec *codec, 5936 const struct alc_fixup *fix, int action) 5937 { 5938 struct alc_spec *spec = codec->spec; 5939 if (action != ALC_FIXUP_ACT_PROBE) 5940 return; 5941 spec->automute_hook = alc269_quanta_automute; 5942 } 5943 5944 /* update mute-LED according to the speaker mute state via mic2 VREF pin */ 5945 static void alc269_fixup_mic2_mute_hook(void *private_data, int enabled) 5946 { 5947 struct hda_codec *codec = private_data; 5948 unsigned int pinval = enabled ? 0x20 : 0x24; 5949 snd_hda_codec_update_cache(codec, 0x19, 0, 5950 AC_VERB_SET_PIN_WIDGET_CONTROL, 5951 pinval); 5952 } 5953 5954 static void alc269_fixup_mic2_mute(struct hda_codec *codec, 5955 const struct alc_fixup *fix, int action) 5956 { 5957 struct alc_spec *spec = codec->spec; 5958 switch (action) { 5959 case ALC_FIXUP_ACT_BUILD: 5960 spec->vmaster_mute.hook = alc269_fixup_mic2_mute_hook; 5961 snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute, true); 5962 /* fallthru */ 5963 case ALC_FIXUP_ACT_INIT: 5964 snd_hda_sync_vmaster_hook(&spec->vmaster_mute); 5965 break; 5966 } 5967 } 5968 5969 enum { 5970 ALC269_FIXUP_SONY_VAIO, 5971 ALC275_FIXUP_SONY_VAIO_GPIO2, 5972 ALC269_FIXUP_DELL_M101Z, 5973 ALC269_FIXUP_SKU_IGNORE, 5974 ALC269_FIXUP_ASUS_G73JW, 5975 ALC269_FIXUP_LENOVO_EAPD, 5976 ALC275_FIXUP_SONY_HWEQ, 5977 ALC271_FIXUP_DMIC, 5978 ALC269_FIXUP_PCM_44K, 5979 ALC269_FIXUP_STEREO_DMIC, 5980 ALC269_FIXUP_QUANTA_MUTE, 5981 ALC269_FIXUP_LIFEBOOK, 5982 ALC269_FIXUP_AMIC, 5983 ALC269_FIXUP_DMIC, 5984 ALC269VB_FIXUP_AMIC, 5985 ALC269VB_FIXUP_DMIC, 5986 ALC269_FIXUP_MIC2_MUTE_LED, 5987 }; 5988 5989 static const struct alc_fixup alc269_fixups[] = { 5990 [ALC269_FIXUP_SONY_VAIO] = { 5991 .type = ALC_FIXUP_VERBS, 5992 .v.verbs = (const struct hda_verb[]) { 5993 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD}, 5994 {} 5995 } 5996 }, 5997 [ALC275_FIXUP_SONY_VAIO_GPIO2] = { 5998 .type = ALC_FIXUP_VERBS, 5999 .v.verbs = (const struct hda_verb[]) { 6000 {0x01, AC_VERB_SET_GPIO_MASK, 0x04}, 6001 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04}, 6002 {0x01, AC_VERB_SET_GPIO_DATA, 0x00}, 6003 { } 6004 }, 6005 .chained = true, 6006 .chain_id = ALC269_FIXUP_SONY_VAIO 6007 }, 6008 [ALC269_FIXUP_DELL_M101Z] = { 6009 .type = ALC_FIXUP_VERBS, 6010 .v.verbs = (const struct hda_verb[]) { 6011 /* Enables internal speaker */ 6012 {0x20, AC_VERB_SET_COEF_INDEX, 13}, 6013 {0x20, AC_VERB_SET_PROC_COEF, 0x4040}, 6014 {} 6015 } 6016 }, 6017 [ALC269_FIXUP_SKU_IGNORE] = { 6018 .type = ALC_FIXUP_SKU, 6019 .v.sku = ALC_FIXUP_SKU_IGNORE, 6020 }, 6021 [ALC269_FIXUP_ASUS_G73JW] = { 6022 .type = ALC_FIXUP_PINS, 6023 .v.pins = (const struct alc_pincfg[]) { 6024 { 0x17, 0x99130111 }, /* subwoofer */ 6025 { } 6026 } 6027 }, 6028 [ALC269_FIXUP_LENOVO_EAPD] = { 6029 .type = ALC_FIXUP_VERBS, 6030 .v.verbs = (const struct hda_verb[]) { 6031 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0}, 6032 {} 6033 } 6034 }, 6035 [ALC275_FIXUP_SONY_HWEQ] = { 6036 .type = ALC_FIXUP_FUNC, 6037 .v.func = alc269_fixup_hweq, 6038 .chained = true, 6039 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2 6040 }, 6041 [ALC271_FIXUP_DMIC] = { 6042 .type = ALC_FIXUP_FUNC, 6043 .v.func = alc271_fixup_dmic, 6044 }, 6045 [ALC269_FIXUP_PCM_44K] = { 6046 .type = ALC_FIXUP_FUNC, 6047 .v.func = alc269_fixup_pcm_44k, 6048 }, 6049 [ALC269_FIXUP_STEREO_DMIC] = { 6050 .type = ALC_FIXUP_FUNC, 6051 .v.func = alc269_fixup_stereo_dmic, 6052 }, 6053 [ALC269_FIXUP_QUANTA_MUTE] = { 6054 .type = ALC_FIXUP_FUNC, 6055 .v.func = alc269_fixup_quanta_mute, 6056 }, 6057 [ALC269_FIXUP_LIFEBOOK] = { 6058 .type = ALC_FIXUP_PINS, 6059 .v.pins = (const struct alc_pincfg[]) { 6060 { 0x1a, 0x2101103f }, /* dock line-out */ 6061 { 0x1b, 0x23a11040 }, /* dock mic-in */ 6062 { } 6063 }, 6064 .chained = true, 6065 .chain_id = ALC269_FIXUP_QUANTA_MUTE 6066 }, 6067 [ALC269_FIXUP_AMIC] = { 6068 .type = ALC_FIXUP_PINS, 6069 .v.pins = (const struct alc_pincfg[]) { 6070 { 0x14, 0x99130110 }, /* speaker */ 6071 { 0x15, 0x0121401f }, /* HP out */ 6072 { 0x18, 0x01a19c20 }, /* mic */ 6073 { 0x19, 0x99a3092f }, /* int-mic */ 6074 { } 6075 }, 6076 }, 6077 [ALC269_FIXUP_DMIC] = { 6078 .type = ALC_FIXUP_PINS, 6079 .v.pins = (const struct alc_pincfg[]) { 6080 { 0x12, 0x99a3092f }, /* int-mic */ 6081 { 0x14, 0x99130110 }, /* speaker */ 6082 { 0x15, 0x0121401f }, /* HP out */ 6083 { 0x18, 0x01a19c20 }, /* mic */ 6084 { } 6085 }, 6086 }, 6087 [ALC269VB_FIXUP_AMIC] = { 6088 .type = ALC_FIXUP_PINS, 6089 .v.pins = (const struct alc_pincfg[]) { 6090 { 0x14, 0x99130110 }, /* speaker */ 6091 { 0x18, 0x01a19c20 }, /* mic */ 6092 { 0x19, 0x99a3092f }, /* int-mic */ 6093 { 0x21, 0x0121401f }, /* HP out */ 6094 { } 6095 }, 6096 }, 6097 [ALC269VB_FIXUP_DMIC] = { 6098 .type = ALC_FIXUP_PINS, 6099 .v.pins = (const struct alc_pincfg[]) { 6100 { 0x12, 0x99a3092f }, /* int-mic */ 6101 { 0x14, 0x99130110 }, /* speaker */ 6102 { 0x18, 0x01a19c20 }, /* mic */ 6103 { 0x21, 0x0121401f }, /* HP out */ 6104 { } 6105 }, 6106 }, 6107 [ALC269_FIXUP_MIC2_MUTE_LED] = { 6108 .type = ALC_FIXUP_FUNC, 6109 .v.func = alc269_fixup_mic2_mute, 6110 }, 6111 }; 6112 6113 static const struct snd_pci_quirk alc269_fixup_tbl[] = { 6114 SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_MIC2_MUTE_LED), 6115 SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_DMIC), 6116 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW), 6117 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC), 6118 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC), 6119 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC), 6120 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC), 6121 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC), 6122 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2), 6123 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ), 6124 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ), 6125 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO), 6126 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z), 6127 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC), 6128 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK), 6129 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE), 6130 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE), 6131 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE), 6132 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE), 6133 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE), 6134 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_QUANTA_MUTE), 6135 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Lenovo Ideapd", ALC269_FIXUP_PCM_44K), 6136 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD), 6137 6138 #if 0 6139 /* Below is a quirk table taken from the old code. 6140 * Basically the device should work as is without the fixup table. 6141 * If BIOS doesn't give a proper info, enable the corresponding 6142 * fixup entry. 6143 */ 6144 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A", 6145 ALC269_FIXUP_AMIC), 6146 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC), 6147 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC), 6148 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC), 6149 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC), 6150 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC), 6151 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC), 6152 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC), 6153 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC), 6154 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC), 6155 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC), 6156 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC), 6157 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC), 6158 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC), 6159 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC), 6160 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC), 6161 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC), 6162 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC), 6163 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC), 6164 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC), 6165 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC), 6166 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC), 6167 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC), 6168 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC), 6169 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC), 6170 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC), 6171 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC), 6172 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC), 6173 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC), 6174 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC), 6175 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC), 6176 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC), 6177 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC), 6178 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC), 6179 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC), 6180 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC), 6181 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC), 6182 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC), 6183 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC), 6184 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC), 6185 #endif 6186 {} 6187 }; 6188 6189 static const struct alc_model_fixup alc269_fixup_models[] = { 6190 {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"}, 6191 {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"}, 6192 {} 6193 }; 6194 6195 6196 static void alc269_fill_coef(struct hda_codec *codec) 6197 { 6198 struct alc_spec *spec = codec->spec; 6199 int val; 6200 6201 if (spec->codec_variant != ALC269_TYPE_ALC269VB) 6202 return; 6203 6204 if ((alc_get_coef0(codec) & 0x00ff) < 0x015) { 6205 alc_write_coef_idx(codec, 0xf, 0x960b); 6206 alc_write_coef_idx(codec, 0xe, 0x8817); 6207 } 6208 6209 if ((alc_get_coef0(codec) & 0x00ff) == 0x016) { 6210 alc_write_coef_idx(codec, 0xf, 0x960b); 6211 alc_write_coef_idx(codec, 0xe, 0x8814); 6212 } 6213 6214 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) { 6215 val = alc_read_coef_idx(codec, 0x04); 6216 /* Power up output pin */ 6217 alc_write_coef_idx(codec, 0x04, val | (1<<11)); 6218 } 6219 6220 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) { 6221 val = alc_read_coef_idx(codec, 0xd); 6222 if ((val & 0x0c00) >> 10 != 0x1) { 6223 /* Capless ramp up clock control */ 6224 alc_write_coef_idx(codec, 0xd, val | (1<<10)); 6225 } 6226 val = alc_read_coef_idx(codec, 0x17); 6227 if ((val & 0x01c0) >> 6 != 0x4) { 6228 /* Class D power on reset */ 6229 alc_write_coef_idx(codec, 0x17, val | (1<<7)); 6230 } 6231 } 6232 6233 val = alc_read_coef_idx(codec, 0xd); /* Class D */ 6234 alc_write_coef_idx(codec, 0xd, val | (1<<14)); 6235 6236 val = alc_read_coef_idx(codec, 0x4); /* HP */ 6237 alc_write_coef_idx(codec, 0x4, val | (1<<11)); 6238 } 6239 6240 /* 6241 */ 6242 static int patch_alc269(struct hda_codec *codec) 6243 { 6244 struct alc_spec *spec; 6245 int err = 0; 6246 6247 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 6248 if (spec == NULL) 6249 return -ENOMEM; 6250 6251 codec->spec = spec; 6252 6253 spec->mixer_nid = 0x0b; 6254 6255 err = alc_codec_rename_from_preset(codec); 6256 if (err < 0) 6257 goto error; 6258 6259 if (codec->vendor_id == 0x10ec0269) { 6260 spec->codec_variant = ALC269_TYPE_ALC269VA; 6261 switch (alc_get_coef0(codec) & 0x00f0) { 6262 case 0x0010: 6263 if (codec->bus->pci->subsystem_vendor == 0x1025 && 6264 spec->cdefine.platform_type == 1) 6265 err = alc_codec_rename(codec, "ALC271X"); 6266 spec->codec_variant = ALC269_TYPE_ALC269VB; 6267 break; 6268 case 0x0020: 6269 if (codec->bus->pci->subsystem_vendor == 0x17aa && 6270 codec->bus->pci->subsystem_device == 0x21f3) 6271 err = alc_codec_rename(codec, "ALC3202"); 6272 spec->codec_variant = ALC269_TYPE_ALC269VC; 6273 break; 6274 default: 6275 alc_fix_pll_init(codec, 0x20, 0x04, 15); 6276 } 6277 if (err < 0) 6278 goto error; 6279 spec->init_hook = alc269_fill_coef; 6280 alc269_fill_coef(codec); 6281 } 6282 6283 alc_pick_fixup(codec, alc269_fixup_models, 6284 alc269_fixup_tbl, alc269_fixups); 6285 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE); 6286 6287 alc_auto_parse_customize_define(codec); 6288 6289 /* automatic parse from the BIOS config */ 6290 err = alc269_parse_auto_config(codec); 6291 if (err < 0) 6292 goto error; 6293 6294 if (!spec->no_analog && has_cdefine_beep(codec)) { 6295 err = snd_hda_attach_beep_device(codec, 0x1); 6296 if (err < 0) 6297 goto error; 6298 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT); 6299 } 6300 6301 codec->patch_ops = alc_patch_ops; 6302 #ifdef CONFIG_PM 6303 codec->patch_ops.resume = alc269_resume; 6304 #endif 6305 spec->shutup = alc269_shutup; 6306 6307 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE); 6308 6309 return 0; 6310 6311 error: 6312 alc_free(codec); 6313 return err; 6314 } 6315 6316 /* 6317 * ALC861 6318 */ 6319 6320 static int alc861_parse_auto_config(struct hda_codec *codec) 6321 { 6322 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 }; 6323 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 }; 6324 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids); 6325 } 6326 6327 /* Pin config fixes */ 6328 enum { 6329 ALC861_FIXUP_FSC_AMILO_PI1505, 6330 ALC861_FIXUP_AMP_VREF_0F, 6331 ALC861_FIXUP_NO_JACK_DETECT, 6332 ALC861_FIXUP_ASUS_A6RP, 6333 }; 6334 6335 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */ 6336 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec, 6337 const struct alc_fixup *fix, int action) 6338 { 6339 struct alc_spec *spec = codec->spec; 6340 unsigned int val; 6341 6342 if (action != ALC_FIXUP_ACT_INIT) 6343 return; 6344 val = snd_hda_codec_read(codec, 0x0f, 0, 6345 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 6346 if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))) 6347 val |= AC_PINCTL_IN_EN; 6348 val |= AC_PINCTL_VREF_50; 6349 snd_hda_codec_write(codec, 0x0f, 0, 6350 AC_VERB_SET_PIN_WIDGET_CONTROL, val); 6351 spec->keep_vref_in_automute = 1; 6352 } 6353 6354 /* suppress the jack-detection */ 6355 static void alc_fixup_no_jack_detect(struct hda_codec *codec, 6356 const struct alc_fixup *fix, int action) 6357 { 6358 if (action == ALC_FIXUP_ACT_PRE_PROBE) 6359 codec->no_jack_detect = 1; 6360 } 6361 6362 static const struct alc_fixup alc861_fixups[] = { 6363 [ALC861_FIXUP_FSC_AMILO_PI1505] = { 6364 .type = ALC_FIXUP_PINS, 6365 .v.pins = (const struct alc_pincfg[]) { 6366 { 0x0b, 0x0221101f }, /* HP */ 6367 { 0x0f, 0x90170310 }, /* speaker */ 6368 { } 6369 } 6370 }, 6371 [ALC861_FIXUP_AMP_VREF_0F] = { 6372 .type = ALC_FIXUP_FUNC, 6373 .v.func = alc861_fixup_asus_amp_vref_0f, 6374 }, 6375 [ALC861_FIXUP_NO_JACK_DETECT] = { 6376 .type = ALC_FIXUP_FUNC, 6377 .v.func = alc_fixup_no_jack_detect, 6378 }, 6379 [ALC861_FIXUP_ASUS_A6RP] = { 6380 .type = ALC_FIXUP_FUNC, 6381 .v.func = alc861_fixup_asus_amp_vref_0f, 6382 .chained = true, 6383 .chain_id = ALC861_FIXUP_NO_JACK_DETECT, 6384 } 6385 }; 6386 6387 static const struct snd_pci_quirk alc861_fixup_tbl[] = { 6388 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP), 6389 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F), 6390 SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT), 6391 SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F), 6392 SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F), 6393 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505), 6394 {} 6395 }; 6396 6397 /* 6398 */ 6399 static int patch_alc861(struct hda_codec *codec) 6400 { 6401 struct alc_spec *spec; 6402 int err; 6403 6404 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 6405 if (spec == NULL) 6406 return -ENOMEM; 6407 6408 codec->spec = spec; 6409 6410 spec->mixer_nid = 0x15; 6411 6412 alc_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups); 6413 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE); 6414 6415 /* automatic parse from the BIOS config */ 6416 err = alc861_parse_auto_config(codec); 6417 if (err < 0) 6418 goto error; 6419 6420 if (!spec->no_analog) { 6421 err = snd_hda_attach_beep_device(codec, 0x23); 6422 if (err < 0) 6423 goto error; 6424 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT); 6425 } 6426 6427 codec->patch_ops = alc_patch_ops; 6428 #ifdef CONFIG_SND_HDA_POWER_SAVE 6429 spec->power_hook = alc_power_eapd; 6430 #endif 6431 6432 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE); 6433 6434 return 0; 6435 6436 error: 6437 alc_free(codec); 6438 return err; 6439 } 6440 6441 /* 6442 * ALC861-VD support 6443 * 6444 * Based on ALC882 6445 * 6446 * In addition, an independent DAC 6447 */ 6448 static int alc861vd_parse_auto_config(struct hda_codec *codec) 6449 { 6450 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 }; 6451 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 6452 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids); 6453 } 6454 6455 enum { 6456 ALC660VD_FIX_ASUS_GPIO1, 6457 ALC861VD_FIX_DALLAS, 6458 }; 6459 6460 /* exclude VREF80 */ 6461 static void alc861vd_fixup_dallas(struct hda_codec *codec, 6462 const struct alc_fixup *fix, int action) 6463 { 6464 if (action == ALC_FIXUP_ACT_PRE_PROBE) { 6465 snd_hda_override_pin_caps(codec, 0x18, 0x00001714); 6466 snd_hda_override_pin_caps(codec, 0x19, 0x0000171c); 6467 } 6468 } 6469 6470 static const struct alc_fixup alc861vd_fixups[] = { 6471 [ALC660VD_FIX_ASUS_GPIO1] = { 6472 .type = ALC_FIXUP_VERBS, 6473 .v.verbs = (const struct hda_verb[]) { 6474 /* reset GPIO1 */ 6475 {0x01, AC_VERB_SET_GPIO_MASK, 0x03}, 6476 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, 6477 {0x01, AC_VERB_SET_GPIO_DATA, 0x01}, 6478 { } 6479 } 6480 }, 6481 [ALC861VD_FIX_DALLAS] = { 6482 .type = ALC_FIXUP_FUNC, 6483 .v.func = alc861vd_fixup_dallas, 6484 }, 6485 }; 6486 6487 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = { 6488 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS), 6489 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1), 6490 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS), 6491 {} 6492 }; 6493 6494 static const struct hda_verb alc660vd_eapd_verbs[] = { 6495 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 6496 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 6497 { } 6498 }; 6499 6500 /* 6501 */ 6502 static int patch_alc861vd(struct hda_codec *codec) 6503 { 6504 struct alc_spec *spec; 6505 int err; 6506 6507 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 6508 if (spec == NULL) 6509 return -ENOMEM; 6510 6511 codec->spec = spec; 6512 6513 spec->mixer_nid = 0x0b; 6514 6515 alc_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups); 6516 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE); 6517 6518 /* automatic parse from the BIOS config */ 6519 err = alc861vd_parse_auto_config(codec); 6520 if (err < 0) 6521 goto error; 6522 6523 if (codec->vendor_id == 0x10ec0660) { 6524 /* always turn on EAPD */ 6525 add_verb(spec, alc660vd_eapd_verbs); 6526 } 6527 6528 if (!spec->no_analog) { 6529 err = snd_hda_attach_beep_device(codec, 0x23); 6530 if (err < 0) 6531 goto error; 6532 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 6533 } 6534 6535 codec->patch_ops = alc_patch_ops; 6536 6537 spec->shutup = alc_eapd_shutup; 6538 6539 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE); 6540 6541 return 0; 6542 6543 error: 6544 alc_free(codec); 6545 return err; 6546 } 6547 6548 /* 6549 * ALC662 support 6550 * 6551 * ALC662 is almost identical with ALC880 but has cleaner and more flexible 6552 * configuration. Each pin widget can choose any input DACs and a mixer. 6553 * Each ADC is connected from a mixer of all inputs. This makes possible 6554 * 6-channel independent captures. 6555 * 6556 * In addition, an independent DAC for the multi-playback (not used in this 6557 * driver yet). 6558 */ 6559 6560 /* 6561 * BIOS auto configuration 6562 */ 6563 6564 static int alc662_parse_auto_config(struct hda_codec *codec) 6565 { 6566 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 }; 6567 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 }; 6568 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 6569 const hda_nid_t *ssids; 6570 6571 if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 || 6572 codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670) 6573 ssids = alc663_ssids; 6574 else 6575 ssids = alc662_ssids; 6576 return alc_parse_auto_config(codec, alc662_ignore, ssids); 6577 } 6578 6579 static void alc272_fixup_mario(struct hda_codec *codec, 6580 const struct alc_fixup *fix, int action) 6581 { 6582 if (action != ALC_FIXUP_ACT_PROBE) 6583 return; 6584 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT, 6585 (0x3b << AC_AMPCAP_OFFSET_SHIFT) | 6586 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) | 6587 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) | 6588 (0 << AC_AMPCAP_MUTE_SHIFT))) 6589 printk(KERN_WARNING 6590 "hda_codec: failed to override amp caps for NID 0x2\n"); 6591 } 6592 6593 enum { 6594 ALC662_FIXUP_ASPIRE, 6595 ALC662_FIXUP_IDEAPAD, 6596 ALC272_FIXUP_MARIO, 6597 ALC662_FIXUP_CZC_P10T, 6598 ALC662_FIXUP_SKU_IGNORE, 6599 ALC662_FIXUP_HP_RP5800, 6600 ALC662_FIXUP_ASUS_MODE1, 6601 ALC662_FIXUP_ASUS_MODE2, 6602 ALC662_FIXUP_ASUS_MODE3, 6603 ALC662_FIXUP_ASUS_MODE4, 6604 ALC662_FIXUP_ASUS_MODE5, 6605 ALC662_FIXUP_ASUS_MODE6, 6606 ALC662_FIXUP_ASUS_MODE7, 6607 ALC662_FIXUP_ASUS_MODE8, 6608 ALC662_FIXUP_NO_JACK_DETECT, 6609 }; 6610 6611 static const struct alc_fixup alc662_fixups[] = { 6612 [ALC662_FIXUP_ASPIRE] = { 6613 .type = ALC_FIXUP_PINS, 6614 .v.pins = (const struct alc_pincfg[]) { 6615 { 0x15, 0x99130112 }, /* subwoofer */ 6616 { } 6617 } 6618 }, 6619 [ALC662_FIXUP_IDEAPAD] = { 6620 .type = ALC_FIXUP_PINS, 6621 .v.pins = (const struct alc_pincfg[]) { 6622 { 0x17, 0x99130112 }, /* subwoofer */ 6623 { } 6624 } 6625 }, 6626 [ALC272_FIXUP_MARIO] = { 6627 .type = ALC_FIXUP_FUNC, 6628 .v.func = alc272_fixup_mario, 6629 }, 6630 [ALC662_FIXUP_CZC_P10T] = { 6631 .type = ALC_FIXUP_VERBS, 6632 .v.verbs = (const struct hda_verb[]) { 6633 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0}, 6634 {} 6635 } 6636 }, 6637 [ALC662_FIXUP_SKU_IGNORE] = { 6638 .type = ALC_FIXUP_SKU, 6639 .v.sku = ALC_FIXUP_SKU_IGNORE, 6640 }, 6641 [ALC662_FIXUP_HP_RP5800] = { 6642 .type = ALC_FIXUP_PINS, 6643 .v.pins = (const struct alc_pincfg[]) { 6644 { 0x14, 0x0221201f }, /* HP out */ 6645 { } 6646 }, 6647 .chained = true, 6648 .chain_id = ALC662_FIXUP_SKU_IGNORE 6649 }, 6650 [ALC662_FIXUP_ASUS_MODE1] = { 6651 .type = ALC_FIXUP_PINS, 6652 .v.pins = (const struct alc_pincfg[]) { 6653 { 0x14, 0x99130110 }, /* speaker */ 6654 { 0x18, 0x01a19c20 }, /* mic */ 6655 { 0x19, 0x99a3092f }, /* int-mic */ 6656 { 0x21, 0x0121401f }, /* HP out */ 6657 { } 6658 }, 6659 .chained = true, 6660 .chain_id = ALC662_FIXUP_SKU_IGNORE 6661 }, 6662 [ALC662_FIXUP_ASUS_MODE2] = { 6663 .type = ALC_FIXUP_PINS, 6664 .v.pins = (const struct alc_pincfg[]) { 6665 { 0x14, 0x99130110 }, /* speaker */ 6666 { 0x18, 0x01a19820 }, /* mic */ 6667 { 0x19, 0x99a3092f }, /* int-mic */ 6668 { 0x1b, 0x0121401f }, /* HP out */ 6669 { } 6670 }, 6671 .chained = true, 6672 .chain_id = ALC662_FIXUP_SKU_IGNORE 6673 }, 6674 [ALC662_FIXUP_ASUS_MODE3] = { 6675 .type = ALC_FIXUP_PINS, 6676 .v.pins = (const struct alc_pincfg[]) { 6677 { 0x14, 0x99130110 }, /* speaker */ 6678 { 0x15, 0x0121441f }, /* HP */ 6679 { 0x18, 0x01a19840 }, /* mic */ 6680 { 0x19, 0x99a3094f }, /* int-mic */ 6681 { 0x21, 0x01211420 }, /* HP2 */ 6682 { } 6683 }, 6684 .chained = true, 6685 .chain_id = ALC662_FIXUP_SKU_IGNORE 6686 }, 6687 [ALC662_FIXUP_ASUS_MODE4] = { 6688 .type = ALC_FIXUP_PINS, 6689 .v.pins = (const struct alc_pincfg[]) { 6690 { 0x14, 0x99130110 }, /* speaker */ 6691 { 0x16, 0x99130111 }, /* speaker */ 6692 { 0x18, 0x01a19840 }, /* mic */ 6693 { 0x19, 0x99a3094f }, /* int-mic */ 6694 { 0x21, 0x0121441f }, /* HP */ 6695 { } 6696 }, 6697 .chained = true, 6698 .chain_id = ALC662_FIXUP_SKU_IGNORE 6699 }, 6700 [ALC662_FIXUP_ASUS_MODE5] = { 6701 .type = ALC_FIXUP_PINS, 6702 .v.pins = (const struct alc_pincfg[]) { 6703 { 0x14, 0x99130110 }, /* speaker */ 6704 { 0x15, 0x0121441f }, /* HP */ 6705 { 0x16, 0x99130111 }, /* speaker */ 6706 { 0x18, 0x01a19840 }, /* mic */ 6707 { 0x19, 0x99a3094f }, /* int-mic */ 6708 { } 6709 }, 6710 .chained = true, 6711 .chain_id = ALC662_FIXUP_SKU_IGNORE 6712 }, 6713 [ALC662_FIXUP_ASUS_MODE6] = { 6714 .type = ALC_FIXUP_PINS, 6715 .v.pins = (const struct alc_pincfg[]) { 6716 { 0x14, 0x99130110 }, /* speaker */ 6717 { 0x15, 0x01211420 }, /* HP2 */ 6718 { 0x18, 0x01a19840 }, /* mic */ 6719 { 0x19, 0x99a3094f }, /* int-mic */ 6720 { 0x1b, 0x0121441f }, /* HP */ 6721 { } 6722 }, 6723 .chained = true, 6724 .chain_id = ALC662_FIXUP_SKU_IGNORE 6725 }, 6726 [ALC662_FIXUP_ASUS_MODE7] = { 6727 .type = ALC_FIXUP_PINS, 6728 .v.pins = (const struct alc_pincfg[]) { 6729 { 0x14, 0x99130110 }, /* speaker */ 6730 { 0x17, 0x99130111 }, /* speaker */ 6731 { 0x18, 0x01a19840 }, /* mic */ 6732 { 0x19, 0x99a3094f }, /* int-mic */ 6733 { 0x1b, 0x01214020 }, /* HP */ 6734 { 0x21, 0x0121401f }, /* HP */ 6735 { } 6736 }, 6737 .chained = true, 6738 .chain_id = ALC662_FIXUP_SKU_IGNORE 6739 }, 6740 [ALC662_FIXUP_ASUS_MODE8] = { 6741 .type = ALC_FIXUP_PINS, 6742 .v.pins = (const struct alc_pincfg[]) { 6743 { 0x14, 0x99130110 }, /* speaker */ 6744 { 0x12, 0x99a30970 }, /* int-mic */ 6745 { 0x15, 0x01214020 }, /* HP */ 6746 { 0x17, 0x99130111 }, /* speaker */ 6747 { 0x18, 0x01a19840 }, /* mic */ 6748 { 0x21, 0x0121401f }, /* HP */ 6749 { } 6750 }, 6751 .chained = true, 6752 .chain_id = ALC662_FIXUP_SKU_IGNORE 6753 }, 6754 [ALC662_FIXUP_NO_JACK_DETECT] = { 6755 .type = ALC_FIXUP_FUNC, 6756 .v.func = alc_fixup_no_jack_detect, 6757 }, 6758 }; 6759 6760 static const struct snd_pci_quirk alc662_fixup_tbl[] = { 6761 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2), 6762 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE), 6763 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE), 6764 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE), 6765 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800), 6766 SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT), 6767 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2), 6768 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD), 6769 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD), 6770 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD), 6771 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T), 6772 6773 #if 0 6774 /* Below is a quirk table taken from the old code. 6775 * Basically the device should work as is without the fixup table. 6776 * If BIOS doesn't give a proper info, enable the corresponding 6777 * fixup entry. 6778 */ 6779 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1), 6780 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3), 6781 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1), 6782 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3), 6783 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 6784 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 6785 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 6786 SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1), 6787 SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1), 6788 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 6789 SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7), 6790 SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7), 6791 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8), 6792 SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3), 6793 SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1), 6794 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 6795 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2), 6796 SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1), 6797 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 6798 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6), 6799 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6), 6800 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 6801 SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1), 6802 SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3), 6803 SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2), 6804 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 6805 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5), 6806 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6), 6807 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 6808 SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1), 6809 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 6810 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 6811 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3), 6812 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3), 6813 SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1), 6814 SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1), 6815 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1), 6816 SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1), 6817 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1), 6818 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2), 6819 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2), 6820 SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1), 6821 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 6822 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3), 6823 SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1), 6824 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1), 6825 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1), 6826 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2), 6827 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1), 6828 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4), 6829 #endif 6830 {} 6831 }; 6832 6833 static const struct alc_model_fixup alc662_fixup_models[] = { 6834 {.id = ALC272_FIXUP_MARIO, .name = "mario"}, 6835 {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"}, 6836 {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"}, 6837 {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"}, 6838 {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"}, 6839 {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"}, 6840 {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"}, 6841 {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"}, 6842 {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"}, 6843 {} 6844 }; 6845 6846 6847 /* 6848 */ 6849 static int patch_alc662(struct hda_codec *codec) 6850 { 6851 struct alc_spec *spec; 6852 int err = 0; 6853 6854 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 6855 if (!spec) 6856 return -ENOMEM; 6857 6858 codec->spec = spec; 6859 6860 spec->mixer_nid = 0x0b; 6861 6862 /* handle multiple HPs as is */ 6863 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP; 6864 6865 alc_fix_pll_init(codec, 0x20, 0x04, 15); 6866 6867 err = alc_codec_rename_from_preset(codec); 6868 if (err < 0) 6869 goto error; 6870 6871 if ((alc_get_coef0(codec) & (1 << 14)) && 6872 codec->bus->pci->subsystem_vendor == 0x1025 && 6873 spec->cdefine.platform_type == 1) { 6874 if (alc_codec_rename(codec, "ALC272X") < 0) 6875 goto error; 6876 } 6877 6878 alc_pick_fixup(codec, alc662_fixup_models, 6879 alc662_fixup_tbl, alc662_fixups); 6880 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE); 6881 6882 alc_auto_parse_customize_define(codec); 6883 6884 /* automatic parse from the BIOS config */ 6885 err = alc662_parse_auto_config(codec); 6886 if (err < 0) 6887 goto error; 6888 6889 if (!spec->no_analog && has_cdefine_beep(codec)) { 6890 err = snd_hda_attach_beep_device(codec, 0x1); 6891 if (err < 0) 6892 goto error; 6893 switch (codec->vendor_id) { 6894 case 0x10ec0662: 6895 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 6896 break; 6897 case 0x10ec0272: 6898 case 0x10ec0663: 6899 case 0x10ec0665: 6900 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT); 6901 break; 6902 case 0x10ec0273: 6903 set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT); 6904 break; 6905 } 6906 } 6907 6908 codec->patch_ops = alc_patch_ops; 6909 spec->shutup = alc_eapd_shutup; 6910 6911 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE); 6912 6913 return 0; 6914 6915 error: 6916 alc_free(codec); 6917 return err; 6918 } 6919 6920 /* 6921 * ALC680 support 6922 */ 6923 6924 static int alc680_parse_auto_config(struct hda_codec *codec) 6925 { 6926 return alc_parse_auto_config(codec, NULL, NULL); 6927 } 6928 6929 /* 6930 */ 6931 static int patch_alc680(struct hda_codec *codec) 6932 { 6933 struct alc_spec *spec; 6934 int err; 6935 6936 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 6937 if (spec == NULL) 6938 return -ENOMEM; 6939 6940 codec->spec = spec; 6941 6942 /* ALC680 has no aa-loopback mixer */ 6943 6944 /* automatic parse from the BIOS config */ 6945 err = alc680_parse_auto_config(codec); 6946 if (err < 0) { 6947 alc_free(codec); 6948 return err; 6949 } 6950 6951 codec->patch_ops = alc_patch_ops; 6952 6953 return 0; 6954 } 6955 6956 /* 6957 * patch entries 6958 */ 6959 static const struct hda_codec_preset snd_hda_preset_realtek[] = { 6960 { .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 }, 6961 { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 }, 6962 { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 }, 6963 { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 }, 6964 { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 }, 6965 { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 }, 6966 { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 }, 6967 { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 }, 6968 { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 }, 6969 { .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 }, 6970 { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660", 6971 .patch = patch_alc861 }, 6972 { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd }, 6973 { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 }, 6974 { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd }, 6975 { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2", 6976 .patch = patch_alc882 }, 6977 { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1", 6978 .patch = patch_alc662 }, 6979 { .id = 0x10ec0662, .rev = 0x100300, .name = "ALC662 rev3", 6980 .patch = patch_alc662 }, 6981 { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 }, 6982 { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 }, 6983 { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 }, 6984 { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 }, 6985 { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 }, 6986 { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 }, 6987 { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 }, 6988 { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A", 6989 .patch = patch_alc882 }, 6990 { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A", 6991 .patch = patch_alc882 }, 6992 { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 }, 6993 { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 }, 6994 { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200", 6995 .patch = patch_alc882 }, 6996 { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 }, 6997 { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 }, 6998 { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 }, 6999 { .id = 0x10ec0899, .name = "ALC898", .patch = patch_alc882 }, 7000 {} /* terminator */ 7001 }; 7002 7003 MODULE_ALIAS("snd-hda-codec-id:10ec*"); 7004 7005 MODULE_LICENSE("GPL"); 7006 MODULE_DESCRIPTION("Realtek HD-audio codec"); 7007 7008 static struct hda_codec_preset_list realtek_list = { 7009 .preset = snd_hda_preset_realtek, 7010 .owner = THIS_MODULE, 7011 }; 7012 7013 static int __init patch_realtek_init(void) 7014 { 7015 return snd_hda_add_codec_preset(&realtek_list); 7016 } 7017 7018 static void __exit patch_realtek_exit(void) 7019 { 7020 snd_hda_delete_codec_preset(&realtek_list); 7021 } 7022 7023 module_init(patch_realtek_init) 7024 module_exit(patch_realtek_exit) 7025