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 <sound/core.h> 31 #include <sound/jack.h> 32 #include "hda_codec.h" 33 #include "hda_local.h" 34 #include "hda_beep.h" 35 36 /* unsol event tags */ 37 #define ALC_FRONT_EVENT 0x01 38 #define ALC_DCVOL_EVENT 0x02 39 #define ALC_HP_EVENT 0x04 40 #define ALC_MIC_EVENT 0x08 41 42 /* for GPIO Poll */ 43 #define GPIO_MASK 0x03 44 45 /* extra amp-initialization sequence types */ 46 enum { 47 ALC_INIT_NONE, 48 ALC_INIT_DEFAULT, 49 ALC_INIT_GPIO1, 50 ALC_INIT_GPIO2, 51 ALC_INIT_GPIO3, 52 }; 53 54 struct alc_customize_define { 55 unsigned int sku_cfg; 56 unsigned char port_connectivity; 57 unsigned char check_sum; 58 unsigned char customization; 59 unsigned char external_amp; 60 unsigned int enable_pcbeep:1; 61 unsigned int platform_type:1; 62 unsigned int swap:1; 63 unsigned int override:1; 64 unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */ 65 }; 66 67 struct alc_fixup; 68 69 struct alc_multi_io { 70 hda_nid_t pin; /* multi-io widget pin NID */ 71 hda_nid_t dac; /* DAC to be connected */ 72 unsigned int ctl_in; /* cached input-pin control value */ 73 }; 74 75 enum { 76 ALC_AUTOMUTE_PIN, /* change the pin control */ 77 ALC_AUTOMUTE_AMP, /* mute/unmute the pin AMP */ 78 ALC_AUTOMUTE_MIXER, /* mute/unmute mixer widget AMP */ 79 }; 80 81 struct alc_spec { 82 /* codec parameterization */ 83 const struct snd_kcontrol_new *mixers[5]; /* mixer arrays */ 84 unsigned int num_mixers; 85 const struct snd_kcontrol_new *cap_mixer; /* capture mixer */ 86 unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */ 87 88 const struct hda_verb *init_verbs[10]; /* initialization verbs 89 * don't forget NULL 90 * termination! 91 */ 92 unsigned int num_init_verbs; 93 94 char stream_name_analog[32]; /* analog PCM stream */ 95 const struct hda_pcm_stream *stream_analog_playback; 96 const struct hda_pcm_stream *stream_analog_capture; 97 const struct hda_pcm_stream *stream_analog_alt_playback; 98 const struct hda_pcm_stream *stream_analog_alt_capture; 99 100 char stream_name_digital[32]; /* digital PCM stream */ 101 const struct hda_pcm_stream *stream_digital_playback; 102 const struct hda_pcm_stream *stream_digital_capture; 103 104 /* playback */ 105 struct hda_multi_out multiout; /* playback set-up 106 * max_channels, dacs must be set 107 * dig_out_nid and hp_nid are optional 108 */ 109 hda_nid_t alt_dac_nid; 110 hda_nid_t slave_dig_outs[3]; /* optional - for auto-parsing */ 111 int dig_out_type; 112 113 /* capture */ 114 unsigned int num_adc_nids; 115 const hda_nid_t *adc_nids; 116 const hda_nid_t *capsrc_nids; 117 hda_nid_t dig_in_nid; /* digital-in NID; optional */ 118 hda_nid_t mixer_nid; /* analog-mixer NID */ 119 120 /* capture setup for dynamic dual-adc switch */ 121 hda_nid_t cur_adc; 122 unsigned int cur_adc_stream_tag; 123 unsigned int cur_adc_format; 124 125 /* capture source */ 126 unsigned int num_mux_defs; 127 const struct hda_input_mux *input_mux; 128 unsigned int cur_mux[3]; 129 hda_nid_t ext_mic_pin; 130 hda_nid_t dock_mic_pin; 131 hda_nid_t int_mic_pin; 132 133 /* channel model */ 134 const struct hda_channel_mode *channel_mode; 135 int num_channel_mode; 136 int need_dac_fix; 137 int const_channel_count; 138 int ext_channel_count; 139 140 /* PCM information */ 141 struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */ 142 143 /* dynamic controls, init_verbs and input_mux */ 144 struct auto_pin_cfg autocfg; 145 struct alc_customize_define cdefine; 146 struct snd_array kctls; 147 struct hda_input_mux private_imux[3]; 148 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS]; 149 hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS]; 150 hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS]; 151 hda_nid_t imux_pins[HDA_MAX_NUM_INPUTS]; 152 unsigned int dyn_adc_idx[HDA_MAX_NUM_INPUTS]; 153 int int_mic_idx, ext_mic_idx, dock_mic_idx; /* for auto-mic */ 154 155 /* hooks */ 156 void (*init_hook)(struct hda_codec *codec); 157 void (*unsol_event)(struct hda_codec *codec, unsigned int res); 158 #ifdef CONFIG_SND_HDA_POWER_SAVE 159 void (*power_hook)(struct hda_codec *codec); 160 #endif 161 void (*shutup)(struct hda_codec *codec); 162 163 /* for pin sensing */ 164 unsigned int jack_present: 1; 165 unsigned int line_jack_present:1; 166 unsigned int master_mute:1; 167 unsigned int auto_mic:1; 168 unsigned int auto_mic_valid_imux:1; /* valid imux for auto-mic */ 169 unsigned int automute:1; /* HP automute enabled */ 170 unsigned int detect_line:1; /* Line-out detection enabled */ 171 unsigned int automute_lines:1; /* automute line-out as well */ 172 unsigned int automute_hp_lo:1; /* both HP and LO available */ 173 174 /* other flags */ 175 unsigned int no_analog :1; /* digital I/O only */ 176 unsigned int dyn_adc_switch:1; /* switch ADCs (for ALC275) */ 177 unsigned int single_input_src:1; 178 unsigned int vol_in_capsrc:1; /* use capsrc volume (ADC has no vol) */ 179 180 /* auto-mute control */ 181 int automute_mode; 182 hda_nid_t automute_mixer_nid[AUTO_CFG_MAX_OUTS]; 183 184 int init_amp; 185 int codec_variant; /* flag for other variants */ 186 187 /* for virtual master */ 188 hda_nid_t vmaster_nid; 189 #ifdef CONFIG_SND_HDA_POWER_SAVE 190 struct hda_loopback_check loopback; 191 #endif 192 193 /* for PLL fix */ 194 hda_nid_t pll_nid; 195 unsigned int pll_coef_idx, pll_coef_bit; 196 197 /* fix-up list */ 198 int fixup_id; 199 const struct alc_fixup *fixup_list; 200 const char *fixup_name; 201 202 /* multi-io */ 203 int multi_ios; 204 struct alc_multi_io multi_io[4]; 205 }; 206 207 #define ALC_MODEL_AUTO 0 /* common for all chips */ 208 209 static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid, 210 int dir, unsigned int bits) 211 { 212 if (!nid) 213 return false; 214 if (get_wcaps(codec, nid) & (1 << (dir + 1))) 215 if (query_amp_caps(codec, nid, dir) & bits) 216 return true; 217 return false; 218 } 219 220 #define nid_has_mute(codec, nid, dir) \ 221 check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE) 222 #define nid_has_volume(codec, nid, dir) \ 223 check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS) 224 225 /* 226 * input MUX handling 227 */ 228 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol, 229 struct snd_ctl_elem_info *uinfo) 230 { 231 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 232 struct alc_spec *spec = codec->spec; 233 unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id); 234 if (mux_idx >= spec->num_mux_defs) 235 mux_idx = 0; 236 if (!spec->input_mux[mux_idx].num_items && mux_idx > 0) 237 mux_idx = 0; 238 return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo); 239 } 240 241 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol, 242 struct snd_ctl_elem_value *ucontrol) 243 { 244 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 245 struct alc_spec *spec = codec->spec; 246 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 247 248 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx]; 249 return 0; 250 } 251 252 static bool alc_dyn_adc_pcm_resetup(struct hda_codec *codec, int cur) 253 { 254 struct alc_spec *spec = codec->spec; 255 hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]]; 256 257 if (spec->cur_adc && spec->cur_adc != new_adc) { 258 /* stream is running, let's swap the current ADC */ 259 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1); 260 spec->cur_adc = new_adc; 261 snd_hda_codec_setup_stream(codec, new_adc, 262 spec->cur_adc_stream_tag, 0, 263 spec->cur_adc_format); 264 return true; 265 } 266 return false; 267 } 268 269 /* select the given imux item; either unmute exclusively or select the route */ 270 static int alc_mux_select(struct hda_codec *codec, unsigned int adc_idx, 271 unsigned int idx, bool force) 272 { 273 struct alc_spec *spec = codec->spec; 274 const struct hda_input_mux *imux; 275 unsigned int mux_idx; 276 int i, type; 277 hda_nid_t nid; 278 279 mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx; 280 imux = &spec->input_mux[mux_idx]; 281 if (!imux->num_items && mux_idx > 0) 282 imux = &spec->input_mux[0]; 283 284 if (idx >= imux->num_items) 285 idx = imux->num_items - 1; 286 if (spec->cur_mux[adc_idx] == idx && !force) 287 return 0; 288 spec->cur_mux[adc_idx] = idx; 289 290 if (spec->dyn_adc_switch) { 291 alc_dyn_adc_pcm_resetup(codec, idx); 292 adc_idx = spec->dyn_adc_idx[idx]; 293 } 294 295 nid = spec->capsrc_nids ? 296 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx]; 297 298 /* no selection? */ 299 if (snd_hda_get_conn_list(codec, nid, NULL) <= 1) 300 return 1; 301 302 type = get_wcaps_type(get_wcaps(codec, nid)); 303 if (type == AC_WID_AUD_MIX) { 304 /* Matrix-mixer style (e.g. ALC882) */ 305 for (i = 0; i < imux->num_items; i++) { 306 unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE; 307 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 308 imux->items[i].index, 309 HDA_AMP_MUTE, v); 310 } 311 } else { 312 /* MUX style (e.g. ALC880) */ 313 snd_hda_codec_write_cache(codec, nid, 0, 314 AC_VERB_SET_CONNECT_SEL, 315 imux->items[idx].index); 316 } 317 return 1; 318 } 319 320 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol, 321 struct snd_ctl_elem_value *ucontrol) 322 { 323 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 324 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 325 return alc_mux_select(codec, adc_idx, 326 ucontrol->value.enumerated.item[0], false); 327 } 328 329 /* 330 * set up the input pin config (depending on the given auto-pin type) 331 */ 332 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid, 333 int auto_pin_type) 334 { 335 unsigned int val = PIN_IN; 336 337 if (auto_pin_type == AUTO_PIN_MIC) { 338 unsigned int pincap; 339 unsigned int oldval; 340 oldval = snd_hda_codec_read(codec, nid, 0, 341 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 342 pincap = snd_hda_query_pin_caps(codec, nid); 343 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT; 344 /* if the default pin setup is vref50, we give it priority */ 345 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50) 346 val = PIN_VREF80; 347 else if (pincap & AC_PINCAP_VREF_50) 348 val = PIN_VREF50; 349 else if (pincap & AC_PINCAP_VREF_100) 350 val = PIN_VREF100; 351 else if (pincap & AC_PINCAP_VREF_GRD) 352 val = PIN_VREFGRD; 353 } 354 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val); 355 } 356 357 /* 358 * Append the given mixer and verb elements for the later use 359 * The mixer array is referred in build_controls(), and init_verbs are 360 * called in init(). 361 */ 362 static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix) 363 { 364 if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers))) 365 return; 366 spec->mixers[spec->num_mixers++] = mix; 367 } 368 369 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb) 370 { 371 if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs))) 372 return; 373 spec->init_verbs[spec->num_init_verbs++] = verb; 374 } 375 376 /* 377 * GPIO setup tables, used in initialization 378 */ 379 /* Enable GPIO mask and set output */ 380 static const struct hda_verb alc_gpio1_init_verbs[] = { 381 {0x01, AC_VERB_SET_GPIO_MASK, 0x01}, 382 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, 383 {0x01, AC_VERB_SET_GPIO_DATA, 0x01}, 384 { } 385 }; 386 387 static const struct hda_verb alc_gpio2_init_verbs[] = { 388 {0x01, AC_VERB_SET_GPIO_MASK, 0x02}, 389 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02}, 390 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, 391 { } 392 }; 393 394 static const struct hda_verb alc_gpio3_init_verbs[] = { 395 {0x01, AC_VERB_SET_GPIO_MASK, 0x03}, 396 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03}, 397 {0x01, AC_VERB_SET_GPIO_DATA, 0x03}, 398 { } 399 }; 400 401 /* 402 * Fix hardware PLL issue 403 * On some codecs, the analog PLL gating control must be off while 404 * the default value is 1. 405 */ 406 static void alc_fix_pll(struct hda_codec *codec) 407 { 408 struct alc_spec *spec = codec->spec; 409 unsigned int val; 410 411 if (!spec->pll_nid) 412 return; 413 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX, 414 spec->pll_coef_idx); 415 val = snd_hda_codec_read(codec, spec->pll_nid, 0, 416 AC_VERB_GET_PROC_COEF, 0); 417 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX, 418 spec->pll_coef_idx); 419 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF, 420 val & ~(1 << spec->pll_coef_bit)); 421 } 422 423 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid, 424 unsigned int coef_idx, unsigned int coef_bit) 425 { 426 struct alc_spec *spec = codec->spec; 427 spec->pll_nid = nid; 428 spec->pll_coef_idx = coef_idx; 429 spec->pll_coef_bit = coef_bit; 430 alc_fix_pll(codec); 431 } 432 433 /* 434 * Jack-reporting via input-jack layer 435 */ 436 437 /* initialization of jacks; currently checks only a few known pins */ 438 static int alc_init_jacks(struct hda_codec *codec) 439 { 440 #ifdef CONFIG_SND_HDA_INPUT_JACK 441 struct alc_spec *spec = codec->spec; 442 int err; 443 unsigned int hp_nid = spec->autocfg.hp_pins[0]; 444 unsigned int mic_nid = spec->ext_mic_pin; 445 unsigned int dock_nid = spec->dock_mic_pin; 446 447 if (hp_nid) { 448 err = snd_hda_input_jack_add(codec, hp_nid, 449 SND_JACK_HEADPHONE, NULL); 450 if (err < 0) 451 return err; 452 snd_hda_input_jack_report(codec, hp_nid); 453 } 454 455 if (mic_nid) { 456 err = snd_hda_input_jack_add(codec, mic_nid, 457 SND_JACK_MICROPHONE, NULL); 458 if (err < 0) 459 return err; 460 snd_hda_input_jack_report(codec, mic_nid); 461 } 462 if (dock_nid) { 463 err = snd_hda_input_jack_add(codec, dock_nid, 464 SND_JACK_MICROPHONE, NULL); 465 if (err < 0) 466 return err; 467 snd_hda_input_jack_report(codec, dock_nid); 468 } 469 #endif /* CONFIG_SND_HDA_INPUT_JACK */ 470 return 0; 471 } 472 473 /* 474 * Jack detections for HP auto-mute and mic-switch 475 */ 476 477 /* check each pin in the given array; returns true if any of them is plugged */ 478 static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins) 479 { 480 int i, present = 0; 481 482 for (i = 0; i < num_pins; i++) { 483 hda_nid_t nid = pins[i]; 484 if (!nid) 485 break; 486 snd_hda_input_jack_report(codec, nid); 487 present |= snd_hda_jack_detect(codec, nid); 488 } 489 return present; 490 } 491 492 /* standard HP/line-out auto-mute helper */ 493 static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins, 494 bool mute, bool hp_out) 495 { 496 struct alc_spec *spec = codec->spec; 497 unsigned int mute_bits = mute ? HDA_AMP_MUTE : 0; 498 unsigned int pin_bits = mute ? 0 : (hp_out ? PIN_HP : PIN_OUT); 499 int i; 500 501 for (i = 0; i < num_pins; i++) { 502 hda_nid_t nid = pins[i]; 503 if (!nid) 504 break; 505 switch (spec->automute_mode) { 506 case ALC_AUTOMUTE_PIN: 507 snd_hda_codec_write(codec, nid, 0, 508 AC_VERB_SET_PIN_WIDGET_CONTROL, 509 pin_bits); 510 break; 511 case ALC_AUTOMUTE_AMP: 512 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 513 HDA_AMP_MUTE, mute_bits); 514 break; 515 case ALC_AUTOMUTE_MIXER: 516 nid = spec->automute_mixer_nid[i]; 517 if (!nid) 518 break; 519 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0, 520 HDA_AMP_MUTE, mute_bits); 521 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 1, 522 HDA_AMP_MUTE, mute_bits); 523 break; 524 } 525 } 526 } 527 528 /* Toggle internal speakers muting */ 529 static void update_speakers(struct hda_codec *codec) 530 { 531 struct alc_spec *spec = codec->spec; 532 int on; 533 534 /* Control HP pins/amps depending on master_mute state; 535 * in general, HP pins/amps control should be enabled in all cases, 536 * but currently set only for master_mute, just to be safe 537 */ 538 do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins), 539 spec->autocfg.hp_pins, spec->master_mute, true); 540 541 if (!spec->automute) 542 on = 0; 543 else 544 on = spec->jack_present | spec->line_jack_present; 545 on |= spec->master_mute; 546 do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins), 547 spec->autocfg.speaker_pins, on, false); 548 549 /* toggle line-out mutes if needed, too */ 550 /* if LO is a copy of either HP or Speaker, don't need to handle it */ 551 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] || 552 spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0]) 553 return; 554 if (!spec->automute_lines || !spec->automute) 555 on = 0; 556 else 557 on = spec->jack_present; 558 on |= spec->master_mute; 559 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins), 560 spec->autocfg.line_out_pins, on, false); 561 } 562 563 /* standard HP-automute helper */ 564 static void alc_hp_automute(struct hda_codec *codec) 565 { 566 struct alc_spec *spec = codec->spec; 567 568 if (!spec->automute) 569 return; 570 spec->jack_present = 571 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.hp_pins), 572 spec->autocfg.hp_pins); 573 update_speakers(codec); 574 } 575 576 /* standard line-out-automute helper */ 577 static void alc_line_automute(struct hda_codec *codec) 578 { 579 struct alc_spec *spec = codec->spec; 580 581 if (!spec->automute || !spec->detect_line) 582 return; 583 spec->line_jack_present = 584 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins), 585 spec->autocfg.line_out_pins); 586 update_speakers(codec); 587 } 588 589 #define get_connection_index(codec, mux, nid) \ 590 snd_hda_get_conn_index(codec, mux, nid, 0) 591 592 /* standard mic auto-switch helper */ 593 static void alc_mic_automute(struct hda_codec *codec) 594 { 595 struct alc_spec *spec = codec->spec; 596 hda_nid_t *pins = spec->imux_pins; 597 598 if (!spec->auto_mic || !spec->auto_mic_valid_imux) 599 return; 600 if (snd_BUG_ON(!spec->adc_nids)) 601 return; 602 if (snd_BUG_ON(spec->int_mic_idx < 0 || spec->ext_mic_idx < 0)) 603 return; 604 605 if (snd_hda_jack_detect(codec, pins[spec->ext_mic_idx])) 606 alc_mux_select(codec, 0, spec->ext_mic_idx, false); 607 else if (spec->dock_mic_idx >= 0 && 608 snd_hda_jack_detect(codec, pins[spec->dock_mic_idx])) 609 alc_mux_select(codec, 0, spec->dock_mic_idx, false); 610 else 611 alc_mux_select(codec, 0, spec->int_mic_idx, false); 612 613 snd_hda_input_jack_report(codec, pins[spec->ext_mic_idx]); 614 if (spec->dock_mic_idx >= 0) 615 snd_hda_input_jack_report(codec, pins[spec->dock_mic_idx]); 616 } 617 618 /* unsolicited event for HP jack sensing */ 619 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res) 620 { 621 if (codec->vendor_id == 0x10ec0880) 622 res >>= 28; 623 else 624 res >>= 26; 625 switch (res) { 626 case ALC_HP_EVENT: 627 alc_hp_automute(codec); 628 break; 629 case ALC_FRONT_EVENT: 630 alc_line_automute(codec); 631 break; 632 case ALC_MIC_EVENT: 633 alc_mic_automute(codec); 634 break; 635 } 636 } 637 638 /* call init functions of standard auto-mute helpers */ 639 static void alc_inithook(struct hda_codec *codec) 640 { 641 alc_hp_automute(codec); 642 alc_line_automute(codec); 643 alc_mic_automute(codec); 644 } 645 646 /* additional initialization for ALC888 variants */ 647 static void alc888_coef_init(struct hda_codec *codec) 648 { 649 unsigned int tmp; 650 651 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0); 652 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0); 653 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7); 654 if ((tmp & 0xf0) == 0x20) 655 /* alc888S-VC */ 656 snd_hda_codec_read(codec, 0x20, 0, 657 AC_VERB_SET_PROC_COEF, 0x830); 658 else 659 /* alc888-VB */ 660 snd_hda_codec_read(codec, 0x20, 0, 661 AC_VERB_SET_PROC_COEF, 0x3030); 662 } 663 664 /* additional initialization for ALC889 variants */ 665 static void alc889_coef_init(struct hda_codec *codec) 666 { 667 unsigned int tmp; 668 669 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7); 670 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0); 671 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7); 672 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010); 673 } 674 675 /* turn on/off EAPD control (only if available) */ 676 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on) 677 { 678 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN) 679 return; 680 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD) 681 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE, 682 on ? 2 : 0); 683 } 684 685 /* turn on/off EAPD controls of the codec */ 686 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on) 687 { 688 /* We currently only handle front, HP */ 689 static hda_nid_t pins[] = { 690 0x0f, 0x10, 0x14, 0x15, 0 691 }; 692 hda_nid_t *p; 693 for (p = pins; *p; p++) 694 set_eapd(codec, *p, on); 695 } 696 697 /* generic shutup callback; 698 * just turning off EPAD and a little pause for avoiding pop-noise 699 */ 700 static void alc_eapd_shutup(struct hda_codec *codec) 701 { 702 alc_auto_setup_eapd(codec, false); 703 msleep(200); 704 } 705 706 /* generic EAPD initialization */ 707 static void alc_auto_init_amp(struct hda_codec *codec, int type) 708 { 709 unsigned int tmp; 710 711 alc_auto_setup_eapd(codec, true); 712 switch (type) { 713 case ALC_INIT_GPIO1: 714 snd_hda_sequence_write(codec, alc_gpio1_init_verbs); 715 break; 716 case ALC_INIT_GPIO2: 717 snd_hda_sequence_write(codec, alc_gpio2_init_verbs); 718 break; 719 case ALC_INIT_GPIO3: 720 snd_hda_sequence_write(codec, alc_gpio3_init_verbs); 721 break; 722 case ALC_INIT_DEFAULT: 723 switch (codec->vendor_id) { 724 case 0x10ec0260: 725 snd_hda_codec_write(codec, 0x1a, 0, 726 AC_VERB_SET_COEF_INDEX, 7); 727 tmp = snd_hda_codec_read(codec, 0x1a, 0, 728 AC_VERB_GET_PROC_COEF, 0); 729 snd_hda_codec_write(codec, 0x1a, 0, 730 AC_VERB_SET_COEF_INDEX, 7); 731 snd_hda_codec_write(codec, 0x1a, 0, 732 AC_VERB_SET_PROC_COEF, 733 tmp | 0x2010); 734 break; 735 case 0x10ec0262: 736 case 0x10ec0880: 737 case 0x10ec0882: 738 case 0x10ec0883: 739 case 0x10ec0885: 740 case 0x10ec0887: 741 /*case 0x10ec0889:*/ /* this causes an SPDIF problem */ 742 alc889_coef_init(codec); 743 break; 744 case 0x10ec0888: 745 alc888_coef_init(codec); 746 break; 747 #if 0 /* XXX: This may cause the silent output on speaker on some machines */ 748 case 0x10ec0267: 749 case 0x10ec0268: 750 snd_hda_codec_write(codec, 0x20, 0, 751 AC_VERB_SET_COEF_INDEX, 7); 752 tmp = snd_hda_codec_read(codec, 0x20, 0, 753 AC_VERB_GET_PROC_COEF, 0); 754 snd_hda_codec_write(codec, 0x20, 0, 755 AC_VERB_SET_COEF_INDEX, 7); 756 snd_hda_codec_write(codec, 0x20, 0, 757 AC_VERB_SET_PROC_COEF, 758 tmp | 0x3000); 759 break; 760 #endif /* XXX */ 761 } 762 break; 763 } 764 } 765 766 /* 767 * Auto-Mute mode mixer enum support 768 */ 769 static int alc_automute_mode_info(struct snd_kcontrol *kcontrol, 770 struct snd_ctl_elem_info *uinfo) 771 { 772 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 773 struct alc_spec *spec = codec->spec; 774 static const char * const texts2[] = { 775 "Disabled", "Enabled" 776 }; 777 static const char * const texts3[] = { 778 "Disabled", "Speaker Only", "Line-Out+Speaker" 779 }; 780 const char * const *texts; 781 782 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 783 uinfo->count = 1; 784 if (spec->automute_hp_lo) { 785 uinfo->value.enumerated.items = 3; 786 texts = texts3; 787 } else { 788 uinfo->value.enumerated.items = 2; 789 texts = texts2; 790 } 791 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items) 792 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1; 793 strcpy(uinfo->value.enumerated.name, 794 texts[uinfo->value.enumerated.item]); 795 return 0; 796 } 797 798 static int alc_automute_mode_get(struct snd_kcontrol *kcontrol, 799 struct snd_ctl_elem_value *ucontrol) 800 { 801 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 802 struct alc_spec *spec = codec->spec; 803 unsigned int val; 804 if (!spec->automute) 805 val = 0; 806 else if (!spec->automute_lines) 807 val = 1; 808 else 809 val = 2; 810 ucontrol->value.enumerated.item[0] = val; 811 return 0; 812 } 813 814 static int alc_automute_mode_put(struct snd_kcontrol *kcontrol, 815 struct snd_ctl_elem_value *ucontrol) 816 { 817 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 818 struct alc_spec *spec = codec->spec; 819 820 switch (ucontrol->value.enumerated.item[0]) { 821 case 0: 822 if (!spec->automute) 823 return 0; 824 spec->automute = 0; 825 break; 826 case 1: 827 if (spec->automute && !spec->automute_lines) 828 return 0; 829 spec->automute = 1; 830 spec->automute_lines = 0; 831 break; 832 case 2: 833 if (!spec->automute_hp_lo) 834 return -EINVAL; 835 if (spec->automute && spec->automute_lines) 836 return 0; 837 spec->automute = 1; 838 spec->automute_lines = 1; 839 break; 840 default: 841 return -EINVAL; 842 } 843 update_speakers(codec); 844 return 1; 845 } 846 847 static const struct snd_kcontrol_new alc_automute_mode_enum = { 848 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 849 .name = "Auto-Mute Mode", 850 .info = alc_automute_mode_info, 851 .get = alc_automute_mode_get, 852 .put = alc_automute_mode_put, 853 }; 854 855 static struct snd_kcontrol_new *alc_kcontrol_new(struct alc_spec *spec) 856 { 857 snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32); 858 return snd_array_new(&spec->kctls); 859 } 860 861 static int alc_add_automute_mode_enum(struct hda_codec *codec) 862 { 863 struct alc_spec *spec = codec->spec; 864 struct snd_kcontrol_new *knew; 865 866 knew = alc_kcontrol_new(spec); 867 if (!knew) 868 return -ENOMEM; 869 *knew = alc_automute_mode_enum; 870 knew->name = kstrdup("Auto-Mute Mode", GFP_KERNEL); 871 if (!knew->name) 872 return -ENOMEM; 873 return 0; 874 } 875 876 /* 877 * Check the availability of HP/line-out auto-mute; 878 * Set up appropriately if really supported 879 */ 880 static void alc_init_auto_hp(struct hda_codec *codec) 881 { 882 struct alc_spec *spec = codec->spec; 883 struct auto_pin_cfg *cfg = &spec->autocfg; 884 int present = 0; 885 int i; 886 887 if (cfg->hp_pins[0]) 888 present++; 889 if (cfg->line_out_pins[0]) 890 present++; 891 if (cfg->speaker_pins[0]) 892 present++; 893 if (present < 2) /* need two different output types */ 894 return; 895 if (present == 3) 896 spec->automute_hp_lo = 1; /* both HP and LO automute */ 897 898 if (!cfg->speaker_pins[0]) { 899 memcpy(cfg->speaker_pins, cfg->line_out_pins, 900 sizeof(cfg->speaker_pins)); 901 cfg->speaker_outs = cfg->line_outs; 902 } 903 904 if (!cfg->hp_pins[0]) { 905 memcpy(cfg->hp_pins, cfg->line_out_pins, 906 sizeof(cfg->hp_pins)); 907 cfg->hp_outs = cfg->line_outs; 908 } 909 910 for (i = 0; i < cfg->hp_outs; i++) { 911 hda_nid_t nid = cfg->hp_pins[i]; 912 if (!is_jack_detectable(codec, nid)) 913 continue; 914 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n", 915 nid); 916 snd_hda_codec_write_cache(codec, nid, 0, 917 AC_VERB_SET_UNSOLICITED_ENABLE, 918 AC_USRSP_EN | ALC_HP_EVENT); 919 spec->automute = 1; 920 spec->automute_mode = ALC_AUTOMUTE_PIN; 921 } 922 if (spec->automute && cfg->line_out_pins[0] && 923 cfg->line_out_pins[0] != cfg->hp_pins[0] && 924 cfg->line_out_pins[0] != cfg->speaker_pins[0]) { 925 for (i = 0; i < cfg->line_outs; i++) { 926 hda_nid_t nid = cfg->line_out_pins[i]; 927 if (!is_jack_detectable(codec, nid)) 928 continue; 929 snd_printdd("realtek: Enable Line-Out auto-muting " 930 "on NID 0x%x\n", nid); 931 snd_hda_codec_write_cache(codec, nid, 0, 932 AC_VERB_SET_UNSOLICITED_ENABLE, 933 AC_USRSP_EN | ALC_FRONT_EVENT); 934 spec->detect_line = 1; 935 } 936 spec->automute_lines = spec->detect_line; 937 } 938 939 if (spec->automute) { 940 /* create a control for automute mode */ 941 alc_add_automute_mode_enum(codec); 942 spec->unsol_event = alc_sku_unsol_event; 943 } 944 } 945 946 /* return the position of NID in the list, or -1 if not found */ 947 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums) 948 { 949 int i; 950 for (i = 0; i < nums; i++) 951 if (list[i] == nid) 952 return i; 953 return -1; 954 } 955 956 /* check whether dynamic ADC-switching is available */ 957 static bool alc_check_dyn_adc_switch(struct hda_codec *codec) 958 { 959 struct alc_spec *spec = codec->spec; 960 struct hda_input_mux *imux = &spec->private_imux[0]; 961 int i, n, idx; 962 hda_nid_t cap, pin; 963 964 if (imux != spec->input_mux) /* no dynamic imux? */ 965 return false; 966 967 for (n = 0; n < spec->num_adc_nids; n++) { 968 cap = spec->private_capsrc_nids[n]; 969 for (i = 0; i < imux->num_items; i++) { 970 pin = spec->imux_pins[i]; 971 if (!pin) 972 return false; 973 if (get_connection_index(codec, cap, pin) < 0) 974 break; 975 } 976 if (i >= imux->num_items) 977 return true; /* no ADC-switch is needed */ 978 } 979 980 for (i = 0; i < imux->num_items; i++) { 981 pin = spec->imux_pins[i]; 982 for (n = 0; n < spec->num_adc_nids; n++) { 983 cap = spec->private_capsrc_nids[n]; 984 idx = get_connection_index(codec, cap, pin); 985 if (idx >= 0) { 986 imux->items[i].index = idx; 987 spec->dyn_adc_idx[i] = n; 988 break; 989 } 990 } 991 } 992 993 snd_printdd("realtek: enabling ADC switching\n"); 994 spec->dyn_adc_switch = 1; 995 return true; 996 } 997 998 /* rebuild imux for matching with the given auto-mic pins (if not yet) */ 999 static bool alc_rebuild_imux_for_auto_mic(struct hda_codec *codec) 1000 { 1001 struct alc_spec *spec = codec->spec; 1002 struct hda_input_mux *imux; 1003 static char * const texts[3] = { 1004 "Mic", "Internal Mic", "Dock Mic" 1005 }; 1006 int i; 1007 1008 if (!spec->auto_mic) 1009 return false; 1010 imux = &spec->private_imux[0]; 1011 if (spec->input_mux == imux) 1012 return true; 1013 spec->imux_pins[0] = spec->ext_mic_pin; 1014 spec->imux_pins[1] = spec->int_mic_pin; 1015 spec->imux_pins[2] = spec->dock_mic_pin; 1016 for (i = 0; i < 3; i++) { 1017 strcpy(imux->items[i].label, texts[i]); 1018 if (spec->imux_pins[i]) 1019 imux->num_items = i + 1; 1020 } 1021 spec->num_mux_defs = 1; 1022 spec->input_mux = imux; 1023 return true; 1024 } 1025 1026 /* check whether all auto-mic pins are valid; setup indices if OK */ 1027 static bool alc_auto_mic_check_imux(struct hda_codec *codec) 1028 { 1029 struct alc_spec *spec = codec->spec; 1030 const struct hda_input_mux *imux; 1031 1032 if (!spec->auto_mic) 1033 return false; 1034 if (spec->auto_mic_valid_imux) 1035 return true; /* already checked */ 1036 1037 /* fill up imux indices */ 1038 if (!alc_check_dyn_adc_switch(codec)) { 1039 spec->auto_mic = 0; 1040 return false; 1041 } 1042 1043 imux = spec->input_mux; 1044 spec->ext_mic_idx = find_idx_in_nid_list(spec->ext_mic_pin, 1045 spec->imux_pins, imux->num_items); 1046 spec->int_mic_idx = find_idx_in_nid_list(spec->int_mic_pin, 1047 spec->imux_pins, imux->num_items); 1048 spec->dock_mic_idx = find_idx_in_nid_list(spec->dock_mic_pin, 1049 spec->imux_pins, imux->num_items); 1050 if (spec->ext_mic_idx < 0 || spec->int_mic_idx < 0) { 1051 spec->auto_mic = 0; 1052 return false; /* no corresponding imux */ 1053 } 1054 1055 snd_hda_codec_write_cache(codec, spec->ext_mic_pin, 0, 1056 AC_VERB_SET_UNSOLICITED_ENABLE, 1057 AC_USRSP_EN | ALC_MIC_EVENT); 1058 if (spec->dock_mic_pin) 1059 snd_hda_codec_write_cache(codec, spec->dock_mic_pin, 0, 1060 AC_VERB_SET_UNSOLICITED_ENABLE, 1061 AC_USRSP_EN | ALC_MIC_EVENT); 1062 1063 spec->auto_mic_valid_imux = 1; 1064 spec->auto_mic = 1; 1065 return true; 1066 } 1067 1068 /* 1069 * Check the availability of auto-mic switch; 1070 * Set up if really supported 1071 */ 1072 static void alc_init_auto_mic(struct hda_codec *codec) 1073 { 1074 struct alc_spec *spec = codec->spec; 1075 struct auto_pin_cfg *cfg = &spec->autocfg; 1076 hda_nid_t fixed, ext, dock; 1077 int i; 1078 1079 spec->ext_mic_idx = spec->int_mic_idx = spec->dock_mic_idx = -1; 1080 1081 fixed = ext = dock = 0; 1082 for (i = 0; i < cfg->num_inputs; i++) { 1083 hda_nid_t nid = cfg->inputs[i].pin; 1084 unsigned int defcfg; 1085 defcfg = snd_hda_codec_get_pincfg(codec, nid); 1086 switch (snd_hda_get_input_pin_attr(defcfg)) { 1087 case INPUT_PIN_ATTR_INT: 1088 if (fixed) 1089 return; /* already occupied */ 1090 if (cfg->inputs[i].type != AUTO_PIN_MIC) 1091 return; /* invalid type */ 1092 fixed = nid; 1093 break; 1094 case INPUT_PIN_ATTR_UNUSED: 1095 return; /* invalid entry */ 1096 case INPUT_PIN_ATTR_DOCK: 1097 if (dock) 1098 return; /* already occupied */ 1099 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN) 1100 return; /* invalid type */ 1101 dock = nid; 1102 break; 1103 default: 1104 if (ext) 1105 return; /* already occupied */ 1106 if (cfg->inputs[i].type != AUTO_PIN_MIC) 1107 return; /* invalid type */ 1108 ext = nid; 1109 break; 1110 } 1111 } 1112 if (!ext && dock) { 1113 ext = dock; 1114 dock = 0; 1115 } 1116 if (!ext || !fixed) 1117 return; 1118 if (!is_jack_detectable(codec, ext)) 1119 return; /* no unsol support */ 1120 if (dock && !is_jack_detectable(codec, dock)) 1121 return; /* no unsol support */ 1122 1123 /* check imux indices */ 1124 spec->ext_mic_pin = ext; 1125 spec->int_mic_pin = fixed; 1126 spec->dock_mic_pin = dock; 1127 1128 spec->auto_mic = 1; 1129 if (!alc_auto_mic_check_imux(codec)) 1130 return; 1131 1132 snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n", 1133 ext, fixed, dock); 1134 spec->unsol_event = alc_sku_unsol_event; 1135 } 1136 1137 /* check the availabilities of auto-mute and auto-mic switches */ 1138 static void alc_auto_check_switches(struct hda_codec *codec) 1139 { 1140 alc_init_auto_hp(codec); 1141 alc_init_auto_mic(codec); 1142 } 1143 1144 /* 1145 * Realtek SSID verification 1146 */ 1147 1148 /* Could be any non-zero and even value. When used as fixup, tells 1149 * the driver to ignore any present sku defines. 1150 */ 1151 #define ALC_FIXUP_SKU_IGNORE (2) 1152 1153 static int alc_auto_parse_customize_define(struct hda_codec *codec) 1154 { 1155 unsigned int ass, tmp, i; 1156 unsigned nid = 0; 1157 struct alc_spec *spec = codec->spec; 1158 1159 spec->cdefine.enable_pcbeep = 1; /* assume always enabled */ 1160 1161 if (spec->cdefine.fixup) { 1162 ass = spec->cdefine.sku_cfg; 1163 if (ass == ALC_FIXUP_SKU_IGNORE) 1164 return -1; 1165 goto do_sku; 1166 } 1167 1168 ass = codec->subsystem_id & 0xffff; 1169 if (ass != codec->bus->pci->subsystem_device && (ass & 1)) 1170 goto do_sku; 1171 1172 nid = 0x1d; 1173 if (codec->vendor_id == 0x10ec0260) 1174 nid = 0x17; 1175 ass = snd_hda_codec_get_pincfg(codec, nid); 1176 1177 if (!(ass & 1)) { 1178 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n", 1179 codec->chip_name, ass); 1180 return -1; 1181 } 1182 1183 /* check sum */ 1184 tmp = 0; 1185 for (i = 1; i < 16; i++) { 1186 if ((ass >> i) & 1) 1187 tmp++; 1188 } 1189 if (((ass >> 16) & 0xf) != tmp) 1190 return -1; 1191 1192 spec->cdefine.port_connectivity = ass >> 30; 1193 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20; 1194 spec->cdefine.check_sum = (ass >> 16) & 0xf; 1195 spec->cdefine.customization = ass >> 8; 1196 do_sku: 1197 spec->cdefine.sku_cfg = ass; 1198 spec->cdefine.external_amp = (ass & 0x38) >> 3; 1199 spec->cdefine.platform_type = (ass & 0x4) >> 2; 1200 spec->cdefine.swap = (ass & 0x2) >> 1; 1201 spec->cdefine.override = ass & 0x1; 1202 1203 snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n", 1204 nid, spec->cdefine.sku_cfg); 1205 snd_printd("SKU: port_connectivity=0x%x\n", 1206 spec->cdefine.port_connectivity); 1207 snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep); 1208 snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum); 1209 snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization); 1210 snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp); 1211 snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type); 1212 snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap); 1213 snd_printd("SKU: override=0x%x\n", spec->cdefine.override); 1214 1215 return 0; 1216 } 1217 1218 /* return true if the given NID is found in the list */ 1219 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums) 1220 { 1221 return find_idx_in_nid_list(nid, list, nums) >= 0; 1222 } 1223 1224 /* check subsystem ID and set up device-specific initialization; 1225 * return 1 if initialized, 0 if invalid SSID 1226 */ 1227 /* 32-bit subsystem ID for BIOS loading in HD Audio codec. 1228 * 31 ~ 16 : Manufacture ID 1229 * 15 ~ 8 : SKU ID 1230 * 7 ~ 0 : Assembly ID 1231 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36 1232 */ 1233 static int alc_subsystem_id(struct hda_codec *codec, 1234 hda_nid_t porta, hda_nid_t porte, 1235 hda_nid_t portd, hda_nid_t porti) 1236 { 1237 unsigned int ass, tmp, i; 1238 unsigned nid; 1239 struct alc_spec *spec = codec->spec; 1240 1241 if (spec->cdefine.fixup) { 1242 ass = spec->cdefine.sku_cfg; 1243 if (ass == ALC_FIXUP_SKU_IGNORE) 1244 return 0; 1245 goto do_sku; 1246 } 1247 1248 ass = codec->subsystem_id & 0xffff; 1249 if ((ass != codec->bus->pci->subsystem_device) && (ass & 1)) 1250 goto do_sku; 1251 1252 /* invalid SSID, check the special NID pin defcfg instead */ 1253 /* 1254 * 31~30 : port connectivity 1255 * 29~21 : reserve 1256 * 20 : PCBEEP input 1257 * 19~16 : Check sum (15:1) 1258 * 15~1 : Custom 1259 * 0 : override 1260 */ 1261 nid = 0x1d; 1262 if (codec->vendor_id == 0x10ec0260) 1263 nid = 0x17; 1264 ass = snd_hda_codec_get_pincfg(codec, nid); 1265 snd_printd("realtek: No valid SSID, " 1266 "checking pincfg 0x%08x for NID 0x%x\n", 1267 ass, nid); 1268 if (!(ass & 1)) 1269 return 0; 1270 if ((ass >> 30) != 1) /* no physical connection */ 1271 return 0; 1272 1273 /* check sum */ 1274 tmp = 0; 1275 for (i = 1; i < 16; i++) { 1276 if ((ass >> i) & 1) 1277 tmp++; 1278 } 1279 if (((ass >> 16) & 0xf) != tmp) 1280 return 0; 1281 do_sku: 1282 snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n", 1283 ass & 0xffff, codec->vendor_id); 1284 /* 1285 * 0 : override 1286 * 1 : Swap Jack 1287 * 2 : 0 --> Desktop, 1 --> Laptop 1288 * 3~5 : External Amplifier control 1289 * 7~6 : Reserved 1290 */ 1291 tmp = (ass & 0x38) >> 3; /* external Amp control */ 1292 switch (tmp) { 1293 case 1: 1294 spec->init_amp = ALC_INIT_GPIO1; 1295 break; 1296 case 3: 1297 spec->init_amp = ALC_INIT_GPIO2; 1298 break; 1299 case 7: 1300 spec->init_amp = ALC_INIT_GPIO3; 1301 break; 1302 case 5: 1303 default: 1304 spec->init_amp = ALC_INIT_DEFAULT; 1305 break; 1306 } 1307 1308 /* is laptop or Desktop and enable the function "Mute internal speaker 1309 * when the external headphone out jack is plugged" 1310 */ 1311 if (!(ass & 0x8000)) 1312 return 1; 1313 /* 1314 * 10~8 : Jack location 1315 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered 1316 * 14~13: Resvered 1317 * 15 : 1 --> enable the function "Mute internal speaker 1318 * when the external headphone out jack is plugged" 1319 */ 1320 if (!spec->autocfg.hp_pins[0]) { 1321 hda_nid_t nid; 1322 tmp = (ass >> 11) & 0x3; /* HP to chassis */ 1323 if (tmp == 0) 1324 nid = porta; 1325 else if (tmp == 1) 1326 nid = porte; 1327 else if (tmp == 2) 1328 nid = portd; 1329 else if (tmp == 3) 1330 nid = porti; 1331 else 1332 return 1; 1333 if (found_in_nid_list(nid, spec->autocfg.line_out_pins, 1334 spec->autocfg.line_outs)) 1335 return 1; 1336 spec->autocfg.hp_pins[0] = nid; 1337 } 1338 return 1; 1339 } 1340 1341 /* Check the validity of ALC subsystem-id 1342 * ports contains an array of 4 pin NIDs for port-A, E, D and I */ 1343 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports) 1344 { 1345 if (!alc_subsystem_id(codec, ports[0], ports[1], ports[2], ports[3])) { 1346 struct alc_spec *spec = codec->spec; 1347 snd_printd("realtek: " 1348 "Enable default setup for auto mode as fallback\n"); 1349 spec->init_amp = ALC_INIT_DEFAULT; 1350 } 1351 } 1352 1353 /* 1354 * Fix-up pin default configurations and add default verbs 1355 */ 1356 1357 struct alc_pincfg { 1358 hda_nid_t nid; 1359 u32 val; 1360 }; 1361 1362 struct alc_model_fixup { 1363 const int id; 1364 const char *name; 1365 }; 1366 1367 struct alc_fixup { 1368 int type; 1369 bool chained; 1370 int chain_id; 1371 union { 1372 unsigned int sku; 1373 const struct alc_pincfg *pins; 1374 const struct hda_verb *verbs; 1375 void (*func)(struct hda_codec *codec, 1376 const struct alc_fixup *fix, 1377 int action); 1378 } v; 1379 }; 1380 1381 enum { 1382 ALC_FIXUP_INVALID, 1383 ALC_FIXUP_SKU, 1384 ALC_FIXUP_PINS, 1385 ALC_FIXUP_VERBS, 1386 ALC_FIXUP_FUNC, 1387 }; 1388 1389 enum { 1390 ALC_FIXUP_ACT_PRE_PROBE, 1391 ALC_FIXUP_ACT_PROBE, 1392 ALC_FIXUP_ACT_INIT, 1393 }; 1394 1395 static void alc_apply_fixup(struct hda_codec *codec, int action) 1396 { 1397 struct alc_spec *spec = codec->spec; 1398 int id = spec->fixup_id; 1399 #ifdef CONFIG_SND_DEBUG_VERBOSE 1400 const char *modelname = spec->fixup_name; 1401 #endif 1402 int depth = 0; 1403 1404 if (!spec->fixup_list) 1405 return; 1406 1407 while (id >= 0) { 1408 const struct alc_fixup *fix = spec->fixup_list + id; 1409 const struct alc_pincfg *cfg; 1410 1411 switch (fix->type) { 1412 case ALC_FIXUP_SKU: 1413 if (action != ALC_FIXUP_ACT_PRE_PROBE || !fix->v.sku) 1414 break;; 1415 snd_printdd(KERN_INFO "hda_codec: %s: " 1416 "Apply sku override for %s\n", 1417 codec->chip_name, modelname); 1418 spec->cdefine.sku_cfg = fix->v.sku; 1419 spec->cdefine.fixup = 1; 1420 break; 1421 case ALC_FIXUP_PINS: 1422 cfg = fix->v.pins; 1423 if (action != ALC_FIXUP_ACT_PRE_PROBE || !cfg) 1424 break; 1425 snd_printdd(KERN_INFO "hda_codec: %s: " 1426 "Apply pincfg for %s\n", 1427 codec->chip_name, modelname); 1428 for (; cfg->nid; cfg++) 1429 snd_hda_codec_set_pincfg(codec, cfg->nid, 1430 cfg->val); 1431 break; 1432 case ALC_FIXUP_VERBS: 1433 if (action != ALC_FIXUP_ACT_PROBE || !fix->v.verbs) 1434 break; 1435 snd_printdd(KERN_INFO "hda_codec: %s: " 1436 "Apply fix-verbs for %s\n", 1437 codec->chip_name, modelname); 1438 add_verb(codec->spec, fix->v.verbs); 1439 break; 1440 case ALC_FIXUP_FUNC: 1441 if (!fix->v.func) 1442 break; 1443 snd_printdd(KERN_INFO "hda_codec: %s: " 1444 "Apply fix-func for %s\n", 1445 codec->chip_name, modelname); 1446 fix->v.func(codec, fix, action); 1447 break; 1448 default: 1449 snd_printk(KERN_ERR "hda_codec: %s: " 1450 "Invalid fixup type %d\n", 1451 codec->chip_name, fix->type); 1452 break; 1453 } 1454 if (!fix->chained) 1455 break; 1456 if (++depth > 10) 1457 break; 1458 id = fix->chain_id; 1459 } 1460 } 1461 1462 static void alc_pick_fixup(struct hda_codec *codec, 1463 const struct alc_model_fixup *models, 1464 const struct snd_pci_quirk *quirk, 1465 const struct alc_fixup *fixlist) 1466 { 1467 struct alc_spec *spec = codec->spec; 1468 int id = -1; 1469 const char *name = NULL; 1470 1471 if (codec->modelname && models) { 1472 while (models->name) { 1473 if (!strcmp(codec->modelname, models->name)) { 1474 id = models->id; 1475 name = models->name; 1476 break; 1477 } 1478 models++; 1479 } 1480 } 1481 if (id < 0) { 1482 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk); 1483 if (quirk) { 1484 id = quirk->value; 1485 #ifdef CONFIG_SND_DEBUG_VERBOSE 1486 name = quirk->name; 1487 #endif 1488 } 1489 } 1490 1491 spec->fixup_id = id; 1492 if (id >= 0) { 1493 spec->fixup_list = fixlist; 1494 spec->fixup_name = name; 1495 } 1496 } 1497 1498 /* 1499 * COEF access helper functions 1500 */ 1501 static int alc_read_coef_idx(struct hda_codec *codec, 1502 unsigned int coef_idx) 1503 { 1504 unsigned int val; 1505 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 1506 coef_idx); 1507 val = snd_hda_codec_read(codec, 0x20, 0, 1508 AC_VERB_GET_PROC_COEF, 0); 1509 return val; 1510 } 1511 1512 static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx, 1513 unsigned int coef_val) 1514 { 1515 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 1516 coef_idx); 1517 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 1518 coef_val); 1519 } 1520 1521 /* 1522 * Digital I/O handling 1523 */ 1524 1525 /* set right pin controls for digital I/O */ 1526 static void alc_auto_init_digital(struct hda_codec *codec) 1527 { 1528 struct alc_spec *spec = codec->spec; 1529 int i; 1530 hda_nid_t pin, dac; 1531 1532 for (i = 0; i < spec->autocfg.dig_outs; i++) { 1533 pin = spec->autocfg.dig_out_pins[i]; 1534 if (!pin) 1535 continue; 1536 snd_hda_codec_write(codec, pin, 0, 1537 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 1538 if (!i) 1539 dac = spec->multiout.dig_out_nid; 1540 else 1541 dac = spec->slave_dig_outs[i - 1]; 1542 if (!dac || !(get_wcaps(codec, dac) & AC_WCAP_OUT_AMP)) 1543 continue; 1544 snd_hda_codec_write(codec, dac, 0, 1545 AC_VERB_SET_AMP_GAIN_MUTE, 1546 AMP_OUT_UNMUTE); 1547 } 1548 pin = spec->autocfg.dig_in_pin; 1549 if (pin) 1550 snd_hda_codec_write(codec, pin, 0, 1551 AC_VERB_SET_PIN_WIDGET_CONTROL, 1552 PIN_IN); 1553 } 1554 1555 /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */ 1556 static void alc_auto_parse_digital(struct hda_codec *codec) 1557 { 1558 struct alc_spec *spec = codec->spec; 1559 int i, err; 1560 hda_nid_t dig_nid; 1561 1562 /* support multiple SPDIFs; the secondary is set up as a slave */ 1563 for (i = 0; i < spec->autocfg.dig_outs; i++) { 1564 hda_nid_t conn[4]; 1565 err = snd_hda_get_connections(codec, 1566 spec->autocfg.dig_out_pins[i], 1567 conn, ARRAY_SIZE(conn)); 1568 if (err < 0) 1569 continue; 1570 dig_nid = conn[0]; /* assume the first element is audio-out */ 1571 if (!i) { 1572 spec->multiout.dig_out_nid = dig_nid; 1573 spec->dig_out_type = spec->autocfg.dig_out_type[0]; 1574 } else { 1575 spec->multiout.slave_dig_outs = spec->slave_dig_outs; 1576 if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1) 1577 break; 1578 spec->slave_dig_outs[i - 1] = dig_nid; 1579 } 1580 } 1581 1582 if (spec->autocfg.dig_in_pin) { 1583 dig_nid = codec->start_nid; 1584 for (i = 0; i < codec->num_nodes; i++, dig_nid++) { 1585 unsigned int wcaps = get_wcaps(codec, dig_nid); 1586 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN) 1587 continue; 1588 if (!(wcaps & AC_WCAP_DIGITAL)) 1589 continue; 1590 if (!(wcaps & AC_WCAP_CONN_LIST)) 1591 continue; 1592 err = get_connection_index(codec, dig_nid, 1593 spec->autocfg.dig_in_pin); 1594 if (err >= 0) { 1595 spec->dig_in_nid = dig_nid; 1596 break; 1597 } 1598 } 1599 } 1600 } 1601 1602 /* 1603 * capture mixer elements 1604 */ 1605 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol, 1606 struct snd_ctl_elem_info *uinfo) 1607 { 1608 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1609 struct alc_spec *spec = codec->spec; 1610 unsigned long val; 1611 int err; 1612 1613 mutex_lock(&codec->control_mutex); 1614 if (spec->vol_in_capsrc) 1615 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT); 1616 else 1617 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT); 1618 kcontrol->private_value = val; 1619 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo); 1620 mutex_unlock(&codec->control_mutex); 1621 return err; 1622 } 1623 1624 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag, 1625 unsigned int size, unsigned int __user *tlv) 1626 { 1627 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1628 struct alc_spec *spec = codec->spec; 1629 unsigned long val; 1630 int err; 1631 1632 mutex_lock(&codec->control_mutex); 1633 if (spec->vol_in_capsrc) 1634 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT); 1635 else 1636 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT); 1637 kcontrol->private_value = val; 1638 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv); 1639 mutex_unlock(&codec->control_mutex); 1640 return err; 1641 } 1642 1643 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol, 1644 struct snd_ctl_elem_value *ucontrol); 1645 1646 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol, 1647 struct snd_ctl_elem_value *ucontrol, 1648 getput_call_t func, bool check_adc_switch) 1649 { 1650 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1651 struct alc_spec *spec = codec->spec; 1652 int i, err = 0; 1653 1654 mutex_lock(&codec->control_mutex); 1655 if (check_adc_switch && spec->dyn_adc_switch) { 1656 for (i = 0; i < spec->num_adc_nids; i++) { 1657 kcontrol->private_value = 1658 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i], 1659 3, 0, HDA_INPUT); 1660 err = func(kcontrol, ucontrol); 1661 if (err < 0) 1662 goto error; 1663 } 1664 } else { 1665 i = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 1666 if (spec->vol_in_capsrc) 1667 kcontrol->private_value = 1668 HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[i], 1669 3, 0, HDA_OUTPUT); 1670 else 1671 kcontrol->private_value = 1672 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i], 1673 3, 0, HDA_INPUT); 1674 err = func(kcontrol, ucontrol); 1675 } 1676 error: 1677 mutex_unlock(&codec->control_mutex); 1678 return err; 1679 } 1680 1681 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol, 1682 struct snd_ctl_elem_value *ucontrol) 1683 { 1684 return alc_cap_getput_caller(kcontrol, ucontrol, 1685 snd_hda_mixer_amp_volume_get, false); 1686 } 1687 1688 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol, 1689 struct snd_ctl_elem_value *ucontrol) 1690 { 1691 return alc_cap_getput_caller(kcontrol, ucontrol, 1692 snd_hda_mixer_amp_volume_put, true); 1693 } 1694 1695 /* capture mixer elements */ 1696 #define alc_cap_sw_info snd_ctl_boolean_stereo_info 1697 1698 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol, 1699 struct snd_ctl_elem_value *ucontrol) 1700 { 1701 return alc_cap_getput_caller(kcontrol, ucontrol, 1702 snd_hda_mixer_amp_switch_get, false); 1703 } 1704 1705 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol, 1706 struct snd_ctl_elem_value *ucontrol) 1707 { 1708 return alc_cap_getput_caller(kcontrol, ucontrol, 1709 snd_hda_mixer_amp_switch_put, true); 1710 } 1711 1712 #define _DEFINE_CAPMIX(num) \ 1713 { \ 1714 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 1715 .name = "Capture Switch", \ 1716 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \ 1717 .count = num, \ 1718 .info = alc_cap_sw_info, \ 1719 .get = alc_cap_sw_get, \ 1720 .put = alc_cap_sw_put, \ 1721 }, \ 1722 { \ 1723 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 1724 .name = "Capture Volume", \ 1725 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \ 1726 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \ 1727 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \ 1728 .count = num, \ 1729 .info = alc_cap_vol_info, \ 1730 .get = alc_cap_vol_get, \ 1731 .put = alc_cap_vol_put, \ 1732 .tlv = { .c = alc_cap_vol_tlv }, \ 1733 } 1734 1735 #define _DEFINE_CAPSRC(num) \ 1736 { \ 1737 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 1738 /* .name = "Capture Source", */ \ 1739 .name = "Input Source", \ 1740 .count = num, \ 1741 .info = alc_mux_enum_info, \ 1742 .get = alc_mux_enum_get, \ 1743 .put = alc_mux_enum_put, \ 1744 } 1745 1746 #define DEFINE_CAPMIX(num) \ 1747 static const struct snd_kcontrol_new alc_capture_mixer ## num[] = { \ 1748 _DEFINE_CAPMIX(num), \ 1749 _DEFINE_CAPSRC(num), \ 1750 { } /* end */ \ 1751 } 1752 1753 #define DEFINE_CAPMIX_NOSRC(num) \ 1754 static const struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \ 1755 _DEFINE_CAPMIX(num), \ 1756 { } /* end */ \ 1757 } 1758 1759 /* up to three ADCs */ 1760 DEFINE_CAPMIX(1); 1761 DEFINE_CAPMIX(2); 1762 DEFINE_CAPMIX(3); 1763 DEFINE_CAPMIX_NOSRC(1); 1764 DEFINE_CAPMIX_NOSRC(2); 1765 DEFINE_CAPMIX_NOSRC(3); 1766 1767 /* 1768 * virtual master controls 1769 */ 1770 1771 /* 1772 * slave controls for virtual master 1773 */ 1774 static const char * const alc_slave_vols[] = { 1775 "Front Playback Volume", 1776 "Surround Playback Volume", 1777 "Center Playback Volume", 1778 "LFE Playback Volume", 1779 "Side Playback Volume", 1780 "Headphone Playback Volume", 1781 "Speaker Playback Volume", 1782 "Mono Playback Volume", 1783 "Line-Out Playback Volume", 1784 NULL, 1785 }; 1786 1787 static const char * const alc_slave_sws[] = { 1788 "Front Playback Switch", 1789 "Surround Playback Switch", 1790 "Center Playback Switch", 1791 "LFE Playback Switch", 1792 "Side Playback Switch", 1793 "Headphone Playback Switch", 1794 "Speaker Playback Switch", 1795 "Mono Playback Switch", 1796 "IEC958 Playback Switch", 1797 "Line-Out Playback Switch", 1798 NULL, 1799 }; 1800 1801 /* 1802 * build control elements 1803 */ 1804 1805 #define NID_MAPPING (-1) 1806 1807 #define SUBDEV_SPEAKER_ (0 << 6) 1808 #define SUBDEV_HP_ (1 << 6) 1809 #define SUBDEV_LINE_ (2 << 6) 1810 #define SUBDEV_SPEAKER(x) (SUBDEV_SPEAKER_ | ((x) & 0x3f)) 1811 #define SUBDEV_HP(x) (SUBDEV_HP_ | ((x) & 0x3f)) 1812 #define SUBDEV_LINE(x) (SUBDEV_LINE_ | ((x) & 0x3f)) 1813 1814 static void alc_free_kctls(struct hda_codec *codec); 1815 1816 #ifdef CONFIG_SND_HDA_INPUT_BEEP 1817 /* additional beep mixers; the actual parameters are overwritten at build */ 1818 static const struct snd_kcontrol_new alc_beep_mixer[] = { 1819 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT), 1820 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT), 1821 { } /* end */ 1822 }; 1823 #endif 1824 1825 static int alc_build_controls(struct hda_codec *codec) 1826 { 1827 struct alc_spec *spec = codec->spec; 1828 struct snd_kcontrol *kctl = NULL; 1829 const struct snd_kcontrol_new *knew; 1830 int i, j, err; 1831 unsigned int u; 1832 hda_nid_t nid; 1833 1834 for (i = 0; i < spec->num_mixers; i++) { 1835 err = snd_hda_add_new_ctls(codec, spec->mixers[i]); 1836 if (err < 0) 1837 return err; 1838 } 1839 if (spec->cap_mixer) { 1840 err = snd_hda_add_new_ctls(codec, spec->cap_mixer); 1841 if (err < 0) 1842 return err; 1843 } 1844 if (spec->multiout.dig_out_nid) { 1845 err = snd_hda_create_spdif_out_ctls(codec, 1846 spec->multiout.dig_out_nid, 1847 spec->multiout.dig_out_nid); 1848 if (err < 0) 1849 return err; 1850 if (!spec->no_analog) { 1851 err = snd_hda_create_spdif_share_sw(codec, 1852 &spec->multiout); 1853 if (err < 0) 1854 return err; 1855 spec->multiout.share_spdif = 1; 1856 } 1857 } 1858 if (spec->dig_in_nid) { 1859 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid); 1860 if (err < 0) 1861 return err; 1862 } 1863 1864 #ifdef CONFIG_SND_HDA_INPUT_BEEP 1865 /* create beep controls if needed */ 1866 if (spec->beep_amp) { 1867 const struct snd_kcontrol_new *knew; 1868 for (knew = alc_beep_mixer; knew->name; knew++) { 1869 struct snd_kcontrol *kctl; 1870 kctl = snd_ctl_new1(knew, codec); 1871 if (!kctl) 1872 return -ENOMEM; 1873 kctl->private_value = spec->beep_amp; 1874 err = snd_hda_ctl_add(codec, 0, kctl); 1875 if (err < 0) 1876 return err; 1877 } 1878 } 1879 #endif 1880 1881 /* if we have no master control, let's create it */ 1882 if (!spec->no_analog && 1883 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) { 1884 unsigned int vmaster_tlv[4]; 1885 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid, 1886 HDA_OUTPUT, vmaster_tlv); 1887 err = snd_hda_add_vmaster(codec, "Master Playback Volume", 1888 vmaster_tlv, alc_slave_vols); 1889 if (err < 0) 1890 return err; 1891 } 1892 if (!spec->no_analog && 1893 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) { 1894 err = snd_hda_add_vmaster(codec, "Master Playback Switch", 1895 NULL, alc_slave_sws); 1896 if (err < 0) 1897 return err; 1898 } 1899 1900 /* assign Capture Source enums to NID */ 1901 if (spec->capsrc_nids || spec->adc_nids) { 1902 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source"); 1903 if (!kctl) 1904 kctl = snd_hda_find_mixer_ctl(codec, "Input Source"); 1905 for (i = 0; kctl && i < kctl->count; i++) { 1906 const hda_nid_t *nids = spec->capsrc_nids; 1907 if (!nids) 1908 nids = spec->adc_nids; 1909 err = snd_hda_add_nid(codec, kctl, i, nids[i]); 1910 if (err < 0) 1911 return err; 1912 } 1913 } 1914 if (spec->cap_mixer) { 1915 const char *kname = kctl ? kctl->id.name : NULL; 1916 for (knew = spec->cap_mixer; knew->name; knew++) { 1917 if (kname && strcmp(knew->name, kname) == 0) 1918 continue; 1919 kctl = snd_hda_find_mixer_ctl(codec, knew->name); 1920 for (i = 0; kctl && i < kctl->count; i++) { 1921 err = snd_hda_add_nid(codec, kctl, i, 1922 spec->adc_nids[i]); 1923 if (err < 0) 1924 return err; 1925 } 1926 } 1927 } 1928 1929 /* other nid->control mapping */ 1930 for (i = 0; i < spec->num_mixers; i++) { 1931 for (knew = spec->mixers[i]; knew->name; knew++) { 1932 if (knew->iface != NID_MAPPING) 1933 continue; 1934 kctl = snd_hda_find_mixer_ctl(codec, knew->name); 1935 if (kctl == NULL) 1936 continue; 1937 u = knew->subdevice; 1938 for (j = 0; j < 4; j++, u >>= 8) { 1939 nid = u & 0x3f; 1940 if (nid == 0) 1941 continue; 1942 switch (u & 0xc0) { 1943 case SUBDEV_SPEAKER_: 1944 nid = spec->autocfg.speaker_pins[nid]; 1945 break; 1946 case SUBDEV_LINE_: 1947 nid = spec->autocfg.line_out_pins[nid]; 1948 break; 1949 case SUBDEV_HP_: 1950 nid = spec->autocfg.hp_pins[nid]; 1951 break; 1952 default: 1953 continue; 1954 } 1955 err = snd_hda_add_nid(codec, kctl, 0, nid); 1956 if (err < 0) 1957 return err; 1958 } 1959 u = knew->private_value; 1960 for (j = 0; j < 4; j++, u >>= 8) { 1961 nid = u & 0xff; 1962 if (nid == 0) 1963 continue; 1964 err = snd_hda_add_nid(codec, kctl, 0, nid); 1965 if (err < 0) 1966 return err; 1967 } 1968 } 1969 } 1970 1971 alc_free_kctls(codec); /* no longer needed */ 1972 1973 return 0; 1974 } 1975 1976 1977 /* 1978 * Common callbacks 1979 */ 1980 1981 static void alc_init_special_input_src(struct hda_codec *codec); 1982 1983 static int alc_init(struct hda_codec *codec) 1984 { 1985 struct alc_spec *spec = codec->spec; 1986 unsigned int i; 1987 1988 alc_fix_pll(codec); 1989 alc_auto_init_amp(codec, spec->init_amp); 1990 1991 for (i = 0; i < spec->num_init_verbs; i++) 1992 snd_hda_sequence_write(codec, spec->init_verbs[i]); 1993 alc_init_special_input_src(codec); 1994 1995 if (spec->init_hook) 1996 spec->init_hook(codec); 1997 1998 alc_apply_fixup(codec, ALC_FIXUP_ACT_INIT); 1999 2000 hda_call_check_power_status(codec, 0x01); 2001 return 0; 2002 } 2003 2004 static void alc_unsol_event(struct hda_codec *codec, unsigned int res) 2005 { 2006 struct alc_spec *spec = codec->spec; 2007 2008 if (spec->unsol_event) 2009 spec->unsol_event(codec, res); 2010 } 2011 2012 #ifdef CONFIG_SND_HDA_POWER_SAVE 2013 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid) 2014 { 2015 struct alc_spec *spec = codec->spec; 2016 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid); 2017 } 2018 #endif 2019 2020 /* 2021 * Analog playback callbacks 2022 */ 2023 static int alc_playback_pcm_open(struct hda_pcm_stream *hinfo, 2024 struct hda_codec *codec, 2025 struct snd_pcm_substream *substream) 2026 { 2027 struct alc_spec *spec = codec->spec; 2028 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, 2029 hinfo); 2030 } 2031 2032 static int alc_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 2033 struct hda_codec *codec, 2034 unsigned int stream_tag, 2035 unsigned int format, 2036 struct snd_pcm_substream *substream) 2037 { 2038 struct alc_spec *spec = codec->spec; 2039 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, 2040 stream_tag, format, substream); 2041 } 2042 2043 static int alc_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 2044 struct hda_codec *codec, 2045 struct snd_pcm_substream *substream) 2046 { 2047 struct alc_spec *spec = codec->spec; 2048 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); 2049 } 2050 2051 /* 2052 * Digital out 2053 */ 2054 static int alc_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, 2055 struct hda_codec *codec, 2056 struct snd_pcm_substream *substream) 2057 { 2058 struct alc_spec *spec = codec->spec; 2059 return snd_hda_multi_out_dig_open(codec, &spec->multiout); 2060 } 2061 2062 static int alc_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 2063 struct hda_codec *codec, 2064 unsigned int stream_tag, 2065 unsigned int format, 2066 struct snd_pcm_substream *substream) 2067 { 2068 struct alc_spec *spec = codec->spec; 2069 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, 2070 stream_tag, format, substream); 2071 } 2072 2073 static int alc_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 2074 struct hda_codec *codec, 2075 struct snd_pcm_substream *substream) 2076 { 2077 struct alc_spec *spec = codec->spec; 2078 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout); 2079 } 2080 2081 static int alc_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, 2082 struct hda_codec *codec, 2083 struct snd_pcm_substream *substream) 2084 { 2085 struct alc_spec *spec = codec->spec; 2086 return snd_hda_multi_out_dig_close(codec, &spec->multiout); 2087 } 2088 2089 /* 2090 * Analog capture 2091 */ 2092 static int alc_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 2093 struct hda_codec *codec, 2094 unsigned int stream_tag, 2095 unsigned int format, 2096 struct snd_pcm_substream *substream) 2097 { 2098 struct alc_spec *spec = codec->spec; 2099 2100 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1], 2101 stream_tag, 0, format); 2102 return 0; 2103 } 2104 2105 static int alc_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 2106 struct hda_codec *codec, 2107 struct snd_pcm_substream *substream) 2108 { 2109 struct alc_spec *spec = codec->spec; 2110 2111 snd_hda_codec_cleanup_stream(codec, 2112 spec->adc_nids[substream->number + 1]); 2113 return 0; 2114 } 2115 2116 /* analog capture with dynamic dual-adc changes */ 2117 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 2118 struct hda_codec *codec, 2119 unsigned int stream_tag, 2120 unsigned int format, 2121 struct snd_pcm_substream *substream) 2122 { 2123 struct alc_spec *spec = codec->spec; 2124 spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]]; 2125 spec->cur_adc_stream_tag = stream_tag; 2126 spec->cur_adc_format = format; 2127 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format); 2128 return 0; 2129 } 2130 2131 static int dyn_adc_capture_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 snd_hda_codec_cleanup_stream(codec, spec->cur_adc); 2137 spec->cur_adc = 0; 2138 return 0; 2139 } 2140 2141 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = { 2142 .substreams = 1, 2143 .channels_min = 2, 2144 .channels_max = 2, 2145 .nid = 0, /* fill later */ 2146 .ops = { 2147 .prepare = dyn_adc_capture_pcm_prepare, 2148 .cleanup = dyn_adc_capture_pcm_cleanup 2149 }, 2150 }; 2151 2152 /* 2153 */ 2154 static const struct hda_pcm_stream alc_pcm_analog_playback = { 2155 .substreams = 1, 2156 .channels_min = 2, 2157 .channels_max = 8, 2158 /* NID is set in alc_build_pcms */ 2159 .ops = { 2160 .open = alc_playback_pcm_open, 2161 .prepare = alc_playback_pcm_prepare, 2162 .cleanup = alc_playback_pcm_cleanup 2163 }, 2164 }; 2165 2166 static const struct hda_pcm_stream alc_pcm_analog_capture = { 2167 .substreams = 1, 2168 .channels_min = 2, 2169 .channels_max = 2, 2170 /* NID is set in alc_build_pcms */ 2171 }; 2172 2173 static const struct hda_pcm_stream alc_pcm_analog_alt_playback = { 2174 .substreams = 1, 2175 .channels_min = 2, 2176 .channels_max = 2, 2177 /* NID is set in alc_build_pcms */ 2178 }; 2179 2180 static const struct hda_pcm_stream alc_pcm_analog_alt_capture = { 2181 .substreams = 2, /* can be overridden */ 2182 .channels_min = 2, 2183 .channels_max = 2, 2184 /* NID is set in alc_build_pcms */ 2185 .ops = { 2186 .prepare = alc_alt_capture_pcm_prepare, 2187 .cleanup = alc_alt_capture_pcm_cleanup 2188 }, 2189 }; 2190 2191 static const struct hda_pcm_stream alc_pcm_digital_playback = { 2192 .substreams = 1, 2193 .channels_min = 2, 2194 .channels_max = 2, 2195 /* NID is set in alc_build_pcms */ 2196 .ops = { 2197 .open = alc_dig_playback_pcm_open, 2198 .close = alc_dig_playback_pcm_close, 2199 .prepare = alc_dig_playback_pcm_prepare, 2200 .cleanup = alc_dig_playback_pcm_cleanup 2201 }, 2202 }; 2203 2204 static const struct hda_pcm_stream alc_pcm_digital_capture = { 2205 .substreams = 1, 2206 .channels_min = 2, 2207 .channels_max = 2, 2208 /* NID is set in alc_build_pcms */ 2209 }; 2210 2211 /* Used by alc_build_pcms to flag that a PCM has no playback stream */ 2212 static const struct hda_pcm_stream alc_pcm_null_stream = { 2213 .substreams = 0, 2214 .channels_min = 0, 2215 .channels_max = 0, 2216 }; 2217 2218 static int alc_build_pcms(struct hda_codec *codec) 2219 { 2220 struct alc_spec *spec = codec->spec; 2221 struct hda_pcm *info = spec->pcm_rec; 2222 const struct hda_pcm_stream *p; 2223 int i; 2224 2225 codec->num_pcms = 1; 2226 codec->pcm_info = info; 2227 2228 if (spec->no_analog) 2229 goto skip_analog; 2230 2231 snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog), 2232 "%s Analog", codec->chip_name); 2233 info->name = spec->stream_name_analog; 2234 2235 if (spec->multiout.dac_nids > 0) { 2236 p = spec->stream_analog_playback; 2237 if (!p) 2238 p = &alc_pcm_analog_playback; 2239 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p; 2240 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0]; 2241 } 2242 if (spec->adc_nids) { 2243 p = spec->stream_analog_capture; 2244 if (!p) { 2245 if (spec->dyn_adc_switch) 2246 p = &dyn_adc_pcm_analog_capture; 2247 else 2248 p = &alc_pcm_analog_capture; 2249 } 2250 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p; 2251 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; 2252 } 2253 2254 if (spec->channel_mode) { 2255 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0; 2256 for (i = 0; i < spec->num_channel_mode; i++) { 2257 if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) { 2258 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels; 2259 } 2260 } 2261 } 2262 2263 skip_analog: 2264 /* SPDIF for stream index #1 */ 2265 if (spec->multiout.dig_out_nid || spec->dig_in_nid) { 2266 snprintf(spec->stream_name_digital, 2267 sizeof(spec->stream_name_digital), 2268 "%s Digital", codec->chip_name); 2269 codec->num_pcms = 2; 2270 codec->slave_dig_outs = spec->multiout.slave_dig_outs; 2271 info = spec->pcm_rec + 1; 2272 info->name = spec->stream_name_digital; 2273 if (spec->dig_out_type) 2274 info->pcm_type = spec->dig_out_type; 2275 else 2276 info->pcm_type = HDA_PCM_TYPE_SPDIF; 2277 if (spec->multiout.dig_out_nid) { 2278 p = spec->stream_digital_playback; 2279 if (!p) 2280 p = &alc_pcm_digital_playback; 2281 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p; 2282 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid; 2283 } 2284 if (spec->dig_in_nid) { 2285 p = spec->stream_digital_capture; 2286 if (!p) 2287 p = &alc_pcm_digital_capture; 2288 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p; 2289 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid; 2290 } 2291 /* FIXME: do we need this for all Realtek codec models? */ 2292 codec->spdif_status_reset = 1; 2293 } 2294 2295 if (spec->no_analog) 2296 return 0; 2297 2298 /* If the use of more than one ADC is requested for the current 2299 * model, configure a second analog capture-only PCM. 2300 */ 2301 /* Additional Analaog capture for index #2 */ 2302 if (spec->alt_dac_nid || spec->num_adc_nids > 1) { 2303 codec->num_pcms = 3; 2304 info = spec->pcm_rec + 2; 2305 info->name = spec->stream_name_analog; 2306 if (spec->alt_dac_nid) { 2307 p = spec->stream_analog_alt_playback; 2308 if (!p) 2309 p = &alc_pcm_analog_alt_playback; 2310 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p; 2311 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 2312 spec->alt_dac_nid; 2313 } else { 2314 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 2315 alc_pcm_null_stream; 2316 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0; 2317 } 2318 if (spec->num_adc_nids > 1) { 2319 p = spec->stream_analog_alt_capture; 2320 if (!p) 2321 p = &alc_pcm_analog_alt_capture; 2322 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p; 2323 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 2324 spec->adc_nids[1]; 2325 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 2326 spec->num_adc_nids - 1; 2327 } else { 2328 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 2329 alc_pcm_null_stream; 2330 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0; 2331 } 2332 } 2333 2334 return 0; 2335 } 2336 2337 static inline void alc_shutup(struct hda_codec *codec) 2338 { 2339 struct alc_spec *spec = codec->spec; 2340 2341 if (spec && spec->shutup) 2342 spec->shutup(codec); 2343 snd_hda_shutup_pins(codec); 2344 } 2345 2346 static void alc_free_kctls(struct hda_codec *codec) 2347 { 2348 struct alc_spec *spec = codec->spec; 2349 2350 if (spec->kctls.list) { 2351 struct snd_kcontrol_new *kctl = spec->kctls.list; 2352 int i; 2353 for (i = 0; i < spec->kctls.used; i++) 2354 kfree(kctl[i].name); 2355 } 2356 snd_array_free(&spec->kctls); 2357 } 2358 2359 static void alc_free(struct hda_codec *codec) 2360 { 2361 struct alc_spec *spec = codec->spec; 2362 2363 if (!spec) 2364 return; 2365 2366 alc_shutup(codec); 2367 snd_hda_input_jack_free(codec); 2368 alc_free_kctls(codec); 2369 kfree(spec); 2370 snd_hda_detach_beep_device(codec); 2371 } 2372 2373 #ifdef CONFIG_SND_HDA_POWER_SAVE 2374 static void alc_power_eapd(struct hda_codec *codec) 2375 { 2376 alc_auto_setup_eapd(codec, false); 2377 } 2378 2379 static int alc_suspend(struct hda_codec *codec, pm_message_t state) 2380 { 2381 struct alc_spec *spec = codec->spec; 2382 alc_shutup(codec); 2383 if (spec && spec->power_hook) 2384 spec->power_hook(codec); 2385 return 0; 2386 } 2387 #endif 2388 2389 #ifdef SND_HDA_NEEDS_RESUME 2390 static int alc_resume(struct hda_codec *codec) 2391 { 2392 msleep(150); /* to avoid pop noise */ 2393 codec->patch_ops.init(codec); 2394 snd_hda_codec_resume_amp(codec); 2395 snd_hda_codec_resume_cache(codec); 2396 hda_call_check_power_status(codec, 0x01); 2397 return 0; 2398 } 2399 #endif 2400 2401 /* 2402 */ 2403 static const struct hda_codec_ops alc_patch_ops = { 2404 .build_controls = alc_build_controls, 2405 .build_pcms = alc_build_pcms, 2406 .init = alc_init, 2407 .free = alc_free, 2408 .unsol_event = alc_unsol_event, 2409 #ifdef SND_HDA_NEEDS_RESUME 2410 .resume = alc_resume, 2411 #endif 2412 #ifdef CONFIG_SND_HDA_POWER_SAVE 2413 .suspend = alc_suspend, 2414 .check_power_status = alc_check_power_status, 2415 #endif 2416 .reboot_notify = alc_shutup, 2417 }; 2418 2419 /* replace the codec chip_name with the given string */ 2420 static int alc_codec_rename(struct hda_codec *codec, const char *name) 2421 { 2422 kfree(codec->chip_name); 2423 codec->chip_name = kstrdup(name, GFP_KERNEL); 2424 if (!codec->chip_name) { 2425 alc_free(codec); 2426 return -ENOMEM; 2427 } 2428 return 0; 2429 } 2430 2431 /* 2432 * Automatic parse of I/O pins from the BIOS configuration 2433 */ 2434 2435 enum { 2436 ALC_CTL_WIDGET_VOL, 2437 ALC_CTL_WIDGET_MUTE, 2438 ALC_CTL_BIND_MUTE, 2439 }; 2440 static const struct snd_kcontrol_new alc_control_templates[] = { 2441 HDA_CODEC_VOLUME(NULL, 0, 0, 0), 2442 HDA_CODEC_MUTE(NULL, 0, 0, 0), 2443 HDA_BIND_MUTE(NULL, 0, 0, 0), 2444 }; 2445 2446 /* add dynamic controls */ 2447 static int add_control(struct alc_spec *spec, int type, const char *name, 2448 int cidx, unsigned long val) 2449 { 2450 struct snd_kcontrol_new *knew; 2451 2452 knew = alc_kcontrol_new(spec); 2453 if (!knew) 2454 return -ENOMEM; 2455 *knew = alc_control_templates[type]; 2456 knew->name = kstrdup(name, GFP_KERNEL); 2457 if (!knew->name) 2458 return -ENOMEM; 2459 knew->index = cidx; 2460 if (get_amp_nid_(val)) 2461 knew->subdevice = HDA_SUBDEV_AMP_FLAG; 2462 knew->private_value = val; 2463 return 0; 2464 } 2465 2466 static int add_control_with_pfx(struct alc_spec *spec, int type, 2467 const char *pfx, const char *dir, 2468 const char *sfx, int cidx, unsigned long val) 2469 { 2470 char name[32]; 2471 snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx); 2472 return add_control(spec, type, name, cidx, val); 2473 } 2474 2475 #define add_pb_vol_ctrl(spec, type, pfx, val) \ 2476 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val) 2477 #define add_pb_sw_ctrl(spec, type, pfx, val) \ 2478 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val) 2479 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \ 2480 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val) 2481 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \ 2482 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val) 2483 2484 static const char *alc_get_line_out_pfx(struct alc_spec *spec, int ch, 2485 bool can_be_master, int *index) 2486 { 2487 struct auto_pin_cfg *cfg = &spec->autocfg; 2488 static const char * const chname[4] = { 2489 "Front", "Surround", NULL /*CLFE*/, "Side" 2490 }; 2491 2492 *index = 0; 2493 if (cfg->line_outs == 1 && !spec->multi_ios && 2494 !cfg->hp_outs && !cfg->speaker_outs && can_be_master) 2495 return "Master"; 2496 2497 switch (cfg->line_out_type) { 2498 case AUTO_PIN_SPEAKER_OUT: 2499 if (cfg->line_outs == 1) 2500 return "Speaker"; 2501 break; 2502 case AUTO_PIN_HP_OUT: 2503 /* for multi-io case, only the primary out */ 2504 if (ch && spec->multi_ios) 2505 break; 2506 *index = ch; 2507 return "Headphone"; 2508 default: 2509 if (cfg->line_outs == 1 && !spec->multi_ios) 2510 return "PCM"; 2511 break; 2512 } 2513 return chname[ch]; 2514 } 2515 2516 /* create input playback/capture controls for the given pin */ 2517 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin, 2518 const char *ctlname, int ctlidx, 2519 int idx, hda_nid_t mix_nid) 2520 { 2521 int err; 2522 2523 err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx, 2524 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); 2525 if (err < 0) 2526 return err; 2527 err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx, 2528 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); 2529 if (err < 0) 2530 return err; 2531 return 0; 2532 } 2533 2534 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid) 2535 { 2536 unsigned int pincap = snd_hda_query_pin_caps(codec, nid); 2537 return (pincap & AC_PINCAP_IN) != 0; 2538 } 2539 2540 /* Parse the codec tree and retrieve ADCs and corresponding capsrc MUXs */ 2541 static int alc_auto_fill_adc_caps(struct hda_codec *codec) 2542 { 2543 struct alc_spec *spec = codec->spec; 2544 hda_nid_t nid; 2545 hda_nid_t *adc_nids = spec->private_adc_nids; 2546 hda_nid_t *cap_nids = spec->private_capsrc_nids; 2547 int max_nums = ARRAY_SIZE(spec->private_adc_nids); 2548 bool indep_capsrc = false; 2549 int i, nums = 0; 2550 2551 nid = codec->start_nid; 2552 for (i = 0; i < codec->num_nodes; i++, nid++) { 2553 hda_nid_t src; 2554 const hda_nid_t *list; 2555 unsigned int caps = get_wcaps(codec, nid); 2556 int type = get_wcaps_type(caps); 2557 2558 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL)) 2559 continue; 2560 adc_nids[nums] = nid; 2561 cap_nids[nums] = nid; 2562 src = nid; 2563 for (;;) { 2564 int n; 2565 type = get_wcaps_type(get_wcaps(codec, src)); 2566 if (type == AC_WID_PIN) 2567 break; 2568 if (type == AC_WID_AUD_SEL) { 2569 cap_nids[nums] = src; 2570 indep_capsrc = true; 2571 break; 2572 } 2573 n = snd_hda_get_conn_list(codec, src, &list); 2574 if (n > 1) { 2575 cap_nids[nums] = src; 2576 indep_capsrc = true; 2577 break; 2578 } else if (n != 1) 2579 break; 2580 src = *list; 2581 } 2582 if (++nums >= max_nums) 2583 break; 2584 } 2585 spec->adc_nids = spec->private_adc_nids; 2586 spec->capsrc_nids = spec->private_capsrc_nids; 2587 spec->num_adc_nids = nums; 2588 return nums; 2589 } 2590 2591 /* create playback/capture controls for input pins */ 2592 static int alc_auto_create_input_ctls(struct hda_codec *codec) 2593 { 2594 struct alc_spec *spec = codec->spec; 2595 const struct auto_pin_cfg *cfg = &spec->autocfg; 2596 hda_nid_t mixer = spec->mixer_nid; 2597 struct hda_input_mux *imux = &spec->private_imux[0]; 2598 int num_adcs; 2599 int i, c, err, idx, type_idx = 0; 2600 const char *prev_label = NULL; 2601 2602 num_adcs = alc_auto_fill_adc_caps(codec); 2603 if (num_adcs < 0) 2604 return 0; 2605 2606 for (i = 0; i < cfg->num_inputs; i++) { 2607 hda_nid_t pin; 2608 const char *label; 2609 2610 pin = cfg->inputs[i].pin; 2611 if (!alc_is_input_pin(codec, pin)) 2612 continue; 2613 2614 label = hda_get_autocfg_input_label(codec, cfg, i); 2615 if (prev_label && !strcmp(label, prev_label)) 2616 type_idx++; 2617 else 2618 type_idx = 0; 2619 prev_label = label; 2620 2621 if (mixer) { 2622 idx = get_connection_index(codec, mixer, pin); 2623 if (idx >= 0) { 2624 err = new_analog_input(spec, pin, 2625 label, type_idx, 2626 idx, mixer); 2627 if (err < 0) 2628 return err; 2629 } 2630 } 2631 2632 for (c = 0; c < num_adcs; c++) { 2633 hda_nid_t cap = spec->capsrc_nids ? 2634 spec->capsrc_nids[c] : spec->adc_nids[c]; 2635 idx = get_connection_index(codec, cap, pin); 2636 if (idx >= 0) { 2637 spec->imux_pins[imux->num_items] = pin; 2638 snd_hda_add_imux_item(imux, label, idx, NULL); 2639 break; 2640 } 2641 } 2642 } 2643 2644 spec->num_mux_defs = 1; 2645 spec->input_mux = imux; 2646 2647 return 0; 2648 } 2649 2650 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid, 2651 unsigned int pin_type) 2652 { 2653 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 2654 pin_type); 2655 /* unmute pin */ 2656 if (nid_has_mute(codec, nid, HDA_OUTPUT)) 2657 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, 2658 AMP_OUT_UNMUTE); 2659 } 2660 2661 static int get_pin_type(int line_out_type) 2662 { 2663 if (line_out_type == AUTO_PIN_HP_OUT) 2664 return PIN_HP; 2665 else 2666 return PIN_OUT; 2667 } 2668 2669 static void alc_auto_init_analog_input(struct hda_codec *codec) 2670 { 2671 struct alc_spec *spec = codec->spec; 2672 struct auto_pin_cfg *cfg = &spec->autocfg; 2673 int i; 2674 2675 for (i = 0; i < cfg->num_inputs; i++) { 2676 hda_nid_t nid = cfg->inputs[i].pin; 2677 if (alc_is_input_pin(codec, nid)) { 2678 alc_set_input_pin(codec, nid, cfg->inputs[i].type); 2679 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) 2680 snd_hda_codec_write(codec, nid, 0, 2681 AC_VERB_SET_AMP_GAIN_MUTE, 2682 AMP_OUT_MUTE); 2683 } 2684 } 2685 2686 /* mute all loopback inputs */ 2687 if (spec->mixer_nid) { 2688 int nums = snd_hda_get_conn_list(codec, spec->mixer_nid, NULL); 2689 for (i = 0; i < nums; i++) 2690 snd_hda_codec_write(codec, spec->mixer_nid, 0, 2691 AC_VERB_SET_AMP_GAIN_MUTE, 2692 AMP_IN_MUTE(i)); 2693 } 2694 } 2695 2696 /* convert from MIX nid to DAC */ 2697 static hda_nid_t alc_auto_mix_to_dac(struct hda_codec *codec, hda_nid_t nid) 2698 { 2699 hda_nid_t list[5]; 2700 int i, num; 2701 2702 if (get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_AUD_OUT) 2703 return nid; 2704 num = snd_hda_get_connections(codec, nid, list, ARRAY_SIZE(list)); 2705 for (i = 0; i < num; i++) { 2706 if (get_wcaps_type(get_wcaps(codec, list[i])) == AC_WID_AUD_OUT) 2707 return list[i]; 2708 } 2709 return 0; 2710 } 2711 2712 /* go down to the selector widget before the mixer */ 2713 static hda_nid_t alc_go_down_to_selector(struct hda_codec *codec, hda_nid_t pin) 2714 { 2715 hda_nid_t srcs[5]; 2716 int num = snd_hda_get_connections(codec, pin, srcs, 2717 ARRAY_SIZE(srcs)); 2718 if (num != 1 || 2719 get_wcaps_type(get_wcaps(codec, srcs[0])) != AC_WID_AUD_SEL) 2720 return pin; 2721 return srcs[0]; 2722 } 2723 2724 /* get MIX nid connected to the given pin targeted to DAC */ 2725 static hda_nid_t alc_auto_dac_to_mix(struct hda_codec *codec, hda_nid_t pin, 2726 hda_nid_t dac) 2727 { 2728 hda_nid_t mix[5]; 2729 int i, num; 2730 2731 pin = alc_go_down_to_selector(codec, pin); 2732 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix)); 2733 for (i = 0; i < num; i++) { 2734 if (alc_auto_mix_to_dac(codec, mix[i]) == dac) 2735 return mix[i]; 2736 } 2737 return 0; 2738 } 2739 2740 /* select the connection from pin to DAC if needed */ 2741 static int alc_auto_select_dac(struct hda_codec *codec, hda_nid_t pin, 2742 hda_nid_t dac) 2743 { 2744 hda_nid_t mix[5]; 2745 int i, num; 2746 2747 pin = alc_go_down_to_selector(codec, pin); 2748 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix)); 2749 if (num < 2) 2750 return 0; 2751 for (i = 0; i < num; i++) { 2752 if (alc_auto_mix_to_dac(codec, mix[i]) == dac) { 2753 snd_hda_codec_update_cache(codec, pin, 0, 2754 AC_VERB_SET_CONNECT_SEL, i); 2755 return 0; 2756 } 2757 } 2758 return 0; 2759 } 2760 2761 /* look for an empty DAC slot */ 2762 static hda_nid_t alc_auto_look_for_dac(struct hda_codec *codec, hda_nid_t pin) 2763 { 2764 struct alc_spec *spec = codec->spec; 2765 hda_nid_t srcs[5]; 2766 int i, num; 2767 2768 pin = alc_go_down_to_selector(codec, pin); 2769 num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs)); 2770 for (i = 0; i < num; i++) { 2771 hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]); 2772 if (!nid) 2773 continue; 2774 if (found_in_nid_list(nid, spec->multiout.dac_nids, 2775 spec->multiout.num_dacs)) 2776 continue; 2777 if (spec->multiout.hp_nid == nid) 2778 continue; 2779 if (found_in_nid_list(nid, spec->multiout.extra_out_nid, 2780 ARRAY_SIZE(spec->multiout.extra_out_nid))) 2781 continue; 2782 return nid; 2783 } 2784 return 0; 2785 } 2786 2787 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin) 2788 { 2789 hda_nid_t sel = alc_go_down_to_selector(codec, pin); 2790 if (snd_hda_get_conn_list(codec, sel, NULL) == 1) 2791 return alc_auto_look_for_dac(codec, pin); 2792 return 0; 2793 } 2794 2795 /* fill in the dac_nids table from the parsed pin configuration */ 2796 static int alc_auto_fill_dac_nids(struct hda_codec *codec) 2797 { 2798 struct alc_spec *spec = codec->spec; 2799 const struct auto_pin_cfg *cfg = &spec->autocfg; 2800 bool redone = false; 2801 int i; 2802 2803 again: 2804 spec->multiout.num_dacs = 0; 2805 spec->multiout.hp_nid = 0; 2806 spec->multiout.extra_out_nid[0] = 0; 2807 memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids)); 2808 spec->multiout.dac_nids = spec->private_dac_nids; 2809 2810 /* fill hard-wired DACs first */ 2811 if (!redone) { 2812 for (i = 0; i < cfg->line_outs; i++) 2813 spec->private_dac_nids[i] = 2814 get_dac_if_single(codec, cfg->line_out_pins[i]); 2815 if (cfg->hp_outs) 2816 spec->multiout.hp_nid = 2817 get_dac_if_single(codec, cfg->hp_pins[0]); 2818 if (cfg->speaker_outs) 2819 spec->multiout.extra_out_nid[0] = 2820 get_dac_if_single(codec, cfg->speaker_pins[0]); 2821 } 2822 2823 for (i = 0; i < cfg->line_outs; i++) { 2824 hda_nid_t pin = cfg->line_out_pins[i]; 2825 if (spec->private_dac_nids[i]) 2826 continue; 2827 spec->private_dac_nids[i] = alc_auto_look_for_dac(codec, pin); 2828 if (!spec->private_dac_nids[i] && !redone) { 2829 /* if we can't find primary DACs, re-probe without 2830 * checking the hard-wired DACs 2831 */ 2832 redone = true; 2833 goto again; 2834 } 2835 } 2836 2837 for (i = 0; i < cfg->line_outs; i++) { 2838 if (spec->private_dac_nids[i]) 2839 spec->multiout.num_dacs++; 2840 else 2841 memmove(spec->private_dac_nids + i, 2842 spec->private_dac_nids + i + 1, 2843 sizeof(hda_nid_t) * (cfg->line_outs - i - 1)); 2844 } 2845 2846 if (cfg->hp_outs && !spec->multiout.hp_nid) 2847 spec->multiout.hp_nid = 2848 alc_auto_look_for_dac(codec, cfg->hp_pins[0]); 2849 if (cfg->speaker_outs && !spec->multiout.extra_out_nid[0]) 2850 spec->multiout.extra_out_nid[0] = 2851 alc_auto_look_for_dac(codec, cfg->speaker_pins[0]); 2852 2853 return 0; 2854 } 2855 2856 static int alc_auto_add_vol_ctl(struct hda_codec *codec, 2857 const char *pfx, int cidx, 2858 hda_nid_t nid, unsigned int chs) 2859 { 2860 if (!nid) 2861 return 0; 2862 return __add_pb_vol_ctrl(codec->spec, ALC_CTL_WIDGET_VOL, pfx, cidx, 2863 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT)); 2864 } 2865 2866 #define alc_auto_add_stereo_vol(codec, pfx, cidx, nid) \ 2867 alc_auto_add_vol_ctl(codec, pfx, cidx, nid, 3) 2868 2869 /* create a mute-switch for the given mixer widget; 2870 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute 2871 */ 2872 static int alc_auto_add_sw_ctl(struct hda_codec *codec, 2873 const char *pfx, int cidx, 2874 hda_nid_t nid, unsigned int chs) 2875 { 2876 int wid_type; 2877 int type; 2878 unsigned long val; 2879 if (!nid) 2880 return 0; 2881 wid_type = get_wcaps_type(get_wcaps(codec, nid)); 2882 if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT) { 2883 type = ALC_CTL_WIDGET_MUTE; 2884 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT); 2885 } else if (snd_hda_get_conn_list(codec, nid, NULL) == 1) { 2886 type = ALC_CTL_WIDGET_MUTE; 2887 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT); 2888 } else { 2889 type = ALC_CTL_BIND_MUTE; 2890 val = HDA_COMPOSE_AMP_VAL(nid, chs, 2, HDA_INPUT); 2891 } 2892 return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val); 2893 } 2894 2895 #define alc_auto_add_stereo_sw(codec, pfx, cidx, nid) \ 2896 alc_auto_add_sw_ctl(codec, pfx, cidx, nid, 3) 2897 2898 static hda_nid_t alc_look_for_out_mute_nid(struct hda_codec *codec, 2899 hda_nid_t pin, hda_nid_t dac) 2900 { 2901 hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac); 2902 if (nid_has_mute(codec, pin, HDA_OUTPUT)) 2903 return pin; 2904 else if (mix && nid_has_mute(codec, mix, HDA_INPUT)) 2905 return mix; 2906 else if (nid_has_mute(codec, dac, HDA_OUTPUT)) 2907 return dac; 2908 return 0; 2909 } 2910 2911 static hda_nid_t alc_look_for_out_vol_nid(struct hda_codec *codec, 2912 hda_nid_t pin, hda_nid_t dac) 2913 { 2914 hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac); 2915 if (nid_has_volume(codec, dac, HDA_OUTPUT)) 2916 return dac; 2917 else if (nid_has_volume(codec, mix, HDA_OUTPUT)) 2918 return mix; 2919 else if (nid_has_volume(codec, pin, HDA_OUTPUT)) 2920 return pin; 2921 return 0; 2922 } 2923 2924 /* add playback controls from the parsed DAC table */ 2925 static int alc_auto_create_multi_out_ctls(struct hda_codec *codec, 2926 const struct auto_pin_cfg *cfg) 2927 { 2928 struct alc_spec *spec = codec->spec; 2929 int i, err, noutputs; 2930 2931 noutputs = cfg->line_outs; 2932 if (spec->multi_ios > 0) 2933 noutputs += spec->multi_ios; 2934 2935 for (i = 0; i < noutputs; i++) { 2936 const char *name; 2937 int index; 2938 hda_nid_t dac, pin; 2939 hda_nid_t sw, vol; 2940 2941 dac = spec->multiout.dac_nids[i]; 2942 if (!dac) 2943 continue; 2944 if (i >= cfg->line_outs) 2945 pin = spec->multi_io[i - 1].pin; 2946 else 2947 pin = cfg->line_out_pins[i]; 2948 2949 sw = alc_look_for_out_mute_nid(codec, pin, dac); 2950 vol = alc_look_for_out_vol_nid(codec, pin, dac); 2951 name = alc_get_line_out_pfx(spec, i, true, &index); 2952 if (!name) { 2953 /* Center/LFE */ 2954 err = alc_auto_add_vol_ctl(codec, "Center", 0, vol, 1); 2955 if (err < 0) 2956 return err; 2957 err = alc_auto_add_vol_ctl(codec, "LFE", 0, vol, 2); 2958 if (err < 0) 2959 return err; 2960 err = alc_auto_add_sw_ctl(codec, "Center", 0, sw, 1); 2961 if (err < 0) 2962 return err; 2963 err = alc_auto_add_sw_ctl(codec, "LFE", 0, sw, 2); 2964 if (err < 0) 2965 return err; 2966 } else { 2967 err = alc_auto_add_stereo_vol(codec, name, index, vol); 2968 if (err < 0) 2969 return err; 2970 err = alc_auto_add_stereo_sw(codec, name, index, sw); 2971 if (err < 0) 2972 return err; 2973 } 2974 } 2975 return 0; 2976 } 2977 2978 /* add playback controls for speaker and HP outputs */ 2979 static int alc_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin, 2980 hda_nid_t dac, const char *pfx) 2981 { 2982 struct alc_spec *spec = codec->spec; 2983 hda_nid_t sw, vol; 2984 int err; 2985 2986 if (!pin) 2987 return 0; 2988 if (!dac) { 2989 /* the corresponding DAC is already occupied */ 2990 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP)) 2991 return 0; /* no way */ 2992 /* create a switch only */ 2993 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, 2994 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 2995 } 2996 2997 sw = alc_look_for_out_mute_nid(codec, pin, dac); 2998 vol = alc_look_for_out_vol_nid(codec, pin, dac); 2999 err = alc_auto_add_stereo_vol(codec, pfx, 0, vol); 3000 if (err < 0) 3001 return err; 3002 err = alc_auto_add_stereo_sw(codec, pfx, 0, sw); 3003 if (err < 0) 3004 return err; 3005 return 0; 3006 } 3007 3008 static int alc_auto_create_hp_out(struct hda_codec *codec) 3009 { 3010 struct alc_spec *spec = codec->spec; 3011 return alc_auto_create_extra_out(codec, spec->autocfg.hp_pins[0], 3012 spec->multiout.hp_nid, 3013 "Headphone"); 3014 } 3015 3016 static int alc_auto_create_speaker_out(struct hda_codec *codec) 3017 { 3018 struct alc_spec *spec = codec->spec; 3019 return alc_auto_create_extra_out(codec, spec->autocfg.speaker_pins[0], 3020 spec->multiout.extra_out_nid[0], 3021 "Speaker"); 3022 } 3023 3024 static void alc_auto_set_output_and_unmute(struct hda_codec *codec, 3025 hda_nid_t pin, int pin_type, 3026 hda_nid_t dac) 3027 { 3028 int i, num; 3029 hda_nid_t nid, mix = 0; 3030 hda_nid_t srcs[HDA_MAX_CONNECTIONS]; 3031 3032 alc_set_pin_output(codec, pin, pin_type); 3033 nid = alc_go_down_to_selector(codec, pin); 3034 num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs)); 3035 for (i = 0; i < num; i++) { 3036 if (alc_auto_mix_to_dac(codec, srcs[i]) != dac) 3037 continue; 3038 mix = srcs[i]; 3039 break; 3040 } 3041 if (!mix) 3042 return; 3043 3044 /* need the manual connection? */ 3045 if (num > 1) 3046 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i); 3047 /* unmute mixer widget inputs */ 3048 if (nid_has_mute(codec, mix, HDA_INPUT)) { 3049 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE, 3050 AMP_IN_UNMUTE(0)); 3051 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE, 3052 AMP_IN_UNMUTE(1)); 3053 } 3054 /* initialize volume */ 3055 nid = alc_look_for_out_vol_nid(codec, pin, dac); 3056 if (nid) 3057 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, 3058 AMP_OUT_ZERO); 3059 } 3060 3061 static void alc_auto_init_multi_out(struct hda_codec *codec) 3062 { 3063 struct alc_spec *spec = codec->spec; 3064 int pin_type = get_pin_type(spec->autocfg.line_out_type); 3065 int i; 3066 3067 for (i = 0; i <= HDA_SIDE; i++) { 3068 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 3069 if (nid) 3070 alc_auto_set_output_and_unmute(codec, nid, pin_type, 3071 spec->multiout.dac_nids[i]); 3072 } 3073 } 3074 3075 static void alc_auto_init_extra_out(struct hda_codec *codec) 3076 { 3077 struct alc_spec *spec = codec->spec; 3078 hda_nid_t pin; 3079 3080 pin = spec->autocfg.hp_pins[0]; 3081 if (pin) 3082 alc_auto_set_output_and_unmute(codec, pin, PIN_HP, 3083 spec->multiout.hp_nid); 3084 pin = spec->autocfg.speaker_pins[0]; 3085 if (pin) 3086 alc_auto_set_output_and_unmute(codec, pin, PIN_OUT, 3087 spec->multiout.extra_out_nid[0]); 3088 } 3089 3090 /* 3091 * multi-io helper 3092 */ 3093 static int alc_auto_fill_multi_ios(struct hda_codec *codec, 3094 unsigned int location) 3095 { 3096 struct alc_spec *spec = codec->spec; 3097 struct auto_pin_cfg *cfg = &spec->autocfg; 3098 int type, i, num_pins = 0; 3099 3100 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) { 3101 for (i = 0; i < cfg->num_inputs; i++) { 3102 hda_nid_t nid = cfg->inputs[i].pin; 3103 hda_nid_t dac; 3104 unsigned int defcfg, caps; 3105 if (cfg->inputs[i].type != type) 3106 continue; 3107 defcfg = snd_hda_codec_get_pincfg(codec, nid); 3108 if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX) 3109 continue; 3110 if (location && get_defcfg_location(defcfg) != location) 3111 continue; 3112 caps = snd_hda_query_pin_caps(codec, nid); 3113 if (!(caps & AC_PINCAP_OUT)) 3114 continue; 3115 dac = alc_auto_look_for_dac(codec, nid); 3116 if (!dac) 3117 continue; 3118 spec->multi_io[num_pins].pin = nid; 3119 spec->multi_io[num_pins].dac = dac; 3120 num_pins++; 3121 spec->private_dac_nids[spec->multiout.num_dacs++] = dac; 3122 } 3123 } 3124 spec->multiout.num_dacs = 1; 3125 if (num_pins < 2) 3126 return 0; 3127 return num_pins; 3128 } 3129 3130 static int alc_auto_ch_mode_info(struct snd_kcontrol *kcontrol, 3131 struct snd_ctl_elem_info *uinfo) 3132 { 3133 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3134 struct alc_spec *spec = codec->spec; 3135 3136 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 3137 uinfo->count = 1; 3138 uinfo->value.enumerated.items = spec->multi_ios + 1; 3139 if (uinfo->value.enumerated.item > spec->multi_ios) 3140 uinfo->value.enumerated.item = spec->multi_ios; 3141 sprintf(uinfo->value.enumerated.name, "%dch", 3142 (uinfo->value.enumerated.item + 1) * 2); 3143 return 0; 3144 } 3145 3146 static int alc_auto_ch_mode_get(struct snd_kcontrol *kcontrol, 3147 struct snd_ctl_elem_value *ucontrol) 3148 { 3149 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3150 struct alc_spec *spec = codec->spec; 3151 ucontrol->value.enumerated.item[0] = (spec->ext_channel_count - 1) / 2; 3152 return 0; 3153 } 3154 3155 static int alc_set_multi_io(struct hda_codec *codec, int idx, bool output) 3156 { 3157 struct alc_spec *spec = codec->spec; 3158 hda_nid_t nid = spec->multi_io[idx].pin; 3159 3160 if (!spec->multi_io[idx].ctl_in) 3161 spec->multi_io[idx].ctl_in = 3162 snd_hda_codec_read(codec, nid, 0, 3163 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 3164 if (output) { 3165 snd_hda_codec_update_cache(codec, nid, 0, 3166 AC_VERB_SET_PIN_WIDGET_CONTROL, 3167 PIN_OUT); 3168 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) 3169 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 3170 HDA_AMP_MUTE, 0); 3171 alc_auto_select_dac(codec, nid, spec->multi_io[idx].dac); 3172 } else { 3173 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) 3174 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 3175 HDA_AMP_MUTE, HDA_AMP_MUTE); 3176 snd_hda_codec_update_cache(codec, nid, 0, 3177 AC_VERB_SET_PIN_WIDGET_CONTROL, 3178 spec->multi_io[idx].ctl_in); 3179 } 3180 return 0; 3181 } 3182 3183 static int alc_auto_ch_mode_put(struct snd_kcontrol *kcontrol, 3184 struct snd_ctl_elem_value *ucontrol) 3185 { 3186 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3187 struct alc_spec *spec = codec->spec; 3188 int i, ch; 3189 3190 ch = ucontrol->value.enumerated.item[0]; 3191 if (ch < 0 || ch > spec->multi_ios) 3192 return -EINVAL; 3193 if (ch == (spec->ext_channel_count - 1) / 2) 3194 return 0; 3195 spec->ext_channel_count = (ch + 1) * 2; 3196 for (i = 0; i < spec->multi_ios; i++) 3197 alc_set_multi_io(codec, i, i < ch); 3198 spec->multiout.max_channels = spec->ext_channel_count; 3199 if (spec->need_dac_fix && !spec->const_channel_count) 3200 spec->multiout.num_dacs = spec->multiout.max_channels / 2; 3201 return 1; 3202 } 3203 3204 static const struct snd_kcontrol_new alc_auto_channel_mode_enum = { 3205 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3206 .name = "Channel Mode", 3207 .info = alc_auto_ch_mode_info, 3208 .get = alc_auto_ch_mode_get, 3209 .put = alc_auto_ch_mode_put, 3210 }; 3211 3212 static int alc_auto_add_multi_channel_mode(struct hda_codec *codec, 3213 int (*fill_dac)(struct hda_codec *)) 3214 { 3215 struct alc_spec *spec = codec->spec; 3216 struct auto_pin_cfg *cfg = &spec->autocfg; 3217 unsigned int location, defcfg; 3218 int num_pins; 3219 3220 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT && cfg->hp_outs == 1) { 3221 /* use HP as primary out */ 3222 cfg->speaker_outs = cfg->line_outs; 3223 memcpy(cfg->speaker_pins, cfg->line_out_pins, 3224 sizeof(cfg->speaker_pins)); 3225 cfg->line_outs = cfg->hp_outs; 3226 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins)); 3227 cfg->hp_outs = 0; 3228 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins)); 3229 cfg->line_out_type = AUTO_PIN_HP_OUT; 3230 if (fill_dac) 3231 fill_dac(codec); 3232 } 3233 if (cfg->line_outs != 1 || 3234 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) 3235 return 0; 3236 3237 defcfg = snd_hda_codec_get_pincfg(codec, cfg->line_out_pins[0]); 3238 location = get_defcfg_location(defcfg); 3239 3240 num_pins = alc_auto_fill_multi_ios(codec, location); 3241 if (num_pins > 0) { 3242 struct snd_kcontrol_new *knew; 3243 3244 knew = alc_kcontrol_new(spec); 3245 if (!knew) 3246 return -ENOMEM; 3247 *knew = alc_auto_channel_mode_enum; 3248 knew->name = kstrdup("Channel Mode", GFP_KERNEL); 3249 if (!knew->name) 3250 return -ENOMEM; 3251 3252 spec->multi_ios = num_pins; 3253 spec->ext_channel_count = 2; 3254 spec->multiout.num_dacs = num_pins + 1; 3255 } 3256 return 0; 3257 } 3258 3259 /* filter out invalid adc_nids (and capsrc_nids) that don't give all 3260 * active input pins 3261 */ 3262 static void alc_remove_invalid_adc_nids(struct hda_codec *codec) 3263 { 3264 struct alc_spec *spec = codec->spec; 3265 const struct hda_input_mux *imux; 3266 hda_nid_t adc_nids[ARRAY_SIZE(spec->private_adc_nids)]; 3267 hda_nid_t capsrc_nids[ARRAY_SIZE(spec->private_adc_nids)]; 3268 int i, n, nums; 3269 3270 imux = spec->input_mux; 3271 if (!imux) 3272 return; 3273 if (spec->dyn_adc_switch) 3274 return; 3275 3276 nums = 0; 3277 for (n = 0; n < spec->num_adc_nids; n++) { 3278 hda_nid_t cap = spec->private_capsrc_nids[n]; 3279 int num_conns = snd_hda_get_conn_list(codec, cap, NULL); 3280 for (i = 0; i < imux->num_items; i++) { 3281 hda_nid_t pin = spec->imux_pins[i]; 3282 if (pin) { 3283 if (get_connection_index(codec, cap, pin) < 0) 3284 break; 3285 } else if (num_conns <= imux->items[i].index) 3286 break; 3287 } 3288 if (i >= imux->num_items) { 3289 adc_nids[nums] = spec->private_adc_nids[n]; 3290 capsrc_nids[nums++] = cap; 3291 } 3292 } 3293 if (!nums) { 3294 /* check whether ADC-switch is possible */ 3295 if (!alc_check_dyn_adc_switch(codec)) { 3296 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;" 3297 " using fallback 0x%x\n", 3298 codec->chip_name, spec->private_adc_nids[0]); 3299 spec->num_adc_nids = 1; 3300 spec->auto_mic = 0; 3301 return; 3302 } 3303 } else if (nums != spec->num_adc_nids) { 3304 memcpy(spec->private_adc_nids, adc_nids, 3305 nums * sizeof(hda_nid_t)); 3306 memcpy(spec->private_capsrc_nids, capsrc_nids, 3307 nums * sizeof(hda_nid_t)); 3308 spec->num_adc_nids = nums; 3309 } 3310 3311 if (spec->auto_mic) 3312 alc_auto_mic_check_imux(codec); /* check auto-mic setups */ 3313 else if (spec->input_mux->num_items == 1) 3314 spec->num_adc_nids = 1; /* reduce to a single ADC */ 3315 } 3316 3317 /* 3318 * initialize ADC paths 3319 */ 3320 static void alc_auto_init_adc(struct hda_codec *codec, int adc_idx) 3321 { 3322 struct alc_spec *spec = codec->spec; 3323 hda_nid_t nid; 3324 3325 nid = spec->adc_nids[adc_idx]; 3326 /* mute ADC */ 3327 if (nid_has_mute(codec, nid, HDA_INPUT)) { 3328 snd_hda_codec_write(codec, nid, 0, 3329 AC_VERB_SET_AMP_GAIN_MUTE, 3330 AMP_IN_MUTE(0)); 3331 return; 3332 } 3333 if (!spec->capsrc_nids) 3334 return; 3335 nid = spec->capsrc_nids[adc_idx]; 3336 if (nid_has_mute(codec, nid, HDA_OUTPUT)) 3337 snd_hda_codec_write(codec, nid, 0, 3338 AC_VERB_SET_AMP_GAIN_MUTE, 3339 AMP_OUT_MUTE); 3340 } 3341 3342 static void alc_auto_init_input_src(struct hda_codec *codec) 3343 { 3344 struct alc_spec *spec = codec->spec; 3345 int c, nums; 3346 3347 for (c = 0; c < spec->num_adc_nids; c++) 3348 alc_auto_init_adc(codec, c); 3349 if (spec->dyn_adc_switch) 3350 nums = 1; 3351 else 3352 nums = spec->num_adc_nids; 3353 for (c = 0; c < nums; c++) 3354 alc_mux_select(codec, 0, spec->cur_mux[c], true); 3355 } 3356 3357 /* add mic boosts if needed */ 3358 static int alc_auto_add_mic_boost(struct hda_codec *codec) 3359 { 3360 struct alc_spec *spec = codec->spec; 3361 struct auto_pin_cfg *cfg = &spec->autocfg; 3362 int i, err; 3363 int type_idx = 0; 3364 hda_nid_t nid; 3365 const char *prev_label = NULL; 3366 3367 for (i = 0; i < cfg->num_inputs; i++) { 3368 if (cfg->inputs[i].type > AUTO_PIN_MIC) 3369 break; 3370 nid = cfg->inputs[i].pin; 3371 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) { 3372 const char *label; 3373 char boost_label[32]; 3374 3375 label = hda_get_autocfg_input_label(codec, cfg, i); 3376 if (prev_label && !strcmp(label, prev_label)) 3377 type_idx++; 3378 else 3379 type_idx = 0; 3380 prev_label = label; 3381 3382 snprintf(boost_label, sizeof(boost_label), 3383 "%s Boost Volume", label); 3384 err = add_control(spec, ALC_CTL_WIDGET_VOL, 3385 boost_label, type_idx, 3386 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT)); 3387 if (err < 0) 3388 return err; 3389 } 3390 } 3391 return 0; 3392 } 3393 3394 /* select or unmute the given capsrc route */ 3395 static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap, 3396 int idx) 3397 { 3398 if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) { 3399 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx, 3400 HDA_AMP_MUTE, 0); 3401 } else if (snd_hda_get_conn_list(codec, cap, NULL) > 1) { 3402 snd_hda_codec_write_cache(codec, cap, 0, 3403 AC_VERB_SET_CONNECT_SEL, idx); 3404 } 3405 } 3406 3407 /* set the default connection to that pin */ 3408 static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin) 3409 { 3410 struct alc_spec *spec = codec->spec; 3411 int i; 3412 3413 if (!pin) 3414 return 0; 3415 for (i = 0; i < spec->num_adc_nids; i++) { 3416 hda_nid_t cap = spec->capsrc_nids ? 3417 spec->capsrc_nids[i] : spec->adc_nids[i]; 3418 int idx; 3419 3420 idx = get_connection_index(codec, cap, pin); 3421 if (idx < 0) 3422 continue; 3423 select_or_unmute_capsrc(codec, cap, idx); 3424 return i; /* return the found index */ 3425 } 3426 return -1; /* not found */ 3427 } 3428 3429 /* initialize some special cases for input sources */ 3430 static void alc_init_special_input_src(struct hda_codec *codec) 3431 { 3432 struct alc_spec *spec = codec->spec; 3433 int i; 3434 3435 for (i = 0; i < spec->autocfg.num_inputs; i++) 3436 init_capsrc_for_pin(codec, spec->autocfg.inputs[i].pin); 3437 } 3438 3439 /* assign appropriate capture mixers */ 3440 static void set_capture_mixer(struct hda_codec *codec) 3441 { 3442 struct alc_spec *spec = codec->spec; 3443 static const struct snd_kcontrol_new *caps[2][3] = { 3444 { alc_capture_mixer_nosrc1, 3445 alc_capture_mixer_nosrc2, 3446 alc_capture_mixer_nosrc3 }, 3447 { alc_capture_mixer1, 3448 alc_capture_mixer2, 3449 alc_capture_mixer3 }, 3450 }; 3451 3452 /* check whether either of ADC or MUX has a volume control */ 3453 if (!nid_has_volume(codec, spec->adc_nids[0], HDA_INPUT)) { 3454 if (!spec->capsrc_nids) 3455 return; /* no volume */ 3456 if (!nid_has_volume(codec, spec->capsrc_nids[0], HDA_OUTPUT)) 3457 return; /* no volume in capsrc, too */ 3458 spec->vol_in_capsrc = 1; 3459 } 3460 3461 if (spec->num_adc_nids > 0) { 3462 int mux = 0; 3463 int num_adcs = 0; 3464 3465 if (spec->input_mux && spec->input_mux->num_items > 1) 3466 mux = 1; 3467 if (spec->auto_mic) { 3468 num_adcs = 1; 3469 mux = 0; 3470 } else if (spec->dyn_adc_switch) 3471 num_adcs = 1; 3472 if (!num_adcs) { 3473 if (spec->num_adc_nids > 3) 3474 spec->num_adc_nids = 3; 3475 else if (!spec->num_adc_nids) 3476 return; 3477 num_adcs = spec->num_adc_nids; 3478 } 3479 spec->cap_mixer = caps[mux][num_adcs - 1]; 3480 } 3481 } 3482 3483 /* 3484 * standard auto-parser initializations 3485 */ 3486 static void alc_auto_init_std(struct hda_codec *codec) 3487 { 3488 struct alc_spec *spec = codec->spec; 3489 alc_auto_init_multi_out(codec); 3490 alc_auto_init_extra_out(codec); 3491 alc_auto_init_analog_input(codec); 3492 alc_auto_init_input_src(codec); 3493 alc_auto_init_digital(codec); 3494 if (spec->unsol_event) 3495 alc_inithook(codec); 3496 } 3497 3498 /* 3499 * Digital-beep handlers 3500 */ 3501 #ifdef CONFIG_SND_HDA_INPUT_BEEP 3502 #define set_beep_amp(spec, nid, idx, dir) \ 3503 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir)) 3504 3505 static const struct snd_pci_quirk beep_white_list[] = { 3506 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1), 3507 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1), 3508 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1), 3509 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1), 3510 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1), 3511 {} 3512 }; 3513 3514 static inline int has_cdefine_beep(struct hda_codec *codec) 3515 { 3516 struct alc_spec *spec = codec->spec; 3517 const struct snd_pci_quirk *q; 3518 q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list); 3519 if (q) 3520 return q->value; 3521 return spec->cdefine.enable_pcbeep; 3522 } 3523 #else 3524 #define set_beep_amp(spec, nid, idx, dir) /* NOP */ 3525 #define has_cdefine_beep(codec) 0 3526 #endif 3527 3528 /* parse the BIOS configuration and set up the alc_spec */ 3529 /* return 1 if successful, 0 if the proper config is not found, 3530 * or a negative error code 3531 */ 3532 static int alc_parse_auto_config(struct hda_codec *codec, 3533 const hda_nid_t *ignore_nids, 3534 const hda_nid_t *ssid_nids) 3535 { 3536 struct alc_spec *spec = codec->spec; 3537 int err; 3538 3539 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 3540 ignore_nids); 3541 if (err < 0) 3542 return err; 3543 if (!spec->autocfg.line_outs) { 3544 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) { 3545 spec->multiout.max_channels = 2; 3546 spec->no_analog = 1; 3547 goto dig_only; 3548 } 3549 return 0; /* can't find valid BIOS pin config */ 3550 } 3551 err = alc_auto_fill_dac_nids(codec); 3552 if (err < 0) 3553 return err; 3554 err = alc_auto_add_multi_channel_mode(codec, alc_auto_fill_dac_nids); 3555 if (err < 0) 3556 return err; 3557 err = alc_auto_create_multi_out_ctls(codec, &spec->autocfg); 3558 if (err < 0) 3559 return err; 3560 err = alc_auto_create_hp_out(codec); 3561 if (err < 0) 3562 return err; 3563 err = alc_auto_create_speaker_out(codec); 3564 if (err < 0) 3565 return err; 3566 err = alc_auto_create_input_ctls(codec); 3567 if (err < 0) 3568 return err; 3569 3570 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 3571 3572 dig_only: 3573 alc_auto_parse_digital(codec); 3574 3575 if (!spec->no_analog) 3576 alc_remove_invalid_adc_nids(codec); 3577 3578 if (ssid_nids) 3579 alc_ssid_check(codec, ssid_nids); 3580 3581 if (!spec->no_analog) { 3582 alc_auto_check_switches(codec); 3583 err = alc_auto_add_mic_boost(codec); 3584 if (err < 0) 3585 return err; 3586 } 3587 3588 if (spec->kctls.list) 3589 add_mixer(spec, spec->kctls.list); 3590 3591 return 1; 3592 } 3593 3594 static int alc880_parse_auto_config(struct hda_codec *codec) 3595 { 3596 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 }; 3597 static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 3598 return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids); 3599 } 3600 3601 #ifdef CONFIG_SND_HDA_POWER_SAVE 3602 static const struct hda_amp_list alc880_loopbacks[] = { 3603 { 0x0b, HDA_INPUT, 0 }, 3604 { 0x0b, HDA_INPUT, 1 }, 3605 { 0x0b, HDA_INPUT, 2 }, 3606 { 0x0b, HDA_INPUT, 3 }, 3607 { 0x0b, HDA_INPUT, 4 }, 3608 { } /* end */ 3609 }; 3610 #endif 3611 3612 /* 3613 * board setups 3614 */ 3615 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS 3616 #define alc_board_config \ 3617 snd_hda_check_board_config 3618 #define alc_board_codec_sid_config \ 3619 snd_hda_check_board_codec_sid_config 3620 #include "alc_quirks.c" 3621 #else 3622 #define alc_board_config(codec, nums, models, tbl) -1 3623 #define alc_board_codec_sid_config(codec, nums, models, tbl) -1 3624 #define setup_preset(codec, x) /* NOP */ 3625 #endif 3626 3627 /* 3628 * OK, here we have finally the patch for ALC880 3629 */ 3630 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS 3631 #include "alc880_quirks.c" 3632 #endif 3633 3634 static int patch_alc880(struct hda_codec *codec) 3635 { 3636 struct alc_spec *spec; 3637 int board_config; 3638 int err; 3639 3640 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 3641 if (spec == NULL) 3642 return -ENOMEM; 3643 3644 codec->spec = spec; 3645 3646 spec->mixer_nid = 0x0b; 3647 spec->need_dac_fix = 1; 3648 3649 board_config = alc_board_config(codec, ALC880_MODEL_LAST, 3650 alc880_models, alc880_cfg_tbl); 3651 if (board_config < 0) { 3652 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 3653 codec->chip_name); 3654 board_config = ALC_MODEL_AUTO; 3655 } 3656 3657 if (board_config == ALC_MODEL_AUTO) { 3658 /* automatic parse from the BIOS config */ 3659 err = alc880_parse_auto_config(codec); 3660 if (err < 0) { 3661 alc_free(codec); 3662 return err; 3663 } 3664 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS 3665 else if (!err) { 3666 printk(KERN_INFO 3667 "hda_codec: Cannot set up configuration " 3668 "from BIOS. Using 3-stack mode...\n"); 3669 board_config = ALC880_3ST; 3670 } 3671 #endif 3672 } 3673 3674 if (board_config != ALC_MODEL_AUTO) 3675 setup_preset(codec, &alc880_presets[board_config]); 3676 3677 if (!spec->no_analog && !spec->adc_nids && spec->input_mux) { 3678 alc_auto_fill_adc_caps(codec); 3679 alc_rebuild_imux_for_auto_mic(codec); 3680 alc_remove_invalid_adc_nids(codec); 3681 } 3682 3683 if (!spec->no_analog && !spec->cap_mixer) 3684 set_capture_mixer(codec); 3685 3686 if (!spec->no_analog) { 3687 err = snd_hda_attach_beep_device(codec, 0x1); 3688 if (err < 0) { 3689 alc_free(codec); 3690 return err; 3691 } 3692 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 3693 } 3694 3695 spec->vmaster_nid = 0x0c; 3696 3697 codec->patch_ops = alc_patch_ops; 3698 if (board_config == ALC_MODEL_AUTO) 3699 spec->init_hook = alc_auto_init_std; 3700 #ifdef CONFIG_SND_HDA_POWER_SAVE 3701 if (!spec->loopback.amplist) 3702 spec->loopback.amplist = alc880_loopbacks; 3703 #endif 3704 3705 return 0; 3706 } 3707 3708 3709 /* 3710 * ALC260 support 3711 */ 3712 static int alc260_parse_auto_config(struct hda_codec *codec) 3713 { 3714 static const hda_nid_t alc260_ignore[] = { 0x17, 0 }; 3715 static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 }; 3716 return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids); 3717 } 3718 3719 #ifdef CONFIG_SND_HDA_POWER_SAVE 3720 static const struct hda_amp_list alc260_loopbacks[] = { 3721 { 0x07, HDA_INPUT, 0 }, 3722 { 0x07, HDA_INPUT, 1 }, 3723 { 0x07, HDA_INPUT, 2 }, 3724 { 0x07, HDA_INPUT, 3 }, 3725 { 0x07, HDA_INPUT, 4 }, 3726 { } /* end */ 3727 }; 3728 #endif 3729 3730 /* 3731 * Pin config fixes 3732 */ 3733 enum { 3734 PINFIX_HP_DC5750, 3735 }; 3736 3737 static const struct alc_fixup alc260_fixups[] = { 3738 [PINFIX_HP_DC5750] = { 3739 .type = ALC_FIXUP_PINS, 3740 .v.pins = (const struct alc_pincfg[]) { 3741 { 0x11, 0x90130110 }, /* speaker */ 3742 { } 3743 } 3744 }, 3745 }; 3746 3747 static const struct snd_pci_quirk alc260_fixup_tbl[] = { 3748 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750), 3749 {} 3750 }; 3751 3752 /* 3753 */ 3754 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS 3755 #include "alc260_quirks.c" 3756 #endif 3757 3758 static int patch_alc260(struct hda_codec *codec) 3759 { 3760 struct alc_spec *spec; 3761 int err, board_config; 3762 3763 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 3764 if (spec == NULL) 3765 return -ENOMEM; 3766 3767 codec->spec = spec; 3768 3769 spec->mixer_nid = 0x07; 3770 3771 board_config = alc_board_config(codec, ALC260_MODEL_LAST, 3772 alc260_models, alc260_cfg_tbl); 3773 if (board_config < 0) { 3774 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 3775 codec->chip_name); 3776 board_config = ALC_MODEL_AUTO; 3777 } 3778 3779 if (board_config == ALC_MODEL_AUTO) { 3780 alc_pick_fixup(codec, NULL, alc260_fixup_tbl, alc260_fixups); 3781 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE); 3782 } 3783 3784 if (board_config == ALC_MODEL_AUTO) { 3785 /* automatic parse from the BIOS config */ 3786 err = alc260_parse_auto_config(codec); 3787 if (err < 0) { 3788 alc_free(codec); 3789 return err; 3790 } 3791 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS 3792 else if (!err) { 3793 printk(KERN_INFO 3794 "hda_codec: Cannot set up configuration " 3795 "from BIOS. Using base mode...\n"); 3796 board_config = ALC260_BASIC; 3797 } 3798 #endif 3799 } 3800 3801 if (board_config != ALC_MODEL_AUTO) 3802 setup_preset(codec, &alc260_presets[board_config]); 3803 3804 if (!spec->no_analog && !spec->adc_nids && spec->input_mux) { 3805 alc_auto_fill_adc_caps(codec); 3806 alc_rebuild_imux_for_auto_mic(codec); 3807 alc_remove_invalid_adc_nids(codec); 3808 } 3809 3810 if (!spec->no_analog && !spec->cap_mixer) 3811 set_capture_mixer(codec); 3812 3813 if (!spec->no_analog) { 3814 err = snd_hda_attach_beep_device(codec, 0x1); 3815 if (err < 0) { 3816 alc_free(codec); 3817 return err; 3818 } 3819 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT); 3820 } 3821 3822 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE); 3823 3824 spec->vmaster_nid = 0x08; 3825 3826 codec->patch_ops = alc_patch_ops; 3827 if (board_config == ALC_MODEL_AUTO) 3828 spec->init_hook = alc_auto_init_std; 3829 spec->shutup = alc_eapd_shutup; 3830 #ifdef CONFIG_SND_HDA_POWER_SAVE 3831 if (!spec->loopback.amplist) 3832 spec->loopback.amplist = alc260_loopbacks; 3833 #endif 3834 3835 return 0; 3836 } 3837 3838 3839 /* 3840 * ALC882/883/885/888/889 support 3841 * 3842 * ALC882 is almost identical with ALC880 but has cleaner and more flexible 3843 * configuration. Each pin widget can choose any input DACs and a mixer. 3844 * Each ADC is connected from a mixer of all inputs. This makes possible 3845 * 6-channel independent captures. 3846 * 3847 * In addition, an independent DAC for the multi-playback (not used in this 3848 * driver yet). 3849 */ 3850 #ifdef CONFIG_SND_HDA_POWER_SAVE 3851 #define alc882_loopbacks alc880_loopbacks 3852 #endif 3853 3854 /* 3855 * Pin config fixes 3856 */ 3857 enum { 3858 PINFIX_ABIT_AW9D_MAX, 3859 PINFIX_LENOVO_Y530, 3860 PINFIX_PB_M5210, 3861 PINFIX_ACER_ASPIRE_7736, 3862 }; 3863 3864 static const struct alc_fixup alc882_fixups[] = { 3865 [PINFIX_ABIT_AW9D_MAX] = { 3866 .type = ALC_FIXUP_PINS, 3867 .v.pins = (const struct alc_pincfg[]) { 3868 { 0x15, 0x01080104 }, /* side */ 3869 { 0x16, 0x01011012 }, /* rear */ 3870 { 0x17, 0x01016011 }, /* clfe */ 3871 { } 3872 } 3873 }, 3874 [PINFIX_LENOVO_Y530] = { 3875 .type = ALC_FIXUP_PINS, 3876 .v.pins = (const struct alc_pincfg[]) { 3877 { 0x15, 0x99130112 }, /* rear int speakers */ 3878 { 0x16, 0x99130111 }, /* subwoofer */ 3879 { } 3880 } 3881 }, 3882 [PINFIX_PB_M5210] = { 3883 .type = ALC_FIXUP_VERBS, 3884 .v.verbs = (const struct hda_verb[]) { 3885 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 }, 3886 {} 3887 } 3888 }, 3889 [PINFIX_ACER_ASPIRE_7736] = { 3890 .type = ALC_FIXUP_SKU, 3891 .v.sku = ALC_FIXUP_SKU_IGNORE, 3892 }, 3893 }; 3894 3895 static const struct snd_pci_quirk alc882_fixup_tbl[] = { 3896 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210), 3897 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", PINFIX_LENOVO_Y530), 3898 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX), 3899 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", PINFIX_ACER_ASPIRE_7736), 3900 {} 3901 }; 3902 3903 /* 3904 * BIOS auto configuration 3905 */ 3906 /* almost identical with ALC880 parser... */ 3907 static int alc882_parse_auto_config(struct hda_codec *codec) 3908 { 3909 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 }; 3910 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 3911 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids); 3912 } 3913 3914 /* 3915 */ 3916 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS 3917 #include "alc882_quirks.c" 3918 #endif 3919 3920 static int patch_alc882(struct hda_codec *codec) 3921 { 3922 struct alc_spec *spec; 3923 int err, board_config; 3924 3925 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 3926 if (spec == NULL) 3927 return -ENOMEM; 3928 3929 codec->spec = spec; 3930 3931 spec->mixer_nid = 0x0b; 3932 3933 switch (codec->vendor_id) { 3934 case 0x10ec0882: 3935 case 0x10ec0885: 3936 break; 3937 default: 3938 /* ALC883 and variants */ 3939 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 3940 break; 3941 } 3942 3943 board_config = alc_board_config(codec, ALC882_MODEL_LAST, 3944 alc882_models, alc882_cfg_tbl); 3945 3946 if (board_config < 0) 3947 board_config = alc_board_codec_sid_config(codec, 3948 ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl); 3949 3950 if (board_config < 0) { 3951 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 3952 codec->chip_name); 3953 board_config = ALC_MODEL_AUTO; 3954 } 3955 3956 if (board_config == ALC_MODEL_AUTO) { 3957 alc_pick_fixup(codec, NULL, alc882_fixup_tbl, alc882_fixups); 3958 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE); 3959 } 3960 3961 alc_auto_parse_customize_define(codec); 3962 3963 if (board_config == ALC_MODEL_AUTO) { 3964 /* automatic parse from the BIOS config */ 3965 err = alc882_parse_auto_config(codec); 3966 if (err < 0) { 3967 alc_free(codec); 3968 return err; 3969 } 3970 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS 3971 else if (!err) { 3972 printk(KERN_INFO 3973 "hda_codec: Cannot set up configuration " 3974 "from BIOS. Using base mode...\n"); 3975 board_config = ALC882_3ST_DIG; 3976 } 3977 #endif 3978 } 3979 3980 if (board_config != ALC_MODEL_AUTO) 3981 setup_preset(codec, &alc882_presets[board_config]); 3982 3983 if (!spec->no_analog && !spec->adc_nids && spec->input_mux) { 3984 alc_auto_fill_adc_caps(codec); 3985 alc_rebuild_imux_for_auto_mic(codec); 3986 alc_remove_invalid_adc_nids(codec); 3987 } 3988 3989 if (!spec->no_analog && !spec->cap_mixer) 3990 set_capture_mixer(codec); 3991 3992 if (!spec->no_analog && has_cdefine_beep(codec)) { 3993 err = snd_hda_attach_beep_device(codec, 0x1); 3994 if (err < 0) { 3995 alc_free(codec); 3996 return err; 3997 } 3998 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 3999 } 4000 4001 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE); 4002 4003 spec->vmaster_nid = 0x0c; 4004 4005 codec->patch_ops = alc_patch_ops; 4006 if (board_config == ALC_MODEL_AUTO) 4007 spec->init_hook = alc_auto_init_std; 4008 4009 alc_init_jacks(codec); 4010 #ifdef CONFIG_SND_HDA_POWER_SAVE 4011 if (!spec->loopback.amplist) 4012 spec->loopback.amplist = alc882_loopbacks; 4013 #endif 4014 4015 return 0; 4016 } 4017 4018 4019 /* 4020 * ALC262 support 4021 */ 4022 static int alc262_parse_auto_config(struct hda_codec *codec) 4023 { 4024 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 }; 4025 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 4026 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids); 4027 } 4028 4029 /* 4030 * Pin config fixes 4031 */ 4032 enum { 4033 PINFIX_FSC_H270, 4034 PINFIX_HP_Z200, 4035 }; 4036 4037 static const struct alc_fixup alc262_fixups[] = { 4038 [PINFIX_FSC_H270] = { 4039 .type = ALC_FIXUP_PINS, 4040 .v.pins = (const struct alc_pincfg[]) { 4041 { 0x14, 0x99130110 }, /* speaker */ 4042 { 0x15, 0x0221142f }, /* front HP */ 4043 { 0x1b, 0x0121141f }, /* rear HP */ 4044 { } 4045 } 4046 }, 4047 [PINFIX_HP_Z200] = { 4048 .type = ALC_FIXUP_PINS, 4049 .v.pins = (const struct alc_pincfg[]) { 4050 { 0x16, 0x99130120 }, /* internal speaker */ 4051 { } 4052 } 4053 }, 4054 }; 4055 4056 static const struct snd_pci_quirk alc262_fixup_tbl[] = { 4057 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", PINFIX_HP_Z200), 4058 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270), 4059 {} 4060 }; 4061 4062 4063 #ifdef CONFIG_SND_HDA_POWER_SAVE 4064 #define alc262_loopbacks alc880_loopbacks 4065 #endif 4066 4067 /* 4068 */ 4069 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS 4070 #include "alc262_quirks.c" 4071 #endif 4072 4073 static int patch_alc262(struct hda_codec *codec) 4074 { 4075 struct alc_spec *spec; 4076 int board_config; 4077 int err; 4078 4079 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 4080 if (spec == NULL) 4081 return -ENOMEM; 4082 4083 codec->spec = spec; 4084 4085 spec->mixer_nid = 0x0b; 4086 4087 #if 0 4088 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is 4089 * under-run 4090 */ 4091 { 4092 int tmp; 4093 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7); 4094 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0); 4095 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7); 4096 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80); 4097 } 4098 #endif 4099 alc_auto_parse_customize_define(codec); 4100 4101 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 4102 4103 board_config = alc_board_config(codec, ALC262_MODEL_LAST, 4104 alc262_models, alc262_cfg_tbl); 4105 4106 if (board_config < 0) { 4107 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 4108 codec->chip_name); 4109 board_config = ALC_MODEL_AUTO; 4110 } 4111 4112 if (board_config == ALC_MODEL_AUTO) { 4113 alc_pick_fixup(codec, NULL, alc262_fixup_tbl, alc262_fixups); 4114 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE); 4115 } 4116 4117 if (board_config == ALC_MODEL_AUTO) { 4118 /* automatic parse from the BIOS config */ 4119 err = alc262_parse_auto_config(codec); 4120 if (err < 0) { 4121 alc_free(codec); 4122 return err; 4123 } 4124 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS 4125 else if (!err) { 4126 printk(KERN_INFO 4127 "hda_codec: Cannot set up configuration " 4128 "from BIOS. Using base mode...\n"); 4129 board_config = ALC262_BASIC; 4130 } 4131 #endif 4132 } 4133 4134 if (board_config != ALC_MODEL_AUTO) 4135 setup_preset(codec, &alc262_presets[board_config]); 4136 4137 if (!spec->no_analog && !spec->adc_nids && spec->input_mux) { 4138 alc_auto_fill_adc_caps(codec); 4139 alc_rebuild_imux_for_auto_mic(codec); 4140 alc_remove_invalid_adc_nids(codec); 4141 } 4142 4143 if (!spec->no_analog && !spec->cap_mixer) 4144 set_capture_mixer(codec); 4145 4146 if (!spec->no_analog && has_cdefine_beep(codec)) { 4147 err = snd_hda_attach_beep_device(codec, 0x1); 4148 if (err < 0) { 4149 alc_free(codec); 4150 return err; 4151 } 4152 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 4153 } 4154 4155 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE); 4156 4157 spec->vmaster_nid = 0x0c; 4158 4159 codec->patch_ops = alc_patch_ops; 4160 if (board_config == ALC_MODEL_AUTO) 4161 spec->init_hook = alc_auto_init_std; 4162 spec->shutup = alc_eapd_shutup; 4163 4164 alc_init_jacks(codec); 4165 #ifdef CONFIG_SND_HDA_POWER_SAVE 4166 if (!spec->loopback.amplist) 4167 spec->loopback.amplist = alc262_loopbacks; 4168 #endif 4169 4170 return 0; 4171 } 4172 4173 /* 4174 * ALC268 4175 */ 4176 /* bind Beep switches of both NID 0x0f and 0x10 */ 4177 static const struct hda_bind_ctls alc268_bind_beep_sw = { 4178 .ops = &snd_hda_bind_sw, 4179 .values = { 4180 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT), 4181 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT), 4182 0 4183 }, 4184 }; 4185 4186 static const struct snd_kcontrol_new alc268_beep_mixer[] = { 4187 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT), 4188 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw), 4189 { } 4190 }; 4191 4192 /* set PCBEEP vol = 0, mute connections */ 4193 static const struct hda_verb alc268_beep_init_verbs[] = { 4194 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4195 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4196 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4197 { } 4198 }; 4199 4200 /* 4201 * BIOS auto configuration 4202 */ 4203 static int alc268_parse_auto_config(struct hda_codec *codec) 4204 { 4205 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 4206 struct alc_spec *spec = codec->spec; 4207 int err = alc_parse_auto_config(codec, NULL, alc268_ssids); 4208 if (err > 0) { 4209 if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d) { 4210 add_mixer(spec, alc268_beep_mixer); 4211 add_verb(spec, alc268_beep_init_verbs); 4212 } 4213 } 4214 return err; 4215 } 4216 4217 /* 4218 */ 4219 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS 4220 #include "alc268_quirks.c" 4221 #endif 4222 4223 static int patch_alc268(struct hda_codec *codec) 4224 { 4225 struct alc_spec *spec; 4226 int board_config; 4227 int i, has_beep, err; 4228 4229 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 4230 if (spec == NULL) 4231 return -ENOMEM; 4232 4233 codec->spec = spec; 4234 4235 /* ALC268 has no aa-loopback mixer */ 4236 4237 board_config = alc_board_config(codec, ALC268_MODEL_LAST, 4238 alc268_models, alc268_cfg_tbl); 4239 4240 if (board_config < 0) 4241 board_config = alc_board_codec_sid_config(codec, 4242 ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl); 4243 4244 if (board_config < 0) { 4245 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 4246 codec->chip_name); 4247 board_config = ALC_MODEL_AUTO; 4248 } 4249 4250 if (board_config == ALC_MODEL_AUTO) { 4251 /* automatic parse from the BIOS config */ 4252 err = alc268_parse_auto_config(codec); 4253 if (err < 0) { 4254 alc_free(codec); 4255 return err; 4256 } 4257 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS 4258 else if (!err) { 4259 printk(KERN_INFO 4260 "hda_codec: Cannot set up configuration " 4261 "from BIOS. Using base mode...\n"); 4262 board_config = ALC268_3ST; 4263 } 4264 #endif 4265 } 4266 4267 if (board_config != ALC_MODEL_AUTO) 4268 setup_preset(codec, &alc268_presets[board_config]); 4269 4270 has_beep = 0; 4271 for (i = 0; i < spec->num_mixers; i++) { 4272 if (spec->mixers[i] == alc268_beep_mixer) { 4273 has_beep = 1; 4274 break; 4275 } 4276 } 4277 4278 if (has_beep) { 4279 err = snd_hda_attach_beep_device(codec, 0x1); 4280 if (err < 0) { 4281 alc_free(codec); 4282 return err; 4283 } 4284 if (!query_amp_caps(codec, 0x1d, HDA_INPUT)) 4285 /* override the amp caps for beep generator */ 4286 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT, 4287 (0x0c << AC_AMPCAP_OFFSET_SHIFT) | 4288 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) | 4289 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) | 4290 (0 << AC_AMPCAP_MUTE_SHIFT)); 4291 } 4292 4293 if (!spec->no_analog && !spec->adc_nids && spec->input_mux) { 4294 alc_auto_fill_adc_caps(codec); 4295 alc_rebuild_imux_for_auto_mic(codec); 4296 alc_remove_invalid_adc_nids(codec); 4297 } 4298 4299 if (!spec->no_analog && !spec->cap_mixer) 4300 set_capture_mixer(codec); 4301 4302 spec->vmaster_nid = 0x02; 4303 4304 codec->patch_ops = alc_patch_ops; 4305 if (board_config == ALC_MODEL_AUTO) 4306 spec->init_hook = alc_auto_init_std; 4307 spec->shutup = alc_eapd_shutup; 4308 4309 alc_init_jacks(codec); 4310 4311 return 0; 4312 } 4313 4314 /* 4315 * ALC269 4316 */ 4317 #ifdef CONFIG_SND_HDA_POWER_SAVE 4318 #define alc269_loopbacks alc880_loopbacks 4319 #endif 4320 4321 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = { 4322 .substreams = 1, 4323 .channels_min = 2, 4324 .channels_max = 8, 4325 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */ 4326 /* NID is set in alc_build_pcms */ 4327 .ops = { 4328 .open = alc_playback_pcm_open, 4329 .prepare = alc_playback_pcm_prepare, 4330 .cleanup = alc_playback_pcm_cleanup 4331 }, 4332 }; 4333 4334 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = { 4335 .substreams = 1, 4336 .channels_min = 2, 4337 .channels_max = 2, 4338 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */ 4339 /* NID is set in alc_build_pcms */ 4340 }; 4341 4342 #ifdef CONFIG_SND_HDA_POWER_SAVE 4343 static int alc269_mic2_for_mute_led(struct hda_codec *codec) 4344 { 4345 switch (codec->subsystem_id) { 4346 case 0x103c1586: 4347 return 1; 4348 } 4349 return 0; 4350 } 4351 4352 static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid) 4353 { 4354 /* update mute-LED according to the speaker mute state */ 4355 if (nid == 0x01 || nid == 0x14) { 4356 int pinval; 4357 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) & 4358 HDA_AMP_MUTE) 4359 pinval = 0x24; 4360 else 4361 pinval = 0x20; 4362 /* mic2 vref pin is used for mute LED control */ 4363 snd_hda_codec_update_cache(codec, 0x19, 0, 4364 AC_VERB_SET_PIN_WIDGET_CONTROL, 4365 pinval); 4366 } 4367 return alc_check_power_status(codec, nid); 4368 } 4369 #endif /* CONFIG_SND_HDA_POWER_SAVE */ 4370 4371 /* different alc269-variants */ 4372 enum { 4373 ALC269_TYPE_ALC269VA, 4374 ALC269_TYPE_ALC269VB, 4375 ALC269_TYPE_ALC269VC, 4376 }; 4377 4378 /* 4379 * BIOS auto configuration 4380 */ 4381 static int alc269_parse_auto_config(struct hda_codec *codec) 4382 { 4383 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 }; 4384 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 }; 4385 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 4386 struct alc_spec *spec = codec->spec; 4387 const hda_nid_t *ssids = spec->codec_variant == ALC269_TYPE_ALC269VA ? 4388 alc269va_ssids : alc269_ssids; 4389 4390 return alc_parse_auto_config(codec, alc269_ignore, ssids); 4391 } 4392 4393 static void alc269_toggle_power_output(struct hda_codec *codec, int power_up) 4394 { 4395 int val = alc_read_coef_idx(codec, 0x04); 4396 if (power_up) 4397 val |= 1 << 11; 4398 else 4399 val &= ~(1 << 11); 4400 alc_write_coef_idx(codec, 0x04, val); 4401 } 4402 4403 static void alc269_shutup(struct hda_codec *codec) 4404 { 4405 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) 4406 alc269_toggle_power_output(codec, 0); 4407 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) { 4408 alc269_toggle_power_output(codec, 0); 4409 msleep(150); 4410 } 4411 } 4412 4413 #ifdef SND_HDA_NEEDS_RESUME 4414 static int alc269_resume(struct hda_codec *codec) 4415 { 4416 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) { 4417 alc269_toggle_power_output(codec, 0); 4418 msleep(150); 4419 } 4420 4421 codec->patch_ops.init(codec); 4422 4423 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) { 4424 alc269_toggle_power_output(codec, 1); 4425 msleep(200); 4426 } 4427 4428 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) 4429 alc269_toggle_power_output(codec, 1); 4430 4431 snd_hda_codec_resume_amp(codec); 4432 snd_hda_codec_resume_cache(codec); 4433 hda_call_check_power_status(codec, 0x01); 4434 return 0; 4435 } 4436 #endif /* SND_HDA_NEEDS_RESUME */ 4437 4438 static void alc269_fixup_hweq(struct hda_codec *codec, 4439 const struct alc_fixup *fix, int action) 4440 { 4441 int coef; 4442 4443 if (action != ALC_FIXUP_ACT_INIT) 4444 return; 4445 coef = alc_read_coef_idx(codec, 0x1e); 4446 alc_write_coef_idx(codec, 0x1e, coef | 0x80); 4447 } 4448 4449 static void alc271_fixup_dmic(struct hda_codec *codec, 4450 const struct alc_fixup *fix, int action) 4451 { 4452 static const struct hda_verb verbs[] = { 4453 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d}, 4454 {0x20, AC_VERB_SET_PROC_COEF, 0x4000}, 4455 {} 4456 }; 4457 unsigned int cfg; 4458 4459 if (strcmp(codec->chip_name, "ALC271X")) 4460 return; 4461 cfg = snd_hda_codec_get_pincfg(codec, 0x12); 4462 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED) 4463 snd_hda_sequence_write(codec, verbs); 4464 } 4465 4466 static void alc269_fixup_pcm_44k(struct hda_codec *codec, 4467 const struct alc_fixup *fix, int action) 4468 { 4469 struct alc_spec *spec = codec->spec; 4470 4471 if (action != ALC_FIXUP_ACT_PROBE) 4472 return; 4473 4474 /* Due to a hardware problem on Lenovo Ideadpad, we need to 4475 * fix the sample rate of analog I/O to 44.1kHz 4476 */ 4477 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback; 4478 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture; 4479 } 4480 4481 enum { 4482 ALC269_FIXUP_SONY_VAIO, 4483 ALC275_FIXUP_SONY_VAIO_GPIO2, 4484 ALC269_FIXUP_DELL_M101Z, 4485 ALC269_FIXUP_SKU_IGNORE, 4486 ALC269_FIXUP_ASUS_G73JW, 4487 ALC269_FIXUP_LENOVO_EAPD, 4488 ALC275_FIXUP_SONY_HWEQ, 4489 ALC271_FIXUP_DMIC, 4490 ALC269_FIXUP_PCM_44K, 4491 }; 4492 4493 static const struct alc_fixup alc269_fixups[] = { 4494 [ALC269_FIXUP_SONY_VAIO] = { 4495 .type = ALC_FIXUP_VERBS, 4496 .v.verbs = (const struct hda_verb[]) { 4497 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD}, 4498 {} 4499 } 4500 }, 4501 [ALC275_FIXUP_SONY_VAIO_GPIO2] = { 4502 .type = ALC_FIXUP_VERBS, 4503 .v.verbs = (const struct hda_verb[]) { 4504 {0x01, AC_VERB_SET_GPIO_MASK, 0x04}, 4505 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04}, 4506 {0x01, AC_VERB_SET_GPIO_DATA, 0x00}, 4507 { } 4508 }, 4509 .chained = true, 4510 .chain_id = ALC269_FIXUP_SONY_VAIO 4511 }, 4512 [ALC269_FIXUP_DELL_M101Z] = { 4513 .type = ALC_FIXUP_VERBS, 4514 .v.verbs = (const struct hda_verb[]) { 4515 /* Enables internal speaker */ 4516 {0x20, AC_VERB_SET_COEF_INDEX, 13}, 4517 {0x20, AC_VERB_SET_PROC_COEF, 0x4040}, 4518 {} 4519 } 4520 }, 4521 [ALC269_FIXUP_SKU_IGNORE] = { 4522 .type = ALC_FIXUP_SKU, 4523 .v.sku = ALC_FIXUP_SKU_IGNORE, 4524 }, 4525 [ALC269_FIXUP_ASUS_G73JW] = { 4526 .type = ALC_FIXUP_PINS, 4527 .v.pins = (const struct alc_pincfg[]) { 4528 { 0x17, 0x99130111 }, /* subwoofer */ 4529 { } 4530 } 4531 }, 4532 [ALC269_FIXUP_LENOVO_EAPD] = { 4533 .type = ALC_FIXUP_VERBS, 4534 .v.verbs = (const struct hda_verb[]) { 4535 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0}, 4536 {} 4537 } 4538 }, 4539 [ALC275_FIXUP_SONY_HWEQ] = { 4540 .type = ALC_FIXUP_FUNC, 4541 .v.func = alc269_fixup_hweq, 4542 .chained = true, 4543 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2 4544 }, 4545 [ALC271_FIXUP_DMIC] = { 4546 .type = ALC_FIXUP_FUNC, 4547 .v.func = alc271_fixup_dmic, 4548 }, 4549 [ALC269_FIXUP_PCM_44K] = { 4550 .type = ALC_FIXUP_FUNC, 4551 .v.func = alc269_fixup_pcm_44k, 4552 }, 4553 }; 4554 4555 static const struct snd_pci_quirk alc269_fixup_tbl[] = { 4556 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW), 4557 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2), 4558 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ), 4559 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ), 4560 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO), 4561 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z), 4562 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC), 4563 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE), 4564 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE), 4565 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE), 4566 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE), 4567 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE), 4568 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Lenovo Ideapd", ALC269_FIXUP_PCM_44K), 4569 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD), 4570 {} 4571 }; 4572 4573 4574 static int alc269_fill_coef(struct hda_codec *codec) 4575 { 4576 int val; 4577 4578 if ((alc_read_coef_idx(codec, 0) & 0x00ff) < 0x015) { 4579 alc_write_coef_idx(codec, 0xf, 0x960b); 4580 alc_write_coef_idx(codec, 0xe, 0x8817); 4581 } 4582 4583 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x016) { 4584 alc_write_coef_idx(codec, 0xf, 0x960b); 4585 alc_write_coef_idx(codec, 0xe, 0x8814); 4586 } 4587 4588 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) { 4589 val = alc_read_coef_idx(codec, 0x04); 4590 /* Power up output pin */ 4591 alc_write_coef_idx(codec, 0x04, val | (1<<11)); 4592 } 4593 4594 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) { 4595 val = alc_read_coef_idx(codec, 0xd); 4596 if ((val & 0x0c00) >> 10 != 0x1) { 4597 /* Capless ramp up clock control */ 4598 alc_write_coef_idx(codec, 0xd, val | (1<<10)); 4599 } 4600 val = alc_read_coef_idx(codec, 0x17); 4601 if ((val & 0x01c0) >> 6 != 0x4) { 4602 /* Class D power on reset */ 4603 alc_write_coef_idx(codec, 0x17, val | (1<<7)); 4604 } 4605 } 4606 4607 val = alc_read_coef_idx(codec, 0xd); /* Class D */ 4608 alc_write_coef_idx(codec, 0xd, val | (1<<14)); 4609 4610 val = alc_read_coef_idx(codec, 0x4); /* HP */ 4611 alc_write_coef_idx(codec, 0x4, val | (1<<11)); 4612 4613 return 0; 4614 } 4615 4616 /* 4617 */ 4618 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS 4619 #include "alc269_quirks.c" 4620 #endif 4621 4622 static int patch_alc269(struct hda_codec *codec) 4623 { 4624 struct alc_spec *spec; 4625 int board_config, coef; 4626 int err; 4627 4628 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 4629 if (spec == NULL) 4630 return -ENOMEM; 4631 4632 codec->spec = spec; 4633 4634 spec->mixer_nid = 0x0b; 4635 4636 alc_auto_parse_customize_define(codec); 4637 4638 if (codec->vendor_id == 0x10ec0269) { 4639 spec->codec_variant = ALC269_TYPE_ALC269VA; 4640 coef = alc_read_coef_idx(codec, 0); 4641 if ((coef & 0x00f0) == 0x0010) { 4642 if (codec->bus->pci->subsystem_vendor == 0x1025 && 4643 spec->cdefine.platform_type == 1) { 4644 alc_codec_rename(codec, "ALC271X"); 4645 } else if ((coef & 0xf000) == 0x2000) { 4646 alc_codec_rename(codec, "ALC259"); 4647 } else if ((coef & 0xf000) == 0x3000) { 4648 alc_codec_rename(codec, "ALC258"); 4649 } else if ((coef & 0xfff0) == 0x3010) { 4650 alc_codec_rename(codec, "ALC277"); 4651 } else { 4652 alc_codec_rename(codec, "ALC269VB"); 4653 } 4654 spec->codec_variant = ALC269_TYPE_ALC269VB; 4655 } else if ((coef & 0x00f0) == 0x0020) { 4656 if (coef == 0xa023) 4657 alc_codec_rename(codec, "ALC259"); 4658 else if (coef == 0x6023) 4659 alc_codec_rename(codec, "ALC281X"); 4660 else if (codec->bus->pci->subsystem_vendor == 0x17aa && 4661 codec->bus->pci->subsystem_device == 0x21f3) 4662 alc_codec_rename(codec, "ALC3202"); 4663 else 4664 alc_codec_rename(codec, "ALC269VC"); 4665 spec->codec_variant = ALC269_TYPE_ALC269VC; 4666 } else 4667 alc_fix_pll_init(codec, 0x20, 0x04, 15); 4668 alc269_fill_coef(codec); 4669 } 4670 4671 board_config = alc_board_config(codec, ALC269_MODEL_LAST, 4672 alc269_models, alc269_cfg_tbl); 4673 4674 if (board_config < 0) { 4675 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 4676 codec->chip_name); 4677 board_config = ALC_MODEL_AUTO; 4678 } 4679 4680 if (board_config == ALC_MODEL_AUTO) { 4681 alc_pick_fixup(codec, NULL, alc269_fixup_tbl, alc269_fixups); 4682 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE); 4683 } 4684 4685 if (board_config == ALC_MODEL_AUTO) { 4686 /* automatic parse from the BIOS config */ 4687 err = alc269_parse_auto_config(codec); 4688 if (err < 0) { 4689 alc_free(codec); 4690 return err; 4691 } 4692 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS 4693 else if (!err) { 4694 printk(KERN_INFO 4695 "hda_codec: Cannot set up configuration " 4696 "from BIOS. Using base mode...\n"); 4697 board_config = ALC269_BASIC; 4698 } 4699 #endif 4700 } 4701 4702 if (board_config != ALC_MODEL_AUTO) 4703 setup_preset(codec, &alc269_presets[board_config]); 4704 4705 if (!spec->no_analog && !spec->adc_nids && spec->input_mux) { 4706 alc_auto_fill_adc_caps(codec); 4707 alc_rebuild_imux_for_auto_mic(codec); 4708 alc_remove_invalid_adc_nids(codec); 4709 } 4710 4711 if (!spec->no_analog && !spec->cap_mixer) 4712 set_capture_mixer(codec); 4713 4714 if (!spec->no_analog && has_cdefine_beep(codec)) { 4715 err = snd_hda_attach_beep_device(codec, 0x1); 4716 if (err < 0) { 4717 alc_free(codec); 4718 return err; 4719 } 4720 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT); 4721 } 4722 4723 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE); 4724 4725 spec->vmaster_nid = 0x02; 4726 4727 codec->patch_ops = alc_patch_ops; 4728 #ifdef SND_HDA_NEEDS_RESUME 4729 codec->patch_ops.resume = alc269_resume; 4730 #endif 4731 if (board_config == ALC_MODEL_AUTO) 4732 spec->init_hook = alc_auto_init_std; 4733 spec->shutup = alc269_shutup; 4734 4735 alc_init_jacks(codec); 4736 #ifdef CONFIG_SND_HDA_POWER_SAVE 4737 if (!spec->loopback.amplist) 4738 spec->loopback.amplist = alc269_loopbacks; 4739 if (alc269_mic2_for_mute_led(codec)) 4740 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps; 4741 #endif 4742 4743 return 0; 4744 } 4745 4746 /* 4747 * ALC861 4748 */ 4749 4750 static int alc861_parse_auto_config(struct hda_codec *codec) 4751 { 4752 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 }; 4753 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 }; 4754 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids); 4755 } 4756 4757 #ifdef CONFIG_SND_HDA_POWER_SAVE 4758 static const struct hda_amp_list alc861_loopbacks[] = { 4759 { 0x15, HDA_INPUT, 0 }, 4760 { 0x15, HDA_INPUT, 1 }, 4761 { 0x15, HDA_INPUT, 2 }, 4762 { 0x15, HDA_INPUT, 3 }, 4763 { } /* end */ 4764 }; 4765 #endif 4766 4767 4768 /* Pin config fixes */ 4769 enum { 4770 PINFIX_FSC_AMILO_PI1505, 4771 }; 4772 4773 static const struct alc_fixup alc861_fixups[] = { 4774 [PINFIX_FSC_AMILO_PI1505] = { 4775 .type = ALC_FIXUP_PINS, 4776 .v.pins = (const struct alc_pincfg[]) { 4777 { 0x0b, 0x0221101f }, /* HP */ 4778 { 0x0f, 0x90170310 }, /* speaker */ 4779 { } 4780 } 4781 }, 4782 }; 4783 4784 static const struct snd_pci_quirk alc861_fixup_tbl[] = { 4785 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505), 4786 {} 4787 }; 4788 4789 /* 4790 */ 4791 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS 4792 #include "alc861_quirks.c" 4793 #endif 4794 4795 static int patch_alc861(struct hda_codec *codec) 4796 { 4797 struct alc_spec *spec; 4798 int board_config; 4799 int err; 4800 4801 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 4802 if (spec == NULL) 4803 return -ENOMEM; 4804 4805 codec->spec = spec; 4806 4807 spec->mixer_nid = 0x15; 4808 4809 board_config = alc_board_config(codec, ALC861_MODEL_LAST, 4810 alc861_models, alc861_cfg_tbl); 4811 4812 if (board_config < 0) { 4813 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 4814 codec->chip_name); 4815 board_config = ALC_MODEL_AUTO; 4816 } 4817 4818 if (board_config == ALC_MODEL_AUTO) { 4819 alc_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups); 4820 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE); 4821 } 4822 4823 if (board_config == ALC_MODEL_AUTO) { 4824 /* automatic parse from the BIOS config */ 4825 err = alc861_parse_auto_config(codec); 4826 if (err < 0) { 4827 alc_free(codec); 4828 return err; 4829 } 4830 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS 4831 else if (!err) { 4832 printk(KERN_INFO 4833 "hda_codec: Cannot set up configuration " 4834 "from BIOS. Using base mode...\n"); 4835 board_config = ALC861_3ST_DIG; 4836 } 4837 #endif 4838 } 4839 4840 if (board_config != ALC_MODEL_AUTO) 4841 setup_preset(codec, &alc861_presets[board_config]); 4842 4843 if (!spec->no_analog && !spec->adc_nids && spec->input_mux) { 4844 alc_auto_fill_adc_caps(codec); 4845 alc_rebuild_imux_for_auto_mic(codec); 4846 alc_remove_invalid_adc_nids(codec); 4847 } 4848 4849 if (!spec->no_analog && !spec->cap_mixer) 4850 set_capture_mixer(codec); 4851 4852 if (!spec->no_analog) { 4853 err = snd_hda_attach_beep_device(codec, 0x23); 4854 if (err < 0) { 4855 alc_free(codec); 4856 return err; 4857 } 4858 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT); 4859 } 4860 4861 spec->vmaster_nid = 0x03; 4862 4863 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE); 4864 4865 codec->patch_ops = alc_patch_ops; 4866 if (board_config == ALC_MODEL_AUTO) { 4867 spec->init_hook = alc_auto_init_std; 4868 #ifdef CONFIG_SND_HDA_POWER_SAVE 4869 spec->power_hook = alc_power_eapd; 4870 #endif 4871 } 4872 #ifdef CONFIG_SND_HDA_POWER_SAVE 4873 if (!spec->loopback.amplist) 4874 spec->loopback.amplist = alc861_loopbacks; 4875 #endif 4876 4877 return 0; 4878 } 4879 4880 /* 4881 * ALC861-VD support 4882 * 4883 * Based on ALC882 4884 * 4885 * In addition, an independent DAC 4886 */ 4887 #ifdef CONFIG_SND_HDA_POWER_SAVE 4888 #define alc861vd_loopbacks alc880_loopbacks 4889 #endif 4890 4891 static int alc861vd_parse_auto_config(struct hda_codec *codec) 4892 { 4893 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 }; 4894 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 4895 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids); 4896 } 4897 4898 enum { 4899 ALC660VD_FIX_ASUS_GPIO1 4900 }; 4901 4902 /* reset GPIO1 */ 4903 static const struct alc_fixup alc861vd_fixups[] = { 4904 [ALC660VD_FIX_ASUS_GPIO1] = { 4905 .type = ALC_FIXUP_VERBS, 4906 .v.verbs = (const struct hda_verb[]) { 4907 {0x01, AC_VERB_SET_GPIO_MASK, 0x03}, 4908 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, 4909 {0x01, AC_VERB_SET_GPIO_DATA, 0x01}, 4910 { } 4911 } 4912 }, 4913 }; 4914 4915 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = { 4916 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1), 4917 {} 4918 }; 4919 4920 static const struct hda_verb alc660vd_eapd_verbs[] = { 4921 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 4922 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 4923 { } 4924 }; 4925 4926 /* 4927 */ 4928 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS 4929 #include "alc861vd_quirks.c" 4930 #endif 4931 4932 static int patch_alc861vd(struct hda_codec *codec) 4933 { 4934 struct alc_spec *spec; 4935 int err, board_config; 4936 4937 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 4938 if (spec == NULL) 4939 return -ENOMEM; 4940 4941 codec->spec = spec; 4942 4943 spec->mixer_nid = 0x0b; 4944 4945 board_config = alc_board_config(codec, ALC861VD_MODEL_LAST, 4946 alc861vd_models, alc861vd_cfg_tbl); 4947 4948 if (board_config < 0) { 4949 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 4950 codec->chip_name); 4951 board_config = ALC_MODEL_AUTO; 4952 } 4953 4954 if (board_config == ALC_MODEL_AUTO) { 4955 alc_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups); 4956 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE); 4957 } 4958 4959 if (board_config == ALC_MODEL_AUTO) { 4960 /* automatic parse from the BIOS config */ 4961 err = alc861vd_parse_auto_config(codec); 4962 if (err < 0) { 4963 alc_free(codec); 4964 return err; 4965 } 4966 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS 4967 else if (!err) { 4968 printk(KERN_INFO 4969 "hda_codec: Cannot set up configuration " 4970 "from BIOS. Using base mode...\n"); 4971 board_config = ALC861VD_3ST; 4972 } 4973 #endif 4974 } 4975 4976 if (board_config != ALC_MODEL_AUTO) 4977 setup_preset(codec, &alc861vd_presets[board_config]); 4978 4979 if (codec->vendor_id == 0x10ec0660) { 4980 /* always turn on EAPD */ 4981 add_verb(spec, alc660vd_eapd_verbs); 4982 } 4983 4984 if (!spec->no_analog && !spec->adc_nids && spec->input_mux) { 4985 alc_auto_fill_adc_caps(codec); 4986 alc_rebuild_imux_for_auto_mic(codec); 4987 alc_remove_invalid_adc_nids(codec); 4988 } 4989 4990 if (!spec->no_analog && !spec->cap_mixer) 4991 set_capture_mixer(codec); 4992 4993 if (!spec->no_analog) { 4994 err = snd_hda_attach_beep_device(codec, 0x23); 4995 if (err < 0) { 4996 alc_free(codec); 4997 return err; 4998 } 4999 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 5000 } 5001 5002 spec->vmaster_nid = 0x02; 5003 5004 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE); 5005 5006 codec->patch_ops = alc_patch_ops; 5007 5008 if (board_config == ALC_MODEL_AUTO) 5009 spec->init_hook = alc_auto_init_std; 5010 spec->shutup = alc_eapd_shutup; 5011 #ifdef CONFIG_SND_HDA_POWER_SAVE 5012 if (!spec->loopback.amplist) 5013 spec->loopback.amplist = alc861vd_loopbacks; 5014 #endif 5015 5016 return 0; 5017 } 5018 5019 /* 5020 * ALC662 support 5021 * 5022 * ALC662 is almost identical with ALC880 but has cleaner and more flexible 5023 * configuration. Each pin widget can choose any input DACs and a mixer. 5024 * Each ADC is connected from a mixer of all inputs. This makes possible 5025 * 6-channel independent captures. 5026 * 5027 * In addition, an independent DAC for the multi-playback (not used in this 5028 * driver yet). 5029 */ 5030 #ifdef CONFIG_SND_HDA_POWER_SAVE 5031 #define alc662_loopbacks alc880_loopbacks 5032 #endif 5033 5034 /* 5035 * BIOS auto configuration 5036 */ 5037 5038 static int alc662_parse_auto_config(struct hda_codec *codec) 5039 { 5040 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 }; 5041 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 }; 5042 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 }; 5043 const hda_nid_t *ssids; 5044 5045 if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 || 5046 codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670) 5047 ssids = alc663_ssids; 5048 else 5049 ssids = alc662_ssids; 5050 return alc_parse_auto_config(codec, alc662_ignore, ssids); 5051 } 5052 5053 static void alc272_fixup_mario(struct hda_codec *codec, 5054 const struct alc_fixup *fix, int action) 5055 { 5056 if (action != ALC_FIXUP_ACT_PROBE) 5057 return; 5058 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT, 5059 (0x3b << AC_AMPCAP_OFFSET_SHIFT) | 5060 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) | 5061 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) | 5062 (0 << AC_AMPCAP_MUTE_SHIFT))) 5063 printk(KERN_WARNING 5064 "hda_codec: failed to override amp caps for NID 0x2\n"); 5065 } 5066 5067 enum { 5068 ALC662_FIXUP_ASPIRE, 5069 ALC662_FIXUP_IDEAPAD, 5070 ALC272_FIXUP_MARIO, 5071 ALC662_FIXUP_CZC_P10T, 5072 ALC662_FIXUP_SKU_IGNORE, 5073 ALC662_FIXUP_HP_RP5800, 5074 }; 5075 5076 static const struct alc_fixup alc662_fixups[] = { 5077 [ALC662_FIXUP_ASPIRE] = { 5078 .type = ALC_FIXUP_PINS, 5079 .v.pins = (const struct alc_pincfg[]) { 5080 { 0x15, 0x99130112 }, /* subwoofer */ 5081 { } 5082 } 5083 }, 5084 [ALC662_FIXUP_IDEAPAD] = { 5085 .type = ALC_FIXUP_PINS, 5086 .v.pins = (const struct alc_pincfg[]) { 5087 { 0x17, 0x99130112 }, /* subwoofer */ 5088 { } 5089 } 5090 }, 5091 [ALC272_FIXUP_MARIO] = { 5092 .type = ALC_FIXUP_FUNC, 5093 .v.func = alc272_fixup_mario, 5094 }, 5095 [ALC662_FIXUP_CZC_P10T] = { 5096 .type = ALC_FIXUP_VERBS, 5097 .v.verbs = (const struct hda_verb[]) { 5098 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0}, 5099 {} 5100 } 5101 }, 5102 [ALC662_FIXUP_SKU_IGNORE] = { 5103 .type = ALC_FIXUP_SKU, 5104 .v.sku = ALC_FIXUP_SKU_IGNORE, 5105 }, 5106 [ALC662_FIXUP_HP_RP5800] = { 5107 .type = ALC_FIXUP_PINS, 5108 .v.pins = (const struct alc_pincfg[]) { 5109 { 0x14, 0x0221201f }, /* HP out */ 5110 { } 5111 }, 5112 .chained = true, 5113 .chain_id = ALC662_FIXUP_SKU_IGNORE 5114 }, 5115 }; 5116 5117 static const struct snd_pci_quirk alc662_fixup_tbl[] = { 5118 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE), 5119 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE), 5120 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE), 5121 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800), 5122 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD), 5123 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD), 5124 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD), 5125 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T), 5126 {} 5127 }; 5128 5129 static const struct alc_model_fixup alc662_fixup_models[] = { 5130 {.id = ALC272_FIXUP_MARIO, .name = "mario"}, 5131 {} 5132 }; 5133 5134 5135 /* 5136 */ 5137 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS 5138 #include "alc662_quirks.c" 5139 #endif 5140 5141 static int patch_alc662(struct hda_codec *codec) 5142 { 5143 struct alc_spec *spec; 5144 int err, board_config; 5145 int coef; 5146 5147 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5148 if (!spec) 5149 return -ENOMEM; 5150 5151 codec->spec = spec; 5152 5153 spec->mixer_nid = 0x0b; 5154 5155 alc_auto_parse_customize_define(codec); 5156 5157 alc_fix_pll_init(codec, 0x20, 0x04, 15); 5158 5159 coef = alc_read_coef_idx(codec, 0); 5160 if (coef == 0x8020 || coef == 0x8011) 5161 alc_codec_rename(codec, "ALC661"); 5162 else if (coef & (1 << 14) && 5163 codec->bus->pci->subsystem_vendor == 0x1025 && 5164 spec->cdefine.platform_type == 1) 5165 alc_codec_rename(codec, "ALC272X"); 5166 else if (coef == 0x4011) 5167 alc_codec_rename(codec, "ALC656"); 5168 5169 board_config = alc_board_config(codec, ALC662_MODEL_LAST, 5170 alc662_models, alc662_cfg_tbl); 5171 if (board_config < 0) { 5172 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 5173 codec->chip_name); 5174 board_config = ALC_MODEL_AUTO; 5175 } 5176 5177 if (board_config == ALC_MODEL_AUTO) { 5178 alc_pick_fixup(codec, alc662_fixup_models, 5179 alc662_fixup_tbl, alc662_fixups); 5180 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE); 5181 /* automatic parse from the BIOS config */ 5182 err = alc662_parse_auto_config(codec); 5183 if (err < 0) { 5184 alc_free(codec); 5185 return err; 5186 } 5187 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS 5188 else if (!err) { 5189 printk(KERN_INFO 5190 "hda_codec: Cannot set up configuration " 5191 "from BIOS. Using base mode...\n"); 5192 board_config = ALC662_3ST_2ch_DIG; 5193 } 5194 #endif 5195 } 5196 5197 if (board_config != ALC_MODEL_AUTO) 5198 setup_preset(codec, &alc662_presets[board_config]); 5199 5200 if (!spec->no_analog && !spec->adc_nids && spec->input_mux) { 5201 alc_auto_fill_adc_caps(codec); 5202 alc_rebuild_imux_for_auto_mic(codec); 5203 alc_remove_invalid_adc_nids(codec); 5204 } 5205 5206 if (!spec->no_analog && !spec->cap_mixer) 5207 set_capture_mixer(codec); 5208 5209 if (!spec->no_analog && has_cdefine_beep(codec)) { 5210 err = snd_hda_attach_beep_device(codec, 0x1); 5211 if (err < 0) { 5212 alc_free(codec); 5213 return err; 5214 } 5215 switch (codec->vendor_id) { 5216 case 0x10ec0662: 5217 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 5218 break; 5219 case 0x10ec0272: 5220 case 0x10ec0663: 5221 case 0x10ec0665: 5222 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT); 5223 break; 5224 case 0x10ec0273: 5225 set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT); 5226 break; 5227 } 5228 } 5229 spec->vmaster_nid = 0x02; 5230 5231 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE); 5232 5233 codec->patch_ops = alc_patch_ops; 5234 if (board_config == ALC_MODEL_AUTO) 5235 spec->init_hook = alc_auto_init_std; 5236 spec->shutup = alc_eapd_shutup; 5237 5238 alc_init_jacks(codec); 5239 5240 #ifdef CONFIG_SND_HDA_POWER_SAVE 5241 if (!spec->loopback.amplist) 5242 spec->loopback.amplist = alc662_loopbacks; 5243 #endif 5244 5245 return 0; 5246 } 5247 5248 static int patch_alc888(struct hda_codec *codec) 5249 { 5250 if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){ 5251 kfree(codec->chip_name); 5252 if (codec->vendor_id == 0x10ec0887) 5253 codec->chip_name = kstrdup("ALC887-VD", GFP_KERNEL); 5254 else 5255 codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL); 5256 if (!codec->chip_name) { 5257 alc_free(codec); 5258 return -ENOMEM; 5259 } 5260 return patch_alc662(codec); 5261 } 5262 return patch_alc882(codec); 5263 } 5264 5265 static int patch_alc899(struct hda_codec *codec) 5266 { 5267 if ((alc_read_coef_idx(codec, 0) & 0x2000) != 0x2000) { 5268 kfree(codec->chip_name); 5269 codec->chip_name = kstrdup("ALC898", GFP_KERNEL); 5270 } 5271 return patch_alc882(codec); 5272 } 5273 5274 /* 5275 * ALC680 support 5276 */ 5277 5278 static int alc680_parse_auto_config(struct hda_codec *codec) 5279 { 5280 return alc_parse_auto_config(codec, NULL, NULL); 5281 } 5282 5283 /* 5284 */ 5285 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS 5286 #include "alc680_quirks.c" 5287 #endif 5288 5289 static int patch_alc680(struct hda_codec *codec) 5290 { 5291 struct alc_spec *spec; 5292 int board_config; 5293 int err; 5294 5295 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5296 if (spec == NULL) 5297 return -ENOMEM; 5298 5299 codec->spec = spec; 5300 5301 /* ALC680 has no aa-loopback mixer */ 5302 5303 board_config = alc_board_config(codec, ALC680_MODEL_LAST, 5304 alc680_models, alc680_cfg_tbl); 5305 5306 if (board_config < 0) { 5307 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 5308 codec->chip_name); 5309 board_config = ALC_MODEL_AUTO; 5310 } 5311 5312 if (board_config == ALC_MODEL_AUTO) { 5313 /* automatic parse from the BIOS config */ 5314 err = alc680_parse_auto_config(codec); 5315 if (err < 0) { 5316 alc_free(codec); 5317 return err; 5318 } 5319 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS 5320 else if (!err) { 5321 printk(KERN_INFO 5322 "hda_codec: Cannot set up configuration " 5323 "from BIOS. Using base mode...\n"); 5324 board_config = ALC680_BASE; 5325 } 5326 #endif 5327 } 5328 5329 if (board_config != ALC_MODEL_AUTO) { 5330 setup_preset(codec, &alc680_presets[board_config]); 5331 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS 5332 spec->stream_analog_capture = &alc680_pcm_analog_auto_capture; 5333 #endif 5334 } 5335 5336 if (!spec->no_analog && !spec->adc_nids && spec->input_mux) { 5337 alc_auto_fill_adc_caps(codec); 5338 alc_rebuild_imux_for_auto_mic(codec); 5339 alc_remove_invalid_adc_nids(codec); 5340 } 5341 5342 if (!spec->no_analog && !spec->cap_mixer) 5343 set_capture_mixer(codec); 5344 5345 spec->vmaster_nid = 0x02; 5346 5347 codec->patch_ops = alc_patch_ops; 5348 if (board_config == ALC_MODEL_AUTO) 5349 spec->init_hook = alc_auto_init_std; 5350 5351 return 0; 5352 } 5353 5354 /* 5355 * patch entries 5356 */ 5357 static const struct hda_codec_preset snd_hda_preset_realtek[] = { 5358 { .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 }, 5359 { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 }, 5360 { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 }, 5361 { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 }, 5362 { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 }, 5363 { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 }, 5364 { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 }, 5365 { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 }, 5366 { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 }, 5367 { .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 }, 5368 { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660", 5369 .patch = patch_alc861 }, 5370 { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd }, 5371 { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 }, 5372 { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd }, 5373 { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2", 5374 .patch = patch_alc882 }, 5375 { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1", 5376 .patch = patch_alc662 }, 5377 { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 }, 5378 { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 }, 5379 { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 }, 5380 { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 }, 5381 { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 }, 5382 { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 }, 5383 { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 }, 5384 { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A", 5385 .patch = patch_alc882 }, 5386 { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A", 5387 .patch = patch_alc882 }, 5388 { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 }, 5389 { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc888 }, 5390 { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200", 5391 .patch = patch_alc882 }, 5392 { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 }, 5393 { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 }, 5394 { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 }, 5395 { .id = 0x10ec0899, .name = "ALC899", .patch = patch_alc899 }, 5396 {} /* terminator */ 5397 }; 5398 5399 MODULE_ALIAS("snd-hda-codec-id:10ec*"); 5400 5401 MODULE_LICENSE("GPL"); 5402 MODULE_DESCRIPTION("Realtek HD-audio codec"); 5403 5404 static struct hda_codec_preset_list realtek_list = { 5405 .preset = snd_hda_preset_realtek, 5406 .owner = THIS_MODULE, 5407 }; 5408 5409 static int __init patch_realtek_init(void) 5410 { 5411 return snd_hda_add_codec_preset(&realtek_list); 5412 } 5413 5414 static void __exit patch_realtek_exit(void) 5415 { 5416 snd_hda_delete_codec_preset(&realtek_list); 5417 } 5418 5419 module_init(patch_realtek_init) 5420 module_exit(patch_realtek_exit) 5421