patch_realtek.c revision ae0ebbf70afe2889b39f575e800e7292abd259d6
1/* 2 * Universal Interface for Intel High Definition Audio Codec 3 * 4 * HD audio interface patch for ALC 260/880/882 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#define ALC880_FRONT_EVENT 0x01 37#define ALC880_DCVOL_EVENT 0x02 38#define ALC880_HP_EVENT 0x04 39#define ALC880_MIC_EVENT 0x08 40 41/* ALC880 board config type */ 42enum { 43 ALC880_3ST, 44 ALC880_3ST_DIG, 45 ALC880_5ST, 46 ALC880_5ST_DIG, 47 ALC880_W810, 48 ALC880_Z71V, 49 ALC880_6ST, 50 ALC880_6ST_DIG, 51 ALC880_F1734, 52 ALC880_ASUS, 53 ALC880_ASUS_DIG, 54 ALC880_ASUS_W1V, 55 ALC880_ASUS_DIG2, 56 ALC880_FUJITSU, 57 ALC880_UNIWILL_DIG, 58 ALC880_UNIWILL, 59 ALC880_UNIWILL_P53, 60 ALC880_CLEVO, 61 ALC880_TCL_S700, 62 ALC880_LG, 63 ALC880_LG_LW, 64 ALC880_MEDION_RIM, 65#ifdef CONFIG_SND_DEBUG 66 ALC880_TEST, 67#endif 68 ALC880_AUTO, 69 ALC880_MODEL_LAST /* last tag */ 70}; 71 72/* ALC260 models */ 73enum { 74 ALC260_BASIC, 75 ALC260_HP, 76 ALC260_HP_DC7600, 77 ALC260_HP_3013, 78 ALC260_FUJITSU_S702X, 79 ALC260_ACER, 80 ALC260_WILL, 81 ALC260_REPLACER_672V, 82 ALC260_FAVORIT100, 83#ifdef CONFIG_SND_DEBUG 84 ALC260_TEST, 85#endif 86 ALC260_AUTO, 87 ALC260_MODEL_LAST /* last tag */ 88}; 89 90/* ALC262 models */ 91enum { 92 ALC262_BASIC, 93 ALC262_HIPPO, 94 ALC262_HIPPO_1, 95 ALC262_FUJITSU, 96 ALC262_HP_BPC, 97 ALC262_HP_BPC_D7000_WL, 98 ALC262_HP_BPC_D7000_WF, 99 ALC262_HP_TC_T5735, 100 ALC262_HP_RP5700, 101 ALC262_BENQ_ED8, 102 ALC262_SONY_ASSAMD, 103 ALC262_BENQ_T31, 104 ALC262_ULTRA, 105 ALC262_LENOVO_3000, 106 ALC262_NEC, 107 ALC262_TOSHIBA_S06, 108 ALC262_TOSHIBA_RX1, 109 ALC262_TYAN, 110 ALC262_AUTO, 111 ALC262_MODEL_LAST /* last tag */ 112}; 113 114/* ALC268 models */ 115enum { 116 ALC267_QUANTA_IL1, 117 ALC268_3ST, 118 ALC268_TOSHIBA, 119 ALC268_ACER, 120 ALC268_ACER_DMIC, 121 ALC268_ACER_ASPIRE_ONE, 122 ALC268_DELL, 123 ALC268_ZEPTO, 124#ifdef CONFIG_SND_DEBUG 125 ALC268_TEST, 126#endif 127 ALC268_AUTO, 128 ALC268_MODEL_LAST /* last tag */ 129}; 130 131/* ALC269 models */ 132enum { 133 ALC269_BASIC, 134 ALC269_QUANTA_FL1, 135 ALC269_AMIC, 136 ALC269_DMIC, 137 ALC269VB_AMIC, 138 ALC269VB_DMIC, 139 ALC269_FUJITSU, 140 ALC269_LIFEBOOK, 141 ALC271_ACER, 142 ALC269_AUTO, 143 ALC269_MODEL_LAST /* last tag */ 144}; 145 146/* ALC861 models */ 147enum { 148 ALC861_3ST, 149 ALC660_3ST, 150 ALC861_3ST_DIG, 151 ALC861_6ST_DIG, 152 ALC861_UNIWILL_M31, 153 ALC861_TOSHIBA, 154 ALC861_ASUS, 155 ALC861_ASUS_LAPTOP, 156 ALC861_AUTO, 157 ALC861_MODEL_LAST, 158}; 159 160/* ALC861-VD models */ 161enum { 162 ALC660VD_3ST, 163 ALC660VD_3ST_DIG, 164 ALC660VD_ASUS_V1S, 165 ALC861VD_3ST, 166 ALC861VD_3ST_DIG, 167 ALC861VD_6ST_DIG, 168 ALC861VD_LENOVO, 169 ALC861VD_DALLAS, 170 ALC861VD_HP, 171 ALC861VD_AUTO, 172 ALC861VD_MODEL_LAST, 173}; 174 175/* ALC662 models */ 176enum { 177 ALC662_3ST_2ch_DIG, 178 ALC662_3ST_6ch_DIG, 179 ALC662_3ST_6ch, 180 ALC662_5ST_DIG, 181 ALC662_LENOVO_101E, 182 ALC662_ASUS_EEEPC_P701, 183 ALC662_ASUS_EEEPC_EP20, 184 ALC663_ASUS_M51VA, 185 ALC663_ASUS_G71V, 186 ALC663_ASUS_H13, 187 ALC663_ASUS_G50V, 188 ALC662_ECS, 189 ALC663_ASUS_MODE1, 190 ALC662_ASUS_MODE2, 191 ALC663_ASUS_MODE3, 192 ALC663_ASUS_MODE4, 193 ALC663_ASUS_MODE5, 194 ALC663_ASUS_MODE6, 195 ALC663_ASUS_MODE7, 196 ALC663_ASUS_MODE8, 197 ALC272_DELL, 198 ALC272_DELL_ZM1, 199 ALC272_SAMSUNG_NC10, 200 ALC662_AUTO, 201 ALC662_MODEL_LAST, 202}; 203 204/* ALC882 models */ 205enum { 206 ALC882_3ST_DIG, 207 ALC882_6ST_DIG, 208 ALC882_ARIMA, 209 ALC882_W2JC, 210 ALC882_TARGA, 211 ALC882_ASUS_A7J, 212 ALC882_ASUS_A7M, 213 ALC885_MACPRO, 214 ALC885_MBA21, 215 ALC885_MBP3, 216 ALC885_MB5, 217 ALC885_MACMINI3, 218 ALC885_IMAC24, 219 ALC885_IMAC91, 220 ALC883_3ST_2ch_DIG, 221 ALC883_3ST_6ch_DIG, 222 ALC883_3ST_6ch, 223 ALC883_6ST_DIG, 224 ALC883_TARGA_DIG, 225 ALC883_TARGA_2ch_DIG, 226 ALC883_TARGA_8ch_DIG, 227 ALC883_ACER, 228 ALC883_ACER_ASPIRE, 229 ALC888_ACER_ASPIRE_4930G, 230 ALC888_ACER_ASPIRE_6530G, 231 ALC888_ACER_ASPIRE_8930G, 232 ALC888_ACER_ASPIRE_7730G, 233 ALC883_MEDION, 234 ALC883_MEDION_WIM2160, 235 ALC883_LAPTOP_EAPD, 236 ALC883_LENOVO_101E_2ch, 237 ALC883_LENOVO_NB0763, 238 ALC888_LENOVO_MS7195_DIG, 239 ALC888_LENOVO_SKY, 240 ALC883_HAIER_W66, 241 ALC888_3ST_HP, 242 ALC888_6ST_DELL, 243 ALC883_MITAC, 244 ALC883_CLEVO_M540R, 245 ALC883_CLEVO_M720, 246 ALC883_FUJITSU_PI2515, 247 ALC888_FUJITSU_XA3530, 248 ALC883_3ST_6ch_INTEL, 249 ALC889A_INTEL, 250 ALC889_INTEL, 251 ALC888_ASUS_M90V, 252 ALC888_ASUS_EEE1601, 253 ALC889A_MB31, 254 ALC1200_ASUS_P5Q, 255 ALC883_SONY_VAIO_TT, 256 ALC882_AUTO, 257 ALC882_MODEL_LAST, 258}; 259 260/* ALC680 models */ 261enum { 262 ALC680_BASE, 263 ALC680_AUTO, 264 ALC680_MODEL_LAST, 265}; 266 267/* for GPIO Poll */ 268#define GPIO_MASK 0x03 269 270/* extra amp-initialization sequence types */ 271enum { 272 ALC_INIT_NONE, 273 ALC_INIT_DEFAULT, 274 ALC_INIT_GPIO1, 275 ALC_INIT_GPIO2, 276 ALC_INIT_GPIO3, 277}; 278 279struct alc_mic_route { 280 hda_nid_t pin; 281 unsigned char mux_idx; 282 unsigned char amix_idx; 283}; 284 285#define MUX_IDX_UNDEF ((unsigned char)-1) 286 287struct alc_customize_define { 288 unsigned int sku_cfg; 289 unsigned char port_connectivity; 290 unsigned char check_sum; 291 unsigned char customization; 292 unsigned char external_amp; 293 unsigned int enable_pcbeep:1; 294 unsigned int platform_type:1; 295 unsigned int swap:1; 296 unsigned int override:1; 297 unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */ 298}; 299 300struct alc_fixup; 301 302struct alc_spec { 303 /* codec parameterization */ 304 struct snd_kcontrol_new *mixers[5]; /* mixer arrays */ 305 unsigned int num_mixers; 306 struct snd_kcontrol_new *cap_mixer; /* capture mixer */ 307 unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */ 308 309 const struct hda_verb *init_verbs[10]; /* initialization verbs 310 * don't forget NULL 311 * termination! 312 */ 313 unsigned int num_init_verbs; 314 315 char stream_name_analog[32]; /* analog PCM stream */ 316 struct hda_pcm_stream *stream_analog_playback; 317 struct hda_pcm_stream *stream_analog_capture; 318 struct hda_pcm_stream *stream_analog_alt_playback; 319 struct hda_pcm_stream *stream_analog_alt_capture; 320 321 char stream_name_digital[32]; /* digital PCM stream */ 322 struct hda_pcm_stream *stream_digital_playback; 323 struct hda_pcm_stream *stream_digital_capture; 324 325 /* playback */ 326 struct hda_multi_out multiout; /* playback set-up 327 * max_channels, dacs must be set 328 * dig_out_nid and hp_nid are optional 329 */ 330 hda_nid_t alt_dac_nid; 331 hda_nid_t slave_dig_outs[3]; /* optional - for auto-parsing */ 332 int dig_out_type; 333 334 /* capture */ 335 unsigned int num_adc_nids; 336 hda_nid_t *adc_nids; 337 hda_nid_t *capsrc_nids; 338 hda_nid_t dig_in_nid; /* digital-in NID; optional */ 339 340 /* capture setup for dynamic dual-adc switch */ 341 unsigned int cur_adc_idx; 342 hda_nid_t cur_adc; 343 unsigned int cur_adc_stream_tag; 344 unsigned int cur_adc_format; 345 346 /* capture source */ 347 unsigned int num_mux_defs; 348 const struct hda_input_mux *input_mux; 349 unsigned int cur_mux[3]; 350 struct alc_mic_route ext_mic; 351 struct alc_mic_route int_mic; 352 353 /* channel model */ 354 const struct hda_channel_mode *channel_mode; 355 int num_channel_mode; 356 int need_dac_fix; 357 int const_channel_count; 358 int ext_channel_count; 359 360 /* PCM information */ 361 struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */ 362 363 /* dynamic controls, init_verbs and input_mux */ 364 struct auto_pin_cfg autocfg; 365 struct alc_customize_define cdefine; 366 struct snd_array kctls; 367 struct hda_input_mux private_imux[3]; 368 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS]; 369 hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS]; 370 hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS]; 371 372 /* hooks */ 373 void (*init_hook)(struct hda_codec *codec); 374 void (*unsol_event)(struct hda_codec *codec, unsigned int res); 375#ifdef CONFIG_SND_HDA_POWER_SAVE 376 void (*power_hook)(struct hda_codec *codec); 377#endif 378 379 /* for pin sensing */ 380 unsigned int sense_updated: 1; 381 unsigned int jack_present: 1; 382 unsigned int master_sw: 1; 383 unsigned int auto_mic:1; 384 385 /* other flags */ 386 unsigned int no_analog :1; /* digital I/O only */ 387 unsigned int dual_adc_switch:1; /* switch ADCs (for ALC275) */ 388 unsigned int single_input_src:1; 389 int init_amp; 390 int codec_variant; /* flag for other variants */ 391 392 /* for virtual master */ 393 hda_nid_t vmaster_nid; 394#ifdef CONFIG_SND_HDA_POWER_SAVE 395 struct hda_loopback_check loopback; 396#endif 397 398 /* for PLL fix */ 399 hda_nid_t pll_nid; 400 unsigned int pll_coef_idx, pll_coef_bit; 401 402 /* fix-up list */ 403 int fixup_id; 404 const struct alc_fixup *fixup_list; 405 const char *fixup_name; 406}; 407 408/* 409 * configuration template - to be copied to the spec instance 410 */ 411struct alc_config_preset { 412 struct snd_kcontrol_new *mixers[5]; /* should be identical size 413 * with spec 414 */ 415 struct snd_kcontrol_new *cap_mixer; /* capture mixer */ 416 const struct hda_verb *init_verbs[5]; 417 unsigned int num_dacs; 418 hda_nid_t *dac_nids; 419 hda_nid_t dig_out_nid; /* optional */ 420 hda_nid_t hp_nid; /* optional */ 421 hda_nid_t *slave_dig_outs; 422 unsigned int num_adc_nids; 423 hda_nid_t *adc_nids; 424 hda_nid_t *capsrc_nids; 425 hda_nid_t dig_in_nid; 426 unsigned int num_channel_mode; 427 const struct hda_channel_mode *channel_mode; 428 int need_dac_fix; 429 int const_channel_count; 430 unsigned int num_mux_defs; 431 const struct hda_input_mux *input_mux; 432 void (*unsol_event)(struct hda_codec *, unsigned int); 433 void (*setup)(struct hda_codec *); 434 void (*init_hook)(struct hda_codec *); 435#ifdef CONFIG_SND_HDA_POWER_SAVE 436 struct hda_amp_list *loopbacks; 437 void (*power_hook)(struct hda_codec *codec); 438#endif 439}; 440 441 442/* 443 * input MUX handling 444 */ 445static int alc_mux_enum_info(struct snd_kcontrol *kcontrol, 446 struct snd_ctl_elem_info *uinfo) 447{ 448 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 449 struct alc_spec *spec = codec->spec; 450 unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id); 451 if (mux_idx >= spec->num_mux_defs) 452 mux_idx = 0; 453 if (!spec->input_mux[mux_idx].num_items && mux_idx > 0) 454 mux_idx = 0; 455 return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo); 456} 457 458static int alc_mux_enum_get(struct snd_kcontrol *kcontrol, 459 struct snd_ctl_elem_value *ucontrol) 460{ 461 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 462 struct alc_spec *spec = codec->spec; 463 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 464 465 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx]; 466 return 0; 467} 468 469static int alc_mux_enum_put(struct snd_kcontrol *kcontrol, 470 struct snd_ctl_elem_value *ucontrol) 471{ 472 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 473 struct alc_spec *spec = codec->spec; 474 const struct hda_input_mux *imux; 475 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 476 unsigned int mux_idx; 477 hda_nid_t nid = spec->capsrc_nids ? 478 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx]; 479 unsigned int type; 480 481 mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx; 482 imux = &spec->input_mux[mux_idx]; 483 if (!imux->num_items && mux_idx > 0) 484 imux = &spec->input_mux[0]; 485 486 type = get_wcaps_type(get_wcaps(codec, nid)); 487 if (type == AC_WID_AUD_MIX) { 488 /* Matrix-mixer style (e.g. ALC882) */ 489 unsigned int *cur_val = &spec->cur_mux[adc_idx]; 490 unsigned int i, idx; 491 492 idx = ucontrol->value.enumerated.item[0]; 493 if (idx >= imux->num_items) 494 idx = imux->num_items - 1; 495 if (*cur_val == idx) 496 return 0; 497 for (i = 0; i < imux->num_items; i++) { 498 unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE; 499 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 500 imux->items[i].index, 501 HDA_AMP_MUTE, v); 502 } 503 *cur_val = idx; 504 return 1; 505 } else { 506 /* MUX style (e.g. ALC880) */ 507 return snd_hda_input_mux_put(codec, imux, ucontrol, nid, 508 &spec->cur_mux[adc_idx]); 509 } 510} 511 512/* 513 * channel mode setting 514 */ 515static int alc_ch_mode_info(struct snd_kcontrol *kcontrol, 516 struct snd_ctl_elem_info *uinfo) 517{ 518 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 519 struct alc_spec *spec = codec->spec; 520 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode, 521 spec->num_channel_mode); 522} 523 524static int alc_ch_mode_get(struct snd_kcontrol *kcontrol, 525 struct snd_ctl_elem_value *ucontrol) 526{ 527 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 528 struct alc_spec *spec = codec->spec; 529 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode, 530 spec->num_channel_mode, 531 spec->ext_channel_count); 532} 533 534static int alc_ch_mode_put(struct snd_kcontrol *kcontrol, 535 struct snd_ctl_elem_value *ucontrol) 536{ 537 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 538 struct alc_spec *spec = codec->spec; 539 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode, 540 spec->num_channel_mode, 541 &spec->ext_channel_count); 542 if (err >= 0 && !spec->const_channel_count) { 543 spec->multiout.max_channels = spec->ext_channel_count; 544 if (spec->need_dac_fix) 545 spec->multiout.num_dacs = spec->multiout.max_channels / 2; 546 } 547 return err; 548} 549 550/* 551 * Control the mode of pin widget settings via the mixer. "pc" is used 552 * instead of "%" to avoid consequences of accidently treating the % as 553 * being part of a format specifier. Maximum allowed length of a value is 554 * 63 characters plus NULL terminator. 555 * 556 * Note: some retasking pin complexes seem to ignore requests for input 557 * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these 558 * are requested. Therefore order this list so that this behaviour will not 559 * cause problems when mixer clients move through the enum sequentially. 560 * NIDs 0x0f and 0x10 have been observed to have this behaviour as of 561 * March 2006. 562 */ 563static char *alc_pin_mode_names[] = { 564 "Mic 50pc bias", "Mic 80pc bias", 565 "Line in", "Line out", "Headphone out", 566}; 567static unsigned char alc_pin_mode_values[] = { 568 PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP, 569}; 570/* The control can present all 5 options, or it can limit the options based 571 * in the pin being assumed to be exclusively an input or an output pin. In 572 * addition, "input" pins may or may not process the mic bias option 573 * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to 574 * accept requests for bias as of chip versions up to March 2006) and/or 575 * wiring in the computer. 576 */ 577#define ALC_PIN_DIR_IN 0x00 578#define ALC_PIN_DIR_OUT 0x01 579#define ALC_PIN_DIR_INOUT 0x02 580#define ALC_PIN_DIR_IN_NOMICBIAS 0x03 581#define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04 582 583/* Info about the pin modes supported by the different pin direction modes. 584 * For each direction the minimum and maximum values are given. 585 */ 586static signed char alc_pin_mode_dir_info[5][2] = { 587 { 0, 2 }, /* ALC_PIN_DIR_IN */ 588 { 3, 4 }, /* ALC_PIN_DIR_OUT */ 589 { 0, 4 }, /* ALC_PIN_DIR_INOUT */ 590 { 2, 2 }, /* ALC_PIN_DIR_IN_NOMICBIAS */ 591 { 2, 4 }, /* ALC_PIN_DIR_INOUT_NOMICBIAS */ 592}; 593#define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0]) 594#define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1]) 595#define alc_pin_mode_n_items(_dir) \ 596 (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1) 597 598static int alc_pin_mode_info(struct snd_kcontrol *kcontrol, 599 struct snd_ctl_elem_info *uinfo) 600{ 601 unsigned int item_num = uinfo->value.enumerated.item; 602 unsigned char dir = (kcontrol->private_value >> 16) & 0xff; 603 604 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 605 uinfo->count = 1; 606 uinfo->value.enumerated.items = alc_pin_mode_n_items(dir); 607 608 if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir)) 609 item_num = alc_pin_mode_min(dir); 610 strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]); 611 return 0; 612} 613 614static int alc_pin_mode_get(struct snd_kcontrol *kcontrol, 615 struct snd_ctl_elem_value *ucontrol) 616{ 617 unsigned int i; 618 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 619 hda_nid_t nid = kcontrol->private_value & 0xffff; 620 unsigned char dir = (kcontrol->private_value >> 16) & 0xff; 621 long *valp = ucontrol->value.integer.value; 622 unsigned int pinctl = snd_hda_codec_read(codec, nid, 0, 623 AC_VERB_GET_PIN_WIDGET_CONTROL, 624 0x00); 625 626 /* Find enumerated value for current pinctl setting */ 627 i = alc_pin_mode_min(dir); 628 while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl) 629 i++; 630 *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir); 631 return 0; 632} 633 634static int alc_pin_mode_put(struct snd_kcontrol *kcontrol, 635 struct snd_ctl_elem_value *ucontrol) 636{ 637 signed int change; 638 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 639 hda_nid_t nid = kcontrol->private_value & 0xffff; 640 unsigned char dir = (kcontrol->private_value >> 16) & 0xff; 641 long val = *ucontrol->value.integer.value; 642 unsigned int pinctl = snd_hda_codec_read(codec, nid, 0, 643 AC_VERB_GET_PIN_WIDGET_CONTROL, 644 0x00); 645 646 if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir)) 647 val = alc_pin_mode_min(dir); 648 649 change = pinctl != alc_pin_mode_values[val]; 650 if (change) { 651 /* Set pin mode to that requested */ 652 snd_hda_codec_write_cache(codec, nid, 0, 653 AC_VERB_SET_PIN_WIDGET_CONTROL, 654 alc_pin_mode_values[val]); 655 656 /* Also enable the retasking pin's input/output as required 657 * for the requested pin mode. Enum values of 2 or less are 658 * input modes. 659 * 660 * Dynamically switching the input/output buffers probably 661 * reduces noise slightly (particularly on input) so we'll 662 * do it. However, having both input and output buffers 663 * enabled simultaneously doesn't seem to be problematic if 664 * this turns out to be necessary in the future. 665 */ 666 if (val <= 2) { 667 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 668 HDA_AMP_MUTE, HDA_AMP_MUTE); 669 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0, 670 HDA_AMP_MUTE, 0); 671 } else { 672 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0, 673 HDA_AMP_MUTE, HDA_AMP_MUTE); 674 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 675 HDA_AMP_MUTE, 0); 676 } 677 } 678 return change; 679} 680 681#define ALC_PIN_MODE(xname, nid, dir) \ 682 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 683 .subdevice = HDA_SUBDEV_NID_FLAG | nid, \ 684 .info = alc_pin_mode_info, \ 685 .get = alc_pin_mode_get, \ 686 .put = alc_pin_mode_put, \ 687 .private_value = nid | (dir<<16) } 688 689/* A switch control for ALC260 GPIO pins. Multiple GPIOs can be ganged 690 * together using a mask with more than one bit set. This control is 691 * currently used only by the ALC260 test model. At this stage they are not 692 * needed for any "production" models. 693 */ 694#ifdef CONFIG_SND_DEBUG 695#define alc_gpio_data_info snd_ctl_boolean_mono_info 696 697static int alc_gpio_data_get(struct snd_kcontrol *kcontrol, 698 struct snd_ctl_elem_value *ucontrol) 699{ 700 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 701 hda_nid_t nid = kcontrol->private_value & 0xffff; 702 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 703 long *valp = ucontrol->value.integer.value; 704 unsigned int val = snd_hda_codec_read(codec, nid, 0, 705 AC_VERB_GET_GPIO_DATA, 0x00); 706 707 *valp = (val & mask) != 0; 708 return 0; 709} 710static int alc_gpio_data_put(struct snd_kcontrol *kcontrol, 711 struct snd_ctl_elem_value *ucontrol) 712{ 713 signed int change; 714 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 715 hda_nid_t nid = kcontrol->private_value & 0xffff; 716 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 717 long val = *ucontrol->value.integer.value; 718 unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0, 719 AC_VERB_GET_GPIO_DATA, 720 0x00); 721 722 /* Set/unset the masked GPIO bit(s) as needed */ 723 change = (val == 0 ? 0 : mask) != (gpio_data & mask); 724 if (val == 0) 725 gpio_data &= ~mask; 726 else 727 gpio_data |= mask; 728 snd_hda_codec_write_cache(codec, nid, 0, 729 AC_VERB_SET_GPIO_DATA, gpio_data); 730 731 return change; 732} 733#define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \ 734 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 735 .subdevice = HDA_SUBDEV_NID_FLAG | nid, \ 736 .info = alc_gpio_data_info, \ 737 .get = alc_gpio_data_get, \ 738 .put = alc_gpio_data_put, \ 739 .private_value = nid | (mask<<16) } 740#endif /* CONFIG_SND_DEBUG */ 741 742/* A switch control to allow the enabling of the digital IO pins on the 743 * ALC260. This is incredibly simplistic; the intention of this control is 744 * to provide something in the test model allowing digital outputs to be 745 * identified if present. If models are found which can utilise these 746 * outputs a more complete mixer control can be devised for those models if 747 * necessary. 748 */ 749#ifdef CONFIG_SND_DEBUG 750#define alc_spdif_ctrl_info snd_ctl_boolean_mono_info 751 752static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol, 753 struct snd_ctl_elem_value *ucontrol) 754{ 755 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 756 hda_nid_t nid = kcontrol->private_value & 0xffff; 757 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 758 long *valp = ucontrol->value.integer.value; 759 unsigned int val = snd_hda_codec_read(codec, nid, 0, 760 AC_VERB_GET_DIGI_CONVERT_1, 0x00); 761 762 *valp = (val & mask) != 0; 763 return 0; 764} 765static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol, 766 struct snd_ctl_elem_value *ucontrol) 767{ 768 signed int change; 769 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 770 hda_nid_t nid = kcontrol->private_value & 0xffff; 771 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 772 long val = *ucontrol->value.integer.value; 773 unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0, 774 AC_VERB_GET_DIGI_CONVERT_1, 775 0x00); 776 777 /* Set/unset the masked control bit(s) as needed */ 778 change = (val == 0 ? 0 : mask) != (ctrl_data & mask); 779 if (val==0) 780 ctrl_data &= ~mask; 781 else 782 ctrl_data |= mask; 783 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1, 784 ctrl_data); 785 786 return change; 787} 788#define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \ 789 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 790 .subdevice = HDA_SUBDEV_NID_FLAG | nid, \ 791 .info = alc_spdif_ctrl_info, \ 792 .get = alc_spdif_ctrl_get, \ 793 .put = alc_spdif_ctrl_put, \ 794 .private_value = nid | (mask<<16) } 795#endif /* CONFIG_SND_DEBUG */ 796 797/* A switch control to allow the enabling EAPD digital outputs on the ALC26x. 798 * Again, this is only used in the ALC26x test models to help identify when 799 * the EAPD line must be asserted for features to work. 800 */ 801#ifdef CONFIG_SND_DEBUG 802#define alc_eapd_ctrl_info snd_ctl_boolean_mono_info 803 804static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol, 805 struct snd_ctl_elem_value *ucontrol) 806{ 807 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 808 hda_nid_t nid = kcontrol->private_value & 0xffff; 809 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 810 long *valp = ucontrol->value.integer.value; 811 unsigned int val = snd_hda_codec_read(codec, nid, 0, 812 AC_VERB_GET_EAPD_BTLENABLE, 0x00); 813 814 *valp = (val & mask) != 0; 815 return 0; 816} 817 818static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol, 819 struct snd_ctl_elem_value *ucontrol) 820{ 821 int change; 822 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 823 hda_nid_t nid = kcontrol->private_value & 0xffff; 824 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 825 long val = *ucontrol->value.integer.value; 826 unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0, 827 AC_VERB_GET_EAPD_BTLENABLE, 828 0x00); 829 830 /* Set/unset the masked control bit(s) as needed */ 831 change = (!val ? 0 : mask) != (ctrl_data & mask); 832 if (!val) 833 ctrl_data &= ~mask; 834 else 835 ctrl_data |= mask; 836 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE, 837 ctrl_data); 838 839 return change; 840} 841 842#define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \ 843 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 844 .subdevice = HDA_SUBDEV_NID_FLAG | nid, \ 845 .info = alc_eapd_ctrl_info, \ 846 .get = alc_eapd_ctrl_get, \ 847 .put = alc_eapd_ctrl_put, \ 848 .private_value = nid | (mask<<16) } 849#endif /* CONFIG_SND_DEBUG */ 850 851/* 852 * set up the input pin config (depending on the given auto-pin type) 853 */ 854static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid, 855 int auto_pin_type) 856{ 857 unsigned int val = PIN_IN; 858 859 if (auto_pin_type == AUTO_PIN_MIC) { 860 unsigned int pincap; 861 unsigned int oldval; 862 oldval = snd_hda_codec_read(codec, nid, 0, 863 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 864 pincap = snd_hda_query_pin_caps(codec, nid); 865 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT; 866 /* if the default pin setup is vref50, we give it priority */ 867 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50) 868 val = PIN_VREF80; 869 else if (pincap & AC_PINCAP_VREF_50) 870 val = PIN_VREF50; 871 else if (pincap & AC_PINCAP_VREF_100) 872 val = PIN_VREF100; 873 else if (pincap & AC_PINCAP_VREF_GRD) 874 val = PIN_VREFGRD; 875 } 876 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val); 877} 878 879static void alc_fixup_autocfg_pin_nums(struct hda_codec *codec) 880{ 881 struct alc_spec *spec = codec->spec; 882 struct auto_pin_cfg *cfg = &spec->autocfg; 883 884 if (!cfg->line_outs) { 885 while (cfg->line_outs < AUTO_CFG_MAX_OUTS && 886 cfg->line_out_pins[cfg->line_outs]) 887 cfg->line_outs++; 888 } 889 if (!cfg->speaker_outs) { 890 while (cfg->speaker_outs < AUTO_CFG_MAX_OUTS && 891 cfg->speaker_pins[cfg->speaker_outs]) 892 cfg->speaker_outs++; 893 } 894 if (!cfg->hp_outs) { 895 while (cfg->hp_outs < AUTO_CFG_MAX_OUTS && 896 cfg->hp_pins[cfg->hp_outs]) 897 cfg->hp_outs++; 898 } 899} 900 901/* 902 */ 903static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix) 904{ 905 if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers))) 906 return; 907 spec->mixers[spec->num_mixers++] = mix; 908} 909 910static void add_verb(struct alc_spec *spec, const struct hda_verb *verb) 911{ 912 if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs))) 913 return; 914 spec->init_verbs[spec->num_init_verbs++] = verb; 915} 916 917/* 918 * set up from the preset table 919 */ 920static void setup_preset(struct hda_codec *codec, 921 const struct alc_config_preset *preset) 922{ 923 struct alc_spec *spec = codec->spec; 924 int i; 925 926 for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++) 927 add_mixer(spec, preset->mixers[i]); 928 spec->cap_mixer = preset->cap_mixer; 929 for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i]; 930 i++) 931 add_verb(spec, preset->init_verbs[i]); 932 933 spec->channel_mode = preset->channel_mode; 934 spec->num_channel_mode = preset->num_channel_mode; 935 spec->need_dac_fix = preset->need_dac_fix; 936 spec->const_channel_count = preset->const_channel_count; 937 938 if (preset->const_channel_count) 939 spec->multiout.max_channels = preset->const_channel_count; 940 else 941 spec->multiout.max_channels = spec->channel_mode[0].channels; 942 spec->ext_channel_count = spec->channel_mode[0].channels; 943 944 spec->multiout.num_dacs = preset->num_dacs; 945 spec->multiout.dac_nids = preset->dac_nids; 946 spec->multiout.dig_out_nid = preset->dig_out_nid; 947 spec->multiout.slave_dig_outs = preset->slave_dig_outs; 948 spec->multiout.hp_nid = preset->hp_nid; 949 950 spec->num_mux_defs = preset->num_mux_defs; 951 if (!spec->num_mux_defs) 952 spec->num_mux_defs = 1; 953 spec->input_mux = preset->input_mux; 954 955 spec->num_adc_nids = preset->num_adc_nids; 956 spec->adc_nids = preset->adc_nids; 957 spec->capsrc_nids = preset->capsrc_nids; 958 spec->dig_in_nid = preset->dig_in_nid; 959 960 spec->unsol_event = preset->unsol_event; 961 spec->init_hook = preset->init_hook; 962#ifdef CONFIG_SND_HDA_POWER_SAVE 963 spec->power_hook = preset->power_hook; 964 spec->loopback.amplist = preset->loopbacks; 965#endif 966 967 if (preset->setup) 968 preset->setup(codec); 969 970 alc_fixup_autocfg_pin_nums(codec); 971} 972 973/* Enable GPIO mask and set output */ 974static struct hda_verb alc_gpio1_init_verbs[] = { 975 {0x01, AC_VERB_SET_GPIO_MASK, 0x01}, 976 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, 977 {0x01, AC_VERB_SET_GPIO_DATA, 0x01}, 978 { } 979}; 980 981static struct hda_verb alc_gpio2_init_verbs[] = { 982 {0x01, AC_VERB_SET_GPIO_MASK, 0x02}, 983 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02}, 984 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, 985 { } 986}; 987 988static struct hda_verb alc_gpio3_init_verbs[] = { 989 {0x01, AC_VERB_SET_GPIO_MASK, 0x03}, 990 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03}, 991 {0x01, AC_VERB_SET_GPIO_DATA, 0x03}, 992 { } 993}; 994 995/* 996 * Fix hardware PLL issue 997 * On some codecs, the analog PLL gating control must be off while 998 * the default value is 1. 999 */ 1000static void alc_fix_pll(struct hda_codec *codec) 1001{ 1002 struct alc_spec *spec = codec->spec; 1003 unsigned int val; 1004 1005 if (!spec->pll_nid) 1006 return; 1007 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX, 1008 spec->pll_coef_idx); 1009 val = snd_hda_codec_read(codec, spec->pll_nid, 0, 1010 AC_VERB_GET_PROC_COEF, 0); 1011 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX, 1012 spec->pll_coef_idx); 1013 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF, 1014 val & ~(1 << spec->pll_coef_bit)); 1015} 1016 1017static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid, 1018 unsigned int coef_idx, unsigned int coef_bit) 1019{ 1020 struct alc_spec *spec = codec->spec; 1021 spec->pll_nid = nid; 1022 spec->pll_coef_idx = coef_idx; 1023 spec->pll_coef_bit = coef_bit; 1024 alc_fix_pll(codec); 1025} 1026 1027static int alc_init_jacks(struct hda_codec *codec) 1028{ 1029#ifdef CONFIG_SND_HDA_INPUT_JACK 1030 struct alc_spec *spec = codec->spec; 1031 int err; 1032 unsigned int hp_nid = spec->autocfg.hp_pins[0]; 1033 unsigned int mic_nid = spec->ext_mic.pin; 1034 1035 if (hp_nid) { 1036 err = snd_hda_input_jack_add(codec, hp_nid, 1037 SND_JACK_HEADPHONE, NULL); 1038 if (err < 0) 1039 return err; 1040 snd_hda_input_jack_report(codec, hp_nid); 1041 } 1042 1043 if (mic_nid) { 1044 err = snd_hda_input_jack_add(codec, mic_nid, 1045 SND_JACK_MICROPHONE, NULL); 1046 if (err < 0) 1047 return err; 1048 snd_hda_input_jack_report(codec, mic_nid); 1049 } 1050#endif /* CONFIG_SND_HDA_INPUT_JACK */ 1051 return 0; 1052} 1053 1054static void alc_automute_speaker(struct hda_codec *codec, int pinctl) 1055{ 1056 struct alc_spec *spec = codec->spec; 1057 unsigned int mute; 1058 hda_nid_t nid; 1059 int i; 1060 1061 spec->jack_present = 0; 1062 for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) { 1063 nid = spec->autocfg.hp_pins[i]; 1064 if (!nid) 1065 break; 1066 snd_hda_input_jack_report(codec, nid); 1067 spec->jack_present |= snd_hda_jack_detect(codec, nid); 1068 } 1069 1070 mute = spec->jack_present ? HDA_AMP_MUTE : 0; 1071 /* Toggle internal speakers muting */ 1072 for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) { 1073 nid = spec->autocfg.speaker_pins[i]; 1074 if (!nid) 1075 break; 1076 if (pinctl) { 1077 snd_hda_codec_write(codec, nid, 0, 1078 AC_VERB_SET_PIN_WIDGET_CONTROL, 1079 spec->jack_present ? 0 : PIN_OUT); 1080 } else { 1081 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 1082 HDA_AMP_MUTE, mute); 1083 } 1084 } 1085} 1086 1087static void alc_automute_pin(struct hda_codec *codec) 1088{ 1089 alc_automute_speaker(codec, 1); 1090} 1091 1092static int get_connection_index(struct hda_codec *codec, hda_nid_t mux, 1093 hda_nid_t nid) 1094{ 1095 hda_nid_t conn[HDA_MAX_NUM_INPUTS]; 1096 int i, nums; 1097 1098 nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn)); 1099 for (i = 0; i < nums; i++) 1100 if (conn[i] == nid) 1101 return i; 1102 return -1; 1103} 1104 1105/* switch the current ADC according to the jack state */ 1106static void alc_dual_mic_adc_auto_switch(struct hda_codec *codec) 1107{ 1108 struct alc_spec *spec = codec->spec; 1109 unsigned int present; 1110 hda_nid_t new_adc; 1111 1112 present = snd_hda_jack_detect(codec, spec->ext_mic.pin); 1113 if (present) 1114 spec->cur_adc_idx = 1; 1115 else 1116 spec->cur_adc_idx = 0; 1117 new_adc = spec->adc_nids[spec->cur_adc_idx]; 1118 if (spec->cur_adc && spec->cur_adc != new_adc) { 1119 /* stream is running, let's swap the current ADC */ 1120 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1); 1121 spec->cur_adc = new_adc; 1122 snd_hda_codec_setup_stream(codec, new_adc, 1123 spec->cur_adc_stream_tag, 0, 1124 spec->cur_adc_format); 1125 } 1126} 1127 1128static void alc_mic_automute(struct hda_codec *codec) 1129{ 1130 struct alc_spec *spec = codec->spec; 1131 struct alc_mic_route *dead, *alive; 1132 unsigned int present, type; 1133 hda_nid_t cap_nid; 1134 1135 if (!spec->auto_mic) 1136 return; 1137 if (!spec->int_mic.pin || !spec->ext_mic.pin) 1138 return; 1139 if (snd_BUG_ON(!spec->adc_nids)) 1140 return; 1141 1142 if (spec->dual_adc_switch) { 1143 alc_dual_mic_adc_auto_switch(codec); 1144 return; 1145 } 1146 1147 cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0]; 1148 1149 present = snd_hda_jack_detect(codec, spec->ext_mic.pin); 1150 if (present) { 1151 alive = &spec->ext_mic; 1152 dead = &spec->int_mic; 1153 } else { 1154 alive = &spec->int_mic; 1155 dead = &spec->ext_mic; 1156 } 1157 1158 type = get_wcaps_type(get_wcaps(codec, cap_nid)); 1159 if (type == AC_WID_AUD_MIX) { 1160 /* Matrix-mixer style (e.g. ALC882) */ 1161 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT, 1162 alive->mux_idx, 1163 HDA_AMP_MUTE, 0); 1164 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT, 1165 dead->mux_idx, 1166 HDA_AMP_MUTE, HDA_AMP_MUTE); 1167 } else { 1168 /* MUX style (e.g. ALC880) */ 1169 snd_hda_codec_write_cache(codec, cap_nid, 0, 1170 AC_VERB_SET_CONNECT_SEL, 1171 alive->mux_idx); 1172 } 1173 snd_hda_input_jack_report(codec, spec->ext_mic.pin); 1174 1175 /* FIXME: analog mixer */ 1176} 1177 1178/* unsolicited event for HP jack sensing */ 1179static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res) 1180{ 1181 if (codec->vendor_id == 0x10ec0880) 1182 res >>= 28; 1183 else 1184 res >>= 26; 1185 switch (res) { 1186 case ALC880_HP_EVENT: 1187 alc_automute_pin(codec); 1188 break; 1189 case ALC880_MIC_EVENT: 1190 alc_mic_automute(codec); 1191 break; 1192 } 1193} 1194 1195static void alc_inithook(struct hda_codec *codec) 1196{ 1197 alc_automute_pin(codec); 1198 alc_mic_automute(codec); 1199} 1200 1201/* additional initialization for ALC888 variants */ 1202static void alc888_coef_init(struct hda_codec *codec) 1203{ 1204 unsigned int tmp; 1205 1206 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0); 1207 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0); 1208 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7); 1209 if ((tmp & 0xf0) == 0x20) 1210 /* alc888S-VC */ 1211 snd_hda_codec_read(codec, 0x20, 0, 1212 AC_VERB_SET_PROC_COEF, 0x830); 1213 else 1214 /* alc888-VB */ 1215 snd_hda_codec_read(codec, 0x20, 0, 1216 AC_VERB_SET_PROC_COEF, 0x3030); 1217} 1218 1219static void alc889_coef_init(struct hda_codec *codec) 1220{ 1221 unsigned int tmp; 1222 1223 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7); 1224 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0); 1225 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7); 1226 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010); 1227} 1228 1229/* turn on/off EAPD control (only if available) */ 1230static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on) 1231{ 1232 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN) 1233 return; 1234 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD) 1235 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE, 1236 on ? 2 : 0); 1237} 1238 1239static void alc_auto_init_amp(struct hda_codec *codec, int type) 1240{ 1241 unsigned int tmp; 1242 1243 switch (type) { 1244 case ALC_INIT_GPIO1: 1245 snd_hda_sequence_write(codec, alc_gpio1_init_verbs); 1246 break; 1247 case ALC_INIT_GPIO2: 1248 snd_hda_sequence_write(codec, alc_gpio2_init_verbs); 1249 break; 1250 case ALC_INIT_GPIO3: 1251 snd_hda_sequence_write(codec, alc_gpio3_init_verbs); 1252 break; 1253 case ALC_INIT_DEFAULT: 1254 switch (codec->vendor_id) { 1255 case 0x10ec0260: 1256 set_eapd(codec, 0x0f, 1); 1257 set_eapd(codec, 0x10, 1); 1258 break; 1259 case 0x10ec0262: 1260 case 0x10ec0267: 1261 case 0x10ec0268: 1262 case 0x10ec0269: 1263 case 0x10ec0270: 1264 case 0x10ec0272: 1265 case 0x10ec0660: 1266 case 0x10ec0662: 1267 case 0x10ec0663: 1268 case 0x10ec0862: 1269 case 0x10ec0889: 1270 set_eapd(codec, 0x14, 1); 1271 set_eapd(codec, 0x15, 1); 1272 break; 1273 } 1274 switch (codec->vendor_id) { 1275 case 0x10ec0260: 1276 snd_hda_codec_write(codec, 0x1a, 0, 1277 AC_VERB_SET_COEF_INDEX, 7); 1278 tmp = snd_hda_codec_read(codec, 0x1a, 0, 1279 AC_VERB_GET_PROC_COEF, 0); 1280 snd_hda_codec_write(codec, 0x1a, 0, 1281 AC_VERB_SET_COEF_INDEX, 7); 1282 snd_hda_codec_write(codec, 0x1a, 0, 1283 AC_VERB_SET_PROC_COEF, 1284 tmp | 0x2010); 1285 break; 1286 case 0x10ec0262: 1287 case 0x10ec0880: 1288 case 0x10ec0882: 1289 case 0x10ec0883: 1290 case 0x10ec0885: 1291 case 0x10ec0887: 1292 case 0x10ec0889: 1293 alc889_coef_init(codec); 1294 break; 1295 case 0x10ec0888: 1296 alc888_coef_init(codec); 1297 break; 1298#if 0 /* XXX: This may cause the silent output on speaker on some machines */ 1299 case 0x10ec0267: 1300 case 0x10ec0268: 1301 snd_hda_codec_write(codec, 0x20, 0, 1302 AC_VERB_SET_COEF_INDEX, 7); 1303 tmp = snd_hda_codec_read(codec, 0x20, 0, 1304 AC_VERB_GET_PROC_COEF, 0); 1305 snd_hda_codec_write(codec, 0x20, 0, 1306 AC_VERB_SET_COEF_INDEX, 7); 1307 snd_hda_codec_write(codec, 0x20, 0, 1308 AC_VERB_SET_PROC_COEF, 1309 tmp | 0x3000); 1310 break; 1311#endif /* XXX */ 1312 } 1313 break; 1314 } 1315} 1316 1317static void alc_init_auto_hp(struct hda_codec *codec) 1318{ 1319 struct alc_spec *spec = codec->spec; 1320 struct auto_pin_cfg *cfg = &spec->autocfg; 1321 int i; 1322 1323 if (!cfg->hp_pins[0]) { 1324 if (cfg->line_out_type != AUTO_PIN_HP_OUT) 1325 return; 1326 } 1327 1328 if (!cfg->speaker_pins[0]) { 1329 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) 1330 return; 1331 memcpy(cfg->speaker_pins, cfg->line_out_pins, 1332 sizeof(cfg->speaker_pins)); 1333 cfg->speaker_outs = cfg->line_outs; 1334 } 1335 1336 if (!cfg->hp_pins[0]) { 1337 memcpy(cfg->hp_pins, cfg->line_out_pins, 1338 sizeof(cfg->hp_pins)); 1339 cfg->hp_outs = cfg->line_outs; 1340 } 1341 1342 for (i = 0; i < cfg->hp_outs; i++) { 1343 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n", 1344 cfg->hp_pins[i]); 1345 snd_hda_codec_write_cache(codec, cfg->hp_pins[i], 0, 1346 AC_VERB_SET_UNSOLICITED_ENABLE, 1347 AC_USRSP_EN | ALC880_HP_EVENT); 1348 } 1349 spec->unsol_event = alc_sku_unsol_event; 1350} 1351 1352static void alc_init_auto_mic(struct hda_codec *codec) 1353{ 1354 struct alc_spec *spec = codec->spec; 1355 struct auto_pin_cfg *cfg = &spec->autocfg; 1356 hda_nid_t fixed, ext; 1357 int i; 1358 1359 /* there must be only two mic inputs exclusively */ 1360 for (i = 0; i < cfg->num_inputs; i++) 1361 if (cfg->inputs[i].type >= AUTO_PIN_LINE_IN) 1362 return; 1363 1364 fixed = ext = 0; 1365 for (i = 0; i < cfg->num_inputs; i++) { 1366 hda_nid_t nid = cfg->inputs[i].pin; 1367 unsigned int defcfg; 1368 defcfg = snd_hda_codec_get_pincfg(codec, nid); 1369 switch (snd_hda_get_input_pin_attr(defcfg)) { 1370 case INPUT_PIN_ATTR_INT: 1371 if (fixed) 1372 return; /* already occupied */ 1373 fixed = nid; 1374 break; 1375 case INPUT_PIN_ATTR_UNUSED: 1376 return; /* invalid entry */ 1377 default: 1378 if (ext) 1379 return; /* already occupied */ 1380 ext = nid; 1381 break; 1382 } 1383 } 1384 if (!ext || !fixed) 1385 return; 1386 if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP)) 1387 return; /* no unsol support */ 1388 snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x\n", 1389 ext, fixed); 1390 spec->ext_mic.pin = ext; 1391 spec->int_mic.pin = fixed; 1392 spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */ 1393 spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */ 1394 spec->auto_mic = 1; 1395 snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0, 1396 AC_VERB_SET_UNSOLICITED_ENABLE, 1397 AC_USRSP_EN | ALC880_MIC_EVENT); 1398 spec->unsol_event = alc_sku_unsol_event; 1399} 1400 1401/* Could be any non-zero and even value. When used as fixup, tells 1402 * the driver to ignore any present sku defines. 1403 */ 1404#define ALC_FIXUP_SKU_IGNORE (2) 1405 1406static int alc_auto_parse_customize_define(struct hda_codec *codec) 1407{ 1408 unsigned int ass, tmp, i; 1409 unsigned nid = 0; 1410 struct alc_spec *spec = codec->spec; 1411 1412 spec->cdefine.enable_pcbeep = 1; /* assume always enabled */ 1413 1414 if (spec->cdefine.fixup) { 1415 ass = spec->cdefine.sku_cfg; 1416 if (ass == ALC_FIXUP_SKU_IGNORE) 1417 return -1; 1418 goto do_sku; 1419 } 1420 1421 ass = codec->subsystem_id & 0xffff; 1422 if (ass != codec->bus->pci->subsystem_device && (ass & 1)) 1423 goto do_sku; 1424 1425 nid = 0x1d; 1426 if (codec->vendor_id == 0x10ec0260) 1427 nid = 0x17; 1428 ass = snd_hda_codec_get_pincfg(codec, nid); 1429 1430 if (!(ass & 1)) { 1431 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n", 1432 codec->chip_name, ass); 1433 return -1; 1434 } 1435 1436 /* check sum */ 1437 tmp = 0; 1438 for (i = 1; i < 16; i++) { 1439 if ((ass >> i) & 1) 1440 tmp++; 1441 } 1442 if (((ass >> 16) & 0xf) != tmp) 1443 return -1; 1444 1445 spec->cdefine.port_connectivity = ass >> 30; 1446 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20; 1447 spec->cdefine.check_sum = (ass >> 16) & 0xf; 1448 spec->cdefine.customization = ass >> 8; 1449do_sku: 1450 spec->cdefine.sku_cfg = ass; 1451 spec->cdefine.external_amp = (ass & 0x38) >> 3; 1452 spec->cdefine.platform_type = (ass & 0x4) >> 2; 1453 spec->cdefine.swap = (ass & 0x2) >> 1; 1454 spec->cdefine.override = ass & 0x1; 1455 1456 snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n", 1457 nid, spec->cdefine.sku_cfg); 1458 snd_printd("SKU: port_connectivity=0x%x\n", 1459 spec->cdefine.port_connectivity); 1460 snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep); 1461 snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum); 1462 snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization); 1463 snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp); 1464 snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type); 1465 snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap); 1466 snd_printd("SKU: override=0x%x\n", spec->cdefine.override); 1467 1468 return 0; 1469} 1470 1471/* check subsystem ID and set up device-specific initialization; 1472 * return 1 if initialized, 0 if invalid SSID 1473 */ 1474/* 32-bit subsystem ID for BIOS loading in HD Audio codec. 1475 * 31 ~ 16 : Manufacture ID 1476 * 15 ~ 8 : SKU ID 1477 * 7 ~ 0 : Assembly ID 1478 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36 1479 */ 1480static int alc_subsystem_id(struct hda_codec *codec, 1481 hda_nid_t porta, hda_nid_t porte, 1482 hda_nid_t portd, hda_nid_t porti) 1483{ 1484 unsigned int ass, tmp, i; 1485 unsigned nid; 1486 struct alc_spec *spec = codec->spec; 1487 1488 if (spec->cdefine.fixup) { 1489 ass = spec->cdefine.sku_cfg; 1490 if (ass == ALC_FIXUP_SKU_IGNORE) 1491 return 0; 1492 goto do_sku; 1493 } 1494 1495 ass = codec->subsystem_id & 0xffff; 1496 if ((ass != codec->bus->pci->subsystem_device) && (ass & 1)) 1497 goto do_sku; 1498 1499 /* invalid SSID, check the special NID pin defcfg instead */ 1500 /* 1501 * 31~30 : port connectivity 1502 * 29~21 : reserve 1503 * 20 : PCBEEP input 1504 * 19~16 : Check sum (15:1) 1505 * 15~1 : Custom 1506 * 0 : override 1507 */ 1508 nid = 0x1d; 1509 if (codec->vendor_id == 0x10ec0260) 1510 nid = 0x17; 1511 ass = snd_hda_codec_get_pincfg(codec, nid); 1512 snd_printd("realtek: No valid SSID, " 1513 "checking pincfg 0x%08x for NID 0x%x\n", 1514 ass, nid); 1515 if (!(ass & 1)) 1516 return 0; 1517 if ((ass >> 30) != 1) /* no physical connection */ 1518 return 0; 1519 1520 /* check sum */ 1521 tmp = 0; 1522 for (i = 1; i < 16; i++) { 1523 if ((ass >> i) & 1) 1524 tmp++; 1525 } 1526 if (((ass >> 16) & 0xf) != tmp) 1527 return 0; 1528do_sku: 1529 snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n", 1530 ass & 0xffff, codec->vendor_id); 1531 /* 1532 * 0 : override 1533 * 1 : Swap Jack 1534 * 2 : 0 --> Desktop, 1 --> Laptop 1535 * 3~5 : External Amplifier control 1536 * 7~6 : Reserved 1537 */ 1538 tmp = (ass & 0x38) >> 3; /* external Amp control */ 1539 switch (tmp) { 1540 case 1: 1541 spec->init_amp = ALC_INIT_GPIO1; 1542 break; 1543 case 3: 1544 spec->init_amp = ALC_INIT_GPIO2; 1545 break; 1546 case 7: 1547 spec->init_amp = ALC_INIT_GPIO3; 1548 break; 1549 case 5: 1550 default: 1551 spec->init_amp = ALC_INIT_DEFAULT; 1552 break; 1553 } 1554 1555 /* is laptop or Desktop and enable the function "Mute internal speaker 1556 * when the external headphone out jack is plugged" 1557 */ 1558 if (!(ass & 0x8000)) 1559 return 1; 1560 /* 1561 * 10~8 : Jack location 1562 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered 1563 * 14~13: Resvered 1564 * 15 : 1 --> enable the function "Mute internal speaker 1565 * when the external headphone out jack is plugged" 1566 */ 1567 if (!spec->autocfg.hp_pins[0]) { 1568 hda_nid_t nid; 1569 tmp = (ass >> 11) & 0x3; /* HP to chassis */ 1570 if (tmp == 0) 1571 nid = porta; 1572 else if (tmp == 1) 1573 nid = porte; 1574 else if (tmp == 2) 1575 nid = portd; 1576 else if (tmp == 3) 1577 nid = porti; 1578 else 1579 return 1; 1580 for (i = 0; i < spec->autocfg.line_outs; i++) 1581 if (spec->autocfg.line_out_pins[i] == nid) 1582 return 1; 1583 spec->autocfg.hp_pins[0] = nid; 1584 } 1585 1586 alc_init_auto_hp(codec); 1587 alc_init_auto_mic(codec); 1588 return 1; 1589} 1590 1591static void alc_ssid_check(struct hda_codec *codec, 1592 hda_nid_t porta, hda_nid_t porte, 1593 hda_nid_t portd, hda_nid_t porti) 1594{ 1595 if (!alc_subsystem_id(codec, porta, porte, portd, porti)) { 1596 struct alc_spec *spec = codec->spec; 1597 snd_printd("realtek: " 1598 "Enable default setup for auto mode as fallback\n"); 1599 spec->init_amp = ALC_INIT_DEFAULT; 1600 alc_init_auto_hp(codec); 1601 alc_init_auto_mic(codec); 1602 } 1603} 1604 1605/* 1606 * Fix-up pin default configurations and add default verbs 1607 */ 1608 1609struct alc_pincfg { 1610 hda_nid_t nid; 1611 u32 val; 1612}; 1613 1614struct alc_model_fixup { 1615 const int id; 1616 const char *name; 1617}; 1618 1619struct alc_fixup { 1620 int type; 1621 bool chained; 1622 int chain_id; 1623 union { 1624 unsigned int sku; 1625 const struct alc_pincfg *pins; 1626 const struct hda_verb *verbs; 1627 void (*func)(struct hda_codec *codec, 1628 const struct alc_fixup *fix, 1629 int action); 1630 } v; 1631}; 1632 1633enum { 1634 ALC_FIXUP_INVALID, 1635 ALC_FIXUP_SKU, 1636 ALC_FIXUP_PINS, 1637 ALC_FIXUP_VERBS, 1638 ALC_FIXUP_FUNC, 1639}; 1640 1641enum { 1642 ALC_FIXUP_ACT_PRE_PROBE, 1643 ALC_FIXUP_ACT_PROBE, 1644 ALC_FIXUP_ACT_INIT, 1645}; 1646 1647static void alc_apply_fixup(struct hda_codec *codec, int action) 1648{ 1649 struct alc_spec *spec = codec->spec; 1650 int id = spec->fixup_id; 1651#ifdef CONFIG_SND_DEBUG_VERBOSE 1652 const char *modelname = spec->fixup_name; 1653#endif 1654 int depth = 0; 1655 1656 if (!spec->fixup_list) 1657 return; 1658 1659 while (id >= 0) { 1660 const struct alc_fixup *fix = spec->fixup_list + id; 1661 const struct alc_pincfg *cfg; 1662 1663 switch (fix->type) { 1664 case ALC_FIXUP_SKU: 1665 if (action != ALC_FIXUP_ACT_PRE_PROBE || !fix->v.sku) 1666 break;; 1667 snd_printdd(KERN_INFO "hda_codec: %s: " 1668 "Apply sku override for %s\n", 1669 codec->chip_name, modelname); 1670 spec->cdefine.sku_cfg = fix->v.sku; 1671 spec->cdefine.fixup = 1; 1672 break; 1673 case ALC_FIXUP_PINS: 1674 cfg = fix->v.pins; 1675 if (action != ALC_FIXUP_ACT_PRE_PROBE || !cfg) 1676 break; 1677 snd_printdd(KERN_INFO "hda_codec: %s: " 1678 "Apply pincfg for %s\n", 1679 codec->chip_name, modelname); 1680 for (; cfg->nid; cfg++) 1681 snd_hda_codec_set_pincfg(codec, cfg->nid, 1682 cfg->val); 1683 break; 1684 case ALC_FIXUP_VERBS: 1685 if (action != ALC_FIXUP_ACT_PROBE || !fix->v.verbs) 1686 break; 1687 snd_printdd(KERN_INFO "hda_codec: %s: " 1688 "Apply fix-verbs for %s\n", 1689 codec->chip_name, modelname); 1690 add_verb(codec->spec, fix->v.verbs); 1691 break; 1692 case ALC_FIXUP_FUNC: 1693 if (!fix->v.func) 1694 break; 1695 snd_printdd(KERN_INFO "hda_codec: %s: " 1696 "Apply fix-func for %s\n", 1697 codec->chip_name, modelname); 1698 fix->v.func(codec, fix, action); 1699 break; 1700 default: 1701 snd_printk(KERN_ERR "hda_codec: %s: " 1702 "Invalid fixup type %d\n", 1703 codec->chip_name, fix->type); 1704 break; 1705 } 1706 if (!fix[id].chained) 1707 break; 1708 if (++depth > 10) 1709 break; 1710 id = fix[id].chain_id; 1711 } 1712} 1713 1714static void alc_pick_fixup(struct hda_codec *codec, 1715 const struct alc_model_fixup *models, 1716 const struct snd_pci_quirk *quirk, 1717 const struct alc_fixup *fixlist) 1718{ 1719 struct alc_spec *spec = codec->spec; 1720 int id = -1; 1721 const char *name = NULL; 1722 1723 if (codec->modelname && models) { 1724 while (models->name) { 1725 if (!strcmp(codec->modelname, models->name)) { 1726 id = models->id; 1727 name = models->name; 1728 break; 1729 } 1730 models++; 1731 } 1732 } 1733 if (id < 0) { 1734 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk); 1735 if (quirk) { 1736 id = quirk->value; 1737#ifdef CONFIG_SND_DEBUG_VERBOSE 1738 name = quirk->name; 1739#endif 1740 } 1741 } 1742 1743 spec->fixup_id = id; 1744 if (id >= 0) { 1745 spec->fixup_list = fixlist; 1746 spec->fixup_name = name; 1747 } 1748} 1749 1750static int alc_read_coef_idx(struct hda_codec *codec, 1751 unsigned int coef_idx) 1752{ 1753 unsigned int val; 1754 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 1755 coef_idx); 1756 val = snd_hda_codec_read(codec, 0x20, 0, 1757 AC_VERB_GET_PROC_COEF, 0); 1758 return val; 1759} 1760 1761static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx, 1762 unsigned int coef_val) 1763{ 1764 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 1765 coef_idx); 1766 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 1767 coef_val); 1768} 1769 1770/* set right pin controls for digital I/O */ 1771static void alc_auto_init_digital(struct hda_codec *codec) 1772{ 1773 struct alc_spec *spec = codec->spec; 1774 int i; 1775 hda_nid_t pin; 1776 1777 for (i = 0; i < spec->autocfg.dig_outs; i++) { 1778 pin = spec->autocfg.dig_out_pins[i]; 1779 if (pin) { 1780 snd_hda_codec_write(codec, pin, 0, 1781 AC_VERB_SET_PIN_WIDGET_CONTROL, 1782 PIN_OUT); 1783 } 1784 } 1785 pin = spec->autocfg.dig_in_pin; 1786 if (pin) 1787 snd_hda_codec_write(codec, pin, 0, 1788 AC_VERB_SET_PIN_WIDGET_CONTROL, 1789 PIN_IN); 1790} 1791 1792/* parse digital I/Os and set up NIDs in BIOS auto-parse mode */ 1793static void alc_auto_parse_digital(struct hda_codec *codec) 1794{ 1795 struct alc_spec *spec = codec->spec; 1796 int i, err; 1797 hda_nid_t dig_nid; 1798 1799 /* support multiple SPDIFs; the secondary is set up as a slave */ 1800 for (i = 0; i < spec->autocfg.dig_outs; i++) { 1801 err = snd_hda_get_connections(codec, 1802 spec->autocfg.dig_out_pins[i], 1803 &dig_nid, 1); 1804 if (err < 0) 1805 continue; 1806 if (!i) { 1807 spec->multiout.dig_out_nid = dig_nid; 1808 spec->dig_out_type = spec->autocfg.dig_out_type[0]; 1809 } else { 1810 spec->multiout.slave_dig_outs = spec->slave_dig_outs; 1811 if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1) 1812 break; 1813 spec->slave_dig_outs[i - 1] = dig_nid; 1814 } 1815 } 1816 1817 if (spec->autocfg.dig_in_pin) { 1818 dig_nid = codec->start_nid; 1819 for (i = 0; i < codec->num_nodes; i++, dig_nid++) { 1820 unsigned int wcaps = get_wcaps(codec, dig_nid); 1821 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN) 1822 continue; 1823 if (!(wcaps & AC_WCAP_DIGITAL)) 1824 continue; 1825 if (!(wcaps & AC_WCAP_CONN_LIST)) 1826 continue; 1827 err = get_connection_index(codec, dig_nid, 1828 spec->autocfg.dig_in_pin); 1829 if (err >= 0) { 1830 spec->dig_in_nid = dig_nid; 1831 break; 1832 } 1833 } 1834 } 1835} 1836 1837/* 1838 * ALC888 1839 */ 1840 1841/* 1842 * 2ch mode 1843 */ 1844static struct hda_verb alc888_4ST_ch2_intel_init[] = { 1845/* Mic-in jack as mic in */ 1846 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 1847 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 1848/* Line-in jack as Line in */ 1849 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 1850 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 1851/* Line-Out as Front */ 1852 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00}, 1853 { } /* end */ 1854}; 1855 1856/* 1857 * 4ch mode 1858 */ 1859static struct hda_verb alc888_4ST_ch4_intel_init[] = { 1860/* Mic-in jack as mic in */ 1861 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 1862 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 1863/* Line-in jack as Surround */ 1864 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1865 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1866/* Line-Out as Front */ 1867 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00}, 1868 { } /* end */ 1869}; 1870 1871/* 1872 * 6ch mode 1873 */ 1874static struct hda_verb alc888_4ST_ch6_intel_init[] = { 1875/* Mic-in jack as CLFE */ 1876 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1877 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1878/* Line-in jack as Surround */ 1879 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1880 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1881/* Line-Out as CLFE (workaround because Mic-in is not loud enough) */ 1882 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 1883 { } /* end */ 1884}; 1885 1886/* 1887 * 8ch mode 1888 */ 1889static struct hda_verb alc888_4ST_ch8_intel_init[] = { 1890/* Mic-in jack as CLFE */ 1891 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1892 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1893/* Line-in jack as Surround */ 1894 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1895 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1896/* Line-Out as Side */ 1897 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 1898 { } /* end */ 1899}; 1900 1901static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = { 1902 { 2, alc888_4ST_ch2_intel_init }, 1903 { 4, alc888_4ST_ch4_intel_init }, 1904 { 6, alc888_4ST_ch6_intel_init }, 1905 { 8, alc888_4ST_ch8_intel_init }, 1906}; 1907 1908/* 1909 * ALC888 Fujitsu Siemens Amillo xa3530 1910 */ 1911 1912static struct hda_verb alc888_fujitsu_xa3530_verbs[] = { 1913/* Front Mic: set to PIN_IN (empty by default) */ 1914 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1915/* Connect Internal HP to Front */ 1916 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1917 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1918 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 1919/* Connect Bass HP to Front */ 1920 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1921 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1922 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 1923/* Connect Line-Out side jack (SPDIF) to Side */ 1924 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1925 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1926 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 1927/* Connect Mic jack to CLFE */ 1928 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1929 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1930 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, 1931/* Connect Line-in jack to Surround */ 1932 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1933 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1934 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, 1935/* Connect HP out jack to Front */ 1936 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1937 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1938 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 1939/* Enable unsolicited event for HP jack and Line-out jack */ 1940 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 1941 {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 1942 {} 1943}; 1944 1945static void alc_automute_amp(struct hda_codec *codec) 1946{ 1947 alc_automute_speaker(codec, 0); 1948} 1949 1950static void alc_automute_amp_unsol_event(struct hda_codec *codec, 1951 unsigned int res) 1952{ 1953 if (codec->vendor_id == 0x10ec0880) 1954 res >>= 28; 1955 else 1956 res >>= 26; 1957 if (res == ALC880_HP_EVENT) 1958 alc_automute_amp(codec); 1959} 1960 1961static void alc889_automute_setup(struct hda_codec *codec) 1962{ 1963 struct alc_spec *spec = codec->spec; 1964 1965 spec->autocfg.hp_pins[0] = 0x15; 1966 spec->autocfg.speaker_pins[0] = 0x14; 1967 spec->autocfg.speaker_pins[1] = 0x16; 1968 spec->autocfg.speaker_pins[2] = 0x17; 1969 spec->autocfg.speaker_pins[3] = 0x19; 1970 spec->autocfg.speaker_pins[4] = 0x1a; 1971} 1972 1973static void alc889_intel_init_hook(struct hda_codec *codec) 1974{ 1975 alc889_coef_init(codec); 1976 alc_automute_amp(codec); 1977} 1978 1979static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec) 1980{ 1981 struct alc_spec *spec = codec->spec; 1982 1983 spec->autocfg.hp_pins[0] = 0x17; /* line-out */ 1984 spec->autocfg.hp_pins[1] = 0x1b; /* hp */ 1985 spec->autocfg.speaker_pins[0] = 0x14; /* speaker */ 1986 spec->autocfg.speaker_pins[1] = 0x15; /* bass */ 1987} 1988 1989/* 1990 * ALC888 Acer Aspire 4930G model 1991 */ 1992 1993static struct hda_verb alc888_acer_aspire_4930g_verbs[] = { 1994/* Front Mic: set to PIN_IN (empty by default) */ 1995 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1996/* Unselect Front Mic by default in input mixer 3 */ 1997 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)}, 1998/* Enable unsolicited event for HP jack */ 1999 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 2000/* Connect Internal HP to front */ 2001 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2002 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2003 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 2004/* Connect HP out to front */ 2005 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2006 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2007 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 2008 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 2009 { } 2010}; 2011 2012/* 2013 * ALC888 Acer Aspire 6530G model 2014 */ 2015 2016static struct hda_verb alc888_acer_aspire_6530g_verbs[] = { 2017/* Route to built-in subwoofer as well as speakers */ 2018 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2019 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2020 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2021 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2022/* Bias voltage on for external mic port */ 2023 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80}, 2024/* Front Mic: set to PIN_IN (empty by default) */ 2025 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2026/* Unselect Front Mic by default in input mixer 3 */ 2027 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)}, 2028/* Enable unsolicited event for HP jack */ 2029 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 2030/* Enable speaker output */ 2031 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2032 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2033 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 2034/* Enable headphone output */ 2035 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP}, 2036 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2037 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 2038 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 2039 { } 2040}; 2041 2042/* 2043 *ALC888 Acer Aspire 7730G model 2044 */ 2045 2046static struct hda_verb alc888_acer_aspire_7730G_verbs[] = { 2047/* Bias voltage on for external mic port */ 2048 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80}, 2049/* Front Mic: set to PIN_IN (empty by default) */ 2050 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2051/* Unselect Front Mic by default in input mixer 3 */ 2052 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)}, 2053/* Enable unsolicited event for HP jack */ 2054 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 2055/* Enable speaker output */ 2056 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2057 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2058 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 2059/* Enable headphone output */ 2060 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP}, 2061 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2062 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 2063 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 2064/*Enable internal subwoofer */ 2065 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2066 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2067 {0x17, AC_VERB_SET_CONNECT_SEL, 0x02}, 2068 {0x17, AC_VERB_SET_EAPD_BTLENABLE, 2}, 2069 { } 2070}; 2071 2072/* 2073 * ALC889 Acer Aspire 8930G model 2074 */ 2075 2076static struct hda_verb alc889_acer_aspire_8930g_verbs[] = { 2077/* Front Mic: set to PIN_IN (empty by default) */ 2078 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2079/* Unselect Front Mic by default in input mixer 3 */ 2080 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)}, 2081/* Enable unsolicited event for HP jack */ 2082 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 2083/* Connect Internal Front to Front */ 2084 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2085 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2086 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 2087/* Connect Internal Rear to Rear */ 2088 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2089 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2090 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01}, 2091/* Connect Internal CLFE to CLFE */ 2092 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2093 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2094 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02}, 2095/* Connect HP out to Front */ 2096 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP}, 2097 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2098 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 2099/* Enable all DACs */ 2100/* DAC DISABLE/MUTE 1? */ 2101/* setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */ 2102 {0x20, AC_VERB_SET_COEF_INDEX, 0x03}, 2103 {0x20, AC_VERB_SET_PROC_COEF, 0x0000}, 2104/* DAC DISABLE/MUTE 2? */ 2105/* some bit here disables the other DACs. Init=0x4900 */ 2106 {0x20, AC_VERB_SET_COEF_INDEX, 0x08}, 2107 {0x20, AC_VERB_SET_PROC_COEF, 0x0000}, 2108/* DMIC fix 2109 * This laptop has a stereo digital microphone. The mics are only 1cm apart 2110 * which makes the stereo useless. However, either the mic or the ALC889 2111 * makes the signal become a difference/sum signal instead of standard 2112 * stereo, which is annoying. So instead we flip this bit which makes the 2113 * codec replicate the sum signal to both channels, turning it into a 2114 * normal mono mic. 2115 */ 2116/* DMIC_CONTROL? Init value = 0x0001 */ 2117 {0x20, AC_VERB_SET_COEF_INDEX, 0x0b}, 2118 {0x20, AC_VERB_SET_PROC_COEF, 0x0003}, 2119 { } 2120}; 2121 2122static struct hda_input_mux alc888_2_capture_sources[2] = { 2123 /* Front mic only available on one ADC */ 2124 { 2125 .num_items = 4, 2126 .items = { 2127 { "Mic", 0x0 }, 2128 { "Line", 0x2 }, 2129 { "CD", 0x4 }, 2130 { "Front Mic", 0xb }, 2131 }, 2132 }, 2133 { 2134 .num_items = 3, 2135 .items = { 2136 { "Mic", 0x0 }, 2137 { "Line", 0x2 }, 2138 { "CD", 0x4 }, 2139 }, 2140 } 2141}; 2142 2143static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = { 2144 /* Interal mic only available on one ADC */ 2145 { 2146 .num_items = 5, 2147 .items = { 2148 { "Mic", 0x0 }, 2149 { "Line In", 0x2 }, 2150 { "CD", 0x4 }, 2151 { "Input Mix", 0xa }, 2152 { "Internal Mic", 0xb }, 2153 }, 2154 }, 2155 { 2156 .num_items = 4, 2157 .items = { 2158 { "Mic", 0x0 }, 2159 { "Line In", 0x2 }, 2160 { "CD", 0x4 }, 2161 { "Input Mix", 0xa }, 2162 }, 2163 } 2164}; 2165 2166static struct hda_input_mux alc889_capture_sources[3] = { 2167 /* Digital mic only available on first "ADC" */ 2168 { 2169 .num_items = 5, 2170 .items = { 2171 { "Mic", 0x0 }, 2172 { "Line", 0x2 }, 2173 { "CD", 0x4 }, 2174 { "Front Mic", 0xb }, 2175 { "Input Mix", 0xa }, 2176 }, 2177 }, 2178 { 2179 .num_items = 4, 2180 .items = { 2181 { "Mic", 0x0 }, 2182 { "Line", 0x2 }, 2183 { "CD", 0x4 }, 2184 { "Input Mix", 0xa }, 2185 }, 2186 }, 2187 { 2188 .num_items = 4, 2189 .items = { 2190 { "Mic", 0x0 }, 2191 { "Line", 0x2 }, 2192 { "CD", 0x4 }, 2193 { "Input Mix", 0xa }, 2194 }, 2195 } 2196}; 2197 2198static struct snd_kcontrol_new alc888_base_mixer[] = { 2199 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2200 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 2201 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 2202 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 2203 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, 2204 HDA_OUTPUT), 2205 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 2206 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 2207 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 2208 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 2209 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 2210 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 2211 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 2212 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 2213 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 2214 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 2215 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 2216 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 2217 { } /* end */ 2218}; 2219 2220static struct snd_kcontrol_new alc888_acer_aspire_4930g_mixer[] = { 2221 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2222 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 2223 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 2224 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 2225 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, 2226 HDA_OUTPUT), 2227 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 2228 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 2229 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 2230 HDA_CODEC_VOLUME_MONO("Internal LFE Playback Volume", 0x0f, 1, 0x0, HDA_OUTPUT), 2231 HDA_BIND_MUTE_MONO("Internal LFE Playback Switch", 0x0f, 1, 2, HDA_INPUT), 2232 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 2233 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 2234 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 2235 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 2236 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 2237 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 2238 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 2239 { } /* end */ 2240}; 2241 2242static struct snd_kcontrol_new alc889_acer_aspire_8930g_mixer[] = { 2243 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2244 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 2245 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 2246 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 2247 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, 2248 HDA_OUTPUT), 2249 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 2250 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 2251 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 2252 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 2253 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 2254 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 2255 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 2256 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 2257 { } /* end */ 2258}; 2259 2260 2261static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec) 2262{ 2263 struct alc_spec *spec = codec->spec; 2264 2265 spec->autocfg.hp_pins[0] = 0x15; 2266 spec->autocfg.speaker_pins[0] = 0x14; 2267 spec->autocfg.speaker_pins[1] = 0x16; 2268 spec->autocfg.speaker_pins[2] = 0x17; 2269} 2270 2271static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec) 2272{ 2273 struct alc_spec *spec = codec->spec; 2274 2275 spec->autocfg.hp_pins[0] = 0x15; 2276 spec->autocfg.speaker_pins[0] = 0x14; 2277 spec->autocfg.speaker_pins[1] = 0x16; 2278 spec->autocfg.speaker_pins[2] = 0x17; 2279} 2280 2281static void alc888_acer_aspire_7730g_setup(struct hda_codec *codec) 2282{ 2283 struct alc_spec *spec = codec->spec; 2284 2285 spec->autocfg.hp_pins[0] = 0x15; 2286 spec->autocfg.speaker_pins[0] = 0x14; 2287 spec->autocfg.speaker_pins[1] = 0x16; 2288 spec->autocfg.speaker_pins[2] = 0x17; 2289} 2290 2291static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec) 2292{ 2293 struct alc_spec *spec = codec->spec; 2294 2295 spec->autocfg.hp_pins[0] = 0x15; 2296 spec->autocfg.speaker_pins[0] = 0x14; 2297 spec->autocfg.speaker_pins[1] = 0x16; 2298 spec->autocfg.speaker_pins[2] = 0x1b; 2299} 2300 2301/* 2302 * ALC880 3-stack model 2303 * 2304 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e) 2305 * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18, 2306 * F-Mic = 0x1b, HP = 0x19 2307 */ 2308 2309static hda_nid_t alc880_dac_nids[4] = { 2310 /* front, rear, clfe, rear_surr */ 2311 0x02, 0x05, 0x04, 0x03 2312}; 2313 2314static hda_nid_t alc880_adc_nids[3] = { 2315 /* ADC0-2 */ 2316 0x07, 0x08, 0x09, 2317}; 2318 2319/* The datasheet says the node 0x07 is connected from inputs, 2320 * but it shows zero connection in the real implementation on some devices. 2321 * Note: this is a 915GAV bug, fixed on 915GLV 2322 */ 2323static hda_nid_t alc880_adc_nids_alt[2] = { 2324 /* ADC1-2 */ 2325 0x08, 0x09, 2326}; 2327 2328#define ALC880_DIGOUT_NID 0x06 2329#define ALC880_DIGIN_NID 0x0a 2330 2331static struct hda_input_mux alc880_capture_source = { 2332 .num_items = 4, 2333 .items = { 2334 { "Mic", 0x0 }, 2335 { "Front Mic", 0x3 }, 2336 { "Line", 0x2 }, 2337 { "CD", 0x4 }, 2338 }, 2339}; 2340 2341/* channel source setting (2/6 channel selection for 3-stack) */ 2342/* 2ch mode */ 2343static struct hda_verb alc880_threestack_ch2_init[] = { 2344 /* set line-in to input, mute it */ 2345 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 2346 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 2347 /* set mic-in to input vref 80%, mute it */ 2348 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 2349 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 2350 { } /* end */ 2351}; 2352 2353/* 6ch mode */ 2354static struct hda_verb alc880_threestack_ch6_init[] = { 2355 /* set line-in to output, unmute it */ 2356 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 2357 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 2358 /* set mic-in to output, unmute it */ 2359 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 2360 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 2361 { } /* end */ 2362}; 2363 2364static struct hda_channel_mode alc880_threestack_modes[2] = { 2365 { 2, alc880_threestack_ch2_init }, 2366 { 6, alc880_threestack_ch6_init }, 2367}; 2368 2369static struct snd_kcontrol_new alc880_three_stack_mixer[] = { 2370 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2371 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 2372 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 2373 HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT), 2374 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 2375 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 2376 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 2377 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 2378 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 2379 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 2380 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 2381 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 2382 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 2383 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 2384 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT), 2385 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT), 2386 HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT), 2387 { 2388 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2389 .name = "Channel Mode", 2390 .info = alc_ch_mode_info, 2391 .get = alc_ch_mode_get, 2392 .put = alc_ch_mode_put, 2393 }, 2394 { } /* end */ 2395}; 2396 2397/* capture mixer elements */ 2398static int alc_cap_vol_info(struct snd_kcontrol *kcontrol, 2399 struct snd_ctl_elem_info *uinfo) 2400{ 2401 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2402 struct alc_spec *spec = codec->spec; 2403 int err; 2404 2405 mutex_lock(&codec->control_mutex); 2406 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, 2407 HDA_INPUT); 2408 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo); 2409 mutex_unlock(&codec->control_mutex); 2410 return err; 2411} 2412 2413static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag, 2414 unsigned int size, unsigned int __user *tlv) 2415{ 2416 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2417 struct alc_spec *spec = codec->spec; 2418 int err; 2419 2420 mutex_lock(&codec->control_mutex); 2421 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, 2422 HDA_INPUT); 2423 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv); 2424 mutex_unlock(&codec->control_mutex); 2425 return err; 2426} 2427 2428typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol, 2429 struct snd_ctl_elem_value *ucontrol); 2430 2431static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol, 2432 struct snd_ctl_elem_value *ucontrol, 2433 getput_call_t func) 2434{ 2435 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2436 struct alc_spec *spec = codec->spec; 2437 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 2438 int err; 2439 2440 mutex_lock(&codec->control_mutex); 2441 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx], 2442 3, 0, HDA_INPUT); 2443 err = func(kcontrol, ucontrol); 2444 mutex_unlock(&codec->control_mutex); 2445 return err; 2446} 2447 2448static int alc_cap_vol_get(struct snd_kcontrol *kcontrol, 2449 struct snd_ctl_elem_value *ucontrol) 2450{ 2451 return alc_cap_getput_caller(kcontrol, ucontrol, 2452 snd_hda_mixer_amp_volume_get); 2453} 2454 2455static int alc_cap_vol_put(struct snd_kcontrol *kcontrol, 2456 struct snd_ctl_elem_value *ucontrol) 2457{ 2458 return alc_cap_getput_caller(kcontrol, ucontrol, 2459 snd_hda_mixer_amp_volume_put); 2460} 2461 2462/* capture mixer elements */ 2463#define alc_cap_sw_info snd_ctl_boolean_stereo_info 2464 2465static int alc_cap_sw_get(struct snd_kcontrol *kcontrol, 2466 struct snd_ctl_elem_value *ucontrol) 2467{ 2468 return alc_cap_getput_caller(kcontrol, ucontrol, 2469 snd_hda_mixer_amp_switch_get); 2470} 2471 2472static int alc_cap_sw_put(struct snd_kcontrol *kcontrol, 2473 struct snd_ctl_elem_value *ucontrol) 2474{ 2475 return alc_cap_getput_caller(kcontrol, ucontrol, 2476 snd_hda_mixer_amp_switch_put); 2477} 2478 2479#define _DEFINE_CAPMIX(num) \ 2480 { \ 2481 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 2482 .name = "Capture Switch", \ 2483 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \ 2484 .count = num, \ 2485 .info = alc_cap_sw_info, \ 2486 .get = alc_cap_sw_get, \ 2487 .put = alc_cap_sw_put, \ 2488 }, \ 2489 { \ 2490 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 2491 .name = "Capture Volume", \ 2492 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \ 2493 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \ 2494 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \ 2495 .count = num, \ 2496 .info = alc_cap_vol_info, \ 2497 .get = alc_cap_vol_get, \ 2498 .put = alc_cap_vol_put, \ 2499 .tlv = { .c = alc_cap_vol_tlv }, \ 2500 } 2501 2502#define _DEFINE_CAPSRC(num) \ 2503 { \ 2504 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 2505 /* .name = "Capture Source", */ \ 2506 .name = "Input Source", \ 2507 .count = num, \ 2508 .info = alc_mux_enum_info, \ 2509 .get = alc_mux_enum_get, \ 2510 .put = alc_mux_enum_put, \ 2511 } 2512 2513#define DEFINE_CAPMIX(num) \ 2514static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \ 2515 _DEFINE_CAPMIX(num), \ 2516 _DEFINE_CAPSRC(num), \ 2517 { } /* end */ \ 2518} 2519 2520#define DEFINE_CAPMIX_NOSRC(num) \ 2521static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \ 2522 _DEFINE_CAPMIX(num), \ 2523 { } /* end */ \ 2524} 2525 2526/* up to three ADCs */ 2527DEFINE_CAPMIX(1); 2528DEFINE_CAPMIX(2); 2529DEFINE_CAPMIX(3); 2530DEFINE_CAPMIX_NOSRC(1); 2531DEFINE_CAPMIX_NOSRC(2); 2532DEFINE_CAPMIX_NOSRC(3); 2533 2534/* 2535 * ALC880 5-stack model 2536 * 2537 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d), 2538 * Side = 0x02 (0xd) 2539 * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16 2540 * Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19 2541 */ 2542 2543/* additional mixers to alc880_three_stack_mixer */ 2544static struct snd_kcontrol_new alc880_five_stack_mixer[] = { 2545 HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 2546 HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT), 2547 { } /* end */ 2548}; 2549 2550/* channel source setting (6/8 channel selection for 5-stack) */ 2551/* 6ch mode */ 2552static struct hda_verb alc880_fivestack_ch6_init[] = { 2553 /* set line-in to input, mute it */ 2554 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 2555 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 2556 { } /* end */ 2557}; 2558 2559/* 8ch mode */ 2560static struct hda_verb alc880_fivestack_ch8_init[] = { 2561 /* set line-in to output, unmute it */ 2562 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 2563 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 2564 { } /* end */ 2565}; 2566 2567static struct hda_channel_mode alc880_fivestack_modes[2] = { 2568 { 6, alc880_fivestack_ch6_init }, 2569 { 8, alc880_fivestack_ch8_init }, 2570}; 2571 2572 2573/* 2574 * ALC880 6-stack model 2575 * 2576 * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e), 2577 * Side = 0x05 (0x0f) 2578 * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17, 2579 * Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b 2580 */ 2581 2582static hda_nid_t alc880_6st_dac_nids[4] = { 2583 /* front, rear, clfe, rear_surr */ 2584 0x02, 0x03, 0x04, 0x05 2585}; 2586 2587static struct hda_input_mux alc880_6stack_capture_source = { 2588 .num_items = 4, 2589 .items = { 2590 { "Mic", 0x0 }, 2591 { "Front Mic", 0x1 }, 2592 { "Line", 0x2 }, 2593 { "CD", 0x4 }, 2594 }, 2595}; 2596 2597/* fixed 8-channels */ 2598static struct hda_channel_mode alc880_sixstack_modes[1] = { 2599 { 8, NULL }, 2600}; 2601 2602static struct snd_kcontrol_new alc880_six_stack_mixer[] = { 2603 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2604 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 2605 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 2606 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 2607 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 2608 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 2609 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 2610 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 2611 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 2612 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 2613 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 2614 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 2615 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 2616 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 2617 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 2618 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 2619 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 2620 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 2621 { 2622 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2623 .name = "Channel Mode", 2624 .info = alc_ch_mode_info, 2625 .get = alc_ch_mode_get, 2626 .put = alc_ch_mode_put, 2627 }, 2628 { } /* end */ 2629}; 2630 2631 2632/* 2633 * ALC880 W810 model 2634 * 2635 * W810 has rear IO for: 2636 * Front (DAC 02) 2637 * Surround (DAC 03) 2638 * Center/LFE (DAC 04) 2639 * Digital out (06) 2640 * 2641 * The system also has a pair of internal speakers, and a headphone jack. 2642 * These are both connected to Line2 on the codec, hence to DAC 02. 2643 * 2644 * There is a variable resistor to control the speaker or headphone 2645 * volume. This is a hardware-only device without a software API. 2646 * 2647 * Plugging headphones in will disable the internal speakers. This is 2648 * implemented in hardware, not via the driver using jack sense. In 2649 * a similar fashion, plugging into the rear socket marked "front" will 2650 * disable both the speakers and headphones. 2651 * 2652 * For input, there's a microphone jack, and an "audio in" jack. 2653 * These may not do anything useful with this driver yet, because I 2654 * haven't setup any initialization verbs for these yet... 2655 */ 2656 2657static hda_nid_t alc880_w810_dac_nids[3] = { 2658 /* front, rear/surround, clfe */ 2659 0x02, 0x03, 0x04 2660}; 2661 2662/* fixed 6 channels */ 2663static struct hda_channel_mode alc880_w810_modes[1] = { 2664 { 6, NULL } 2665}; 2666 2667/* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */ 2668static struct snd_kcontrol_new alc880_w810_base_mixer[] = { 2669 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2670 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 2671 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 2672 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 2673 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 2674 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 2675 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 2676 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 2677 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 2678 { } /* end */ 2679}; 2680 2681 2682/* 2683 * Z710V model 2684 * 2685 * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d) 2686 * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?), 2687 * Line = 0x1a 2688 */ 2689 2690static hda_nid_t alc880_z71v_dac_nids[1] = { 2691 0x02 2692}; 2693#define ALC880_Z71V_HP_DAC 0x03 2694 2695/* fixed 2 channels */ 2696static struct hda_channel_mode alc880_2_jack_modes[1] = { 2697 { 2, NULL } 2698}; 2699 2700static struct snd_kcontrol_new alc880_z71v_mixer[] = { 2701 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2702 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 2703 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 2704 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT), 2705 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 2706 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 2707 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 2708 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 2709 { } /* end */ 2710}; 2711 2712 2713/* 2714 * ALC880 F1734 model 2715 * 2716 * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d) 2717 * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18 2718 */ 2719 2720static hda_nid_t alc880_f1734_dac_nids[1] = { 2721 0x03 2722}; 2723#define ALC880_F1734_HP_DAC 0x02 2724 2725static struct snd_kcontrol_new alc880_f1734_mixer[] = { 2726 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2727 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 2728 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 2729 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 2730 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 2731 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 2732 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 2733 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 2734 { } /* end */ 2735}; 2736 2737static struct hda_input_mux alc880_f1734_capture_source = { 2738 .num_items = 2, 2739 .items = { 2740 { "Mic", 0x1 }, 2741 { "CD", 0x4 }, 2742 }, 2743}; 2744 2745 2746/* 2747 * ALC880 ASUS model 2748 * 2749 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e) 2750 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16, 2751 * Mic = 0x18, Line = 0x1a 2752 */ 2753 2754#define alc880_asus_dac_nids alc880_w810_dac_nids /* identical with w810 */ 2755#define alc880_asus_modes alc880_threestack_modes /* 2/6 channel mode */ 2756 2757static struct snd_kcontrol_new alc880_asus_mixer[] = { 2758 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2759 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 2760 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 2761 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 2762 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 2763 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 2764 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 2765 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 2766 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 2767 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 2768 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 2769 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 2770 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 2771 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 2772 { 2773 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2774 .name = "Channel Mode", 2775 .info = alc_ch_mode_info, 2776 .get = alc_ch_mode_get, 2777 .put = alc_ch_mode_put, 2778 }, 2779 { } /* end */ 2780}; 2781 2782/* 2783 * ALC880 ASUS W1V model 2784 * 2785 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e) 2786 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16, 2787 * Mic = 0x18, Line = 0x1a, Line2 = 0x1b 2788 */ 2789 2790/* additional mixers to alc880_asus_mixer */ 2791static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = { 2792 HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT), 2793 HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT), 2794 { } /* end */ 2795}; 2796 2797/* TCL S700 */ 2798static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = { 2799 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2800 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 2801 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 2802 HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT), 2803 HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT), 2804 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT), 2805 HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT), 2806 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 2807 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 2808 { } /* end */ 2809}; 2810 2811/* Uniwill */ 2812static struct snd_kcontrol_new alc880_uniwill_mixer[] = { 2813 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2814 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 2815 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 2816 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 2817 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 2818 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 2819 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 2820 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 2821 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 2822 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 2823 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 2824 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 2825 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 2826 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 2827 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 2828 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 2829 { 2830 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2831 .name = "Channel Mode", 2832 .info = alc_ch_mode_info, 2833 .get = alc_ch_mode_get, 2834 .put = alc_ch_mode_put, 2835 }, 2836 { } /* end */ 2837}; 2838 2839static struct snd_kcontrol_new alc880_fujitsu_mixer[] = { 2840 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2841 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 2842 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 2843 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 2844 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 2845 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 2846 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 2847 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 2848 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 2849 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 2850 { } /* end */ 2851}; 2852 2853static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = { 2854 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2855 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 2856 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 2857 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 2858 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 2859 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 2860 { } /* end */ 2861}; 2862 2863/* 2864 * virtual master controls 2865 */ 2866 2867/* 2868 * slave controls for virtual master 2869 */ 2870static const char * const alc_slave_vols[] = { 2871 "Front Playback Volume", 2872 "Surround Playback Volume", 2873 "Center Playback Volume", 2874 "LFE Playback Volume", 2875 "Side Playback Volume", 2876 "Headphone Playback Volume", 2877 "Speaker Playback Volume", 2878 "Mono Playback Volume", 2879 "Line-Out Playback Volume", 2880 "PCM Playback Volume", 2881 NULL, 2882}; 2883 2884static const char * const alc_slave_sws[] = { 2885 "Front Playback Switch", 2886 "Surround Playback Switch", 2887 "Center Playback Switch", 2888 "LFE Playback Switch", 2889 "Side Playback Switch", 2890 "Headphone Playback Switch", 2891 "Speaker Playback Switch", 2892 "Mono Playback Switch", 2893 "IEC958 Playback Switch", 2894 "Line-Out Playback Switch", 2895 "PCM Playback Switch", 2896 NULL, 2897}; 2898 2899/* 2900 * build control elements 2901 */ 2902 2903#define NID_MAPPING (-1) 2904 2905#define SUBDEV_SPEAKER_ (0 << 6) 2906#define SUBDEV_HP_ (1 << 6) 2907#define SUBDEV_LINE_ (2 << 6) 2908#define SUBDEV_SPEAKER(x) (SUBDEV_SPEAKER_ | ((x) & 0x3f)) 2909#define SUBDEV_HP(x) (SUBDEV_HP_ | ((x) & 0x3f)) 2910#define SUBDEV_LINE(x) (SUBDEV_LINE_ | ((x) & 0x3f)) 2911 2912static void alc_free_kctls(struct hda_codec *codec); 2913 2914#ifdef CONFIG_SND_HDA_INPUT_BEEP 2915/* additional beep mixers; the actual parameters are overwritten at build */ 2916static struct snd_kcontrol_new alc_beep_mixer[] = { 2917 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT), 2918 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT), 2919 { } /* end */ 2920}; 2921#endif 2922 2923static int alc_build_controls(struct hda_codec *codec) 2924{ 2925 struct alc_spec *spec = codec->spec; 2926 struct snd_kcontrol *kctl = NULL; 2927 struct snd_kcontrol_new *knew; 2928 int i, j, err; 2929 unsigned int u; 2930 hda_nid_t nid; 2931 2932 for (i = 0; i < spec->num_mixers; i++) { 2933 err = snd_hda_add_new_ctls(codec, spec->mixers[i]); 2934 if (err < 0) 2935 return err; 2936 } 2937 if (spec->cap_mixer) { 2938 err = snd_hda_add_new_ctls(codec, spec->cap_mixer); 2939 if (err < 0) 2940 return err; 2941 } 2942 if (spec->multiout.dig_out_nid) { 2943 err = snd_hda_create_spdif_out_ctls(codec, 2944 spec->multiout.dig_out_nid); 2945 if (err < 0) 2946 return err; 2947 if (!spec->no_analog) { 2948 err = snd_hda_create_spdif_share_sw(codec, 2949 &spec->multiout); 2950 if (err < 0) 2951 return err; 2952 spec->multiout.share_spdif = 1; 2953 } 2954 } 2955 if (spec->dig_in_nid) { 2956 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid); 2957 if (err < 0) 2958 return err; 2959 } 2960 2961#ifdef CONFIG_SND_HDA_INPUT_BEEP 2962 /* create beep controls if needed */ 2963 if (spec->beep_amp) { 2964 struct snd_kcontrol_new *knew; 2965 for (knew = alc_beep_mixer; knew->name; knew++) { 2966 struct snd_kcontrol *kctl; 2967 kctl = snd_ctl_new1(knew, codec); 2968 if (!kctl) 2969 return -ENOMEM; 2970 kctl->private_value = spec->beep_amp; 2971 err = snd_hda_ctl_add(codec, 0, kctl); 2972 if (err < 0) 2973 return err; 2974 } 2975 } 2976#endif 2977 2978 /* if we have no master control, let's create it */ 2979 if (!spec->no_analog && 2980 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) { 2981 unsigned int vmaster_tlv[4]; 2982 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid, 2983 HDA_OUTPUT, vmaster_tlv); 2984 err = snd_hda_add_vmaster(codec, "Master Playback Volume", 2985 vmaster_tlv, alc_slave_vols); 2986 if (err < 0) 2987 return err; 2988 } 2989 if (!spec->no_analog && 2990 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) { 2991 err = snd_hda_add_vmaster(codec, "Master Playback Switch", 2992 NULL, alc_slave_sws); 2993 if (err < 0) 2994 return err; 2995 } 2996 2997 /* assign Capture Source enums to NID */ 2998 if (spec->capsrc_nids || spec->adc_nids) { 2999 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source"); 3000 if (!kctl) 3001 kctl = snd_hda_find_mixer_ctl(codec, "Input Source"); 3002 for (i = 0; kctl && i < kctl->count; i++) { 3003 hda_nid_t *nids = spec->capsrc_nids; 3004 if (!nids) 3005 nids = spec->adc_nids; 3006 err = snd_hda_add_nid(codec, kctl, i, nids[i]); 3007 if (err < 0) 3008 return err; 3009 } 3010 } 3011 if (spec->cap_mixer) { 3012 const char *kname = kctl ? kctl->id.name : NULL; 3013 for (knew = spec->cap_mixer; knew->name; knew++) { 3014 if (kname && strcmp(knew->name, kname) == 0) 3015 continue; 3016 kctl = snd_hda_find_mixer_ctl(codec, knew->name); 3017 for (i = 0; kctl && i < kctl->count; i++) { 3018 err = snd_hda_add_nid(codec, kctl, i, 3019 spec->adc_nids[i]); 3020 if (err < 0) 3021 return err; 3022 } 3023 } 3024 } 3025 3026 /* other nid->control mapping */ 3027 for (i = 0; i < spec->num_mixers; i++) { 3028 for (knew = spec->mixers[i]; knew->name; knew++) { 3029 if (knew->iface != NID_MAPPING) 3030 continue; 3031 kctl = snd_hda_find_mixer_ctl(codec, knew->name); 3032 if (kctl == NULL) 3033 continue; 3034 u = knew->subdevice; 3035 for (j = 0; j < 4; j++, u >>= 8) { 3036 nid = u & 0x3f; 3037 if (nid == 0) 3038 continue; 3039 switch (u & 0xc0) { 3040 case SUBDEV_SPEAKER_: 3041 nid = spec->autocfg.speaker_pins[nid]; 3042 break; 3043 case SUBDEV_LINE_: 3044 nid = spec->autocfg.line_out_pins[nid]; 3045 break; 3046 case SUBDEV_HP_: 3047 nid = spec->autocfg.hp_pins[nid]; 3048 break; 3049 default: 3050 continue; 3051 } 3052 err = snd_hda_add_nid(codec, kctl, 0, nid); 3053 if (err < 0) 3054 return err; 3055 } 3056 u = knew->private_value; 3057 for (j = 0; j < 4; j++, u >>= 8) { 3058 nid = u & 0xff; 3059 if (nid == 0) 3060 continue; 3061 err = snd_hda_add_nid(codec, kctl, 0, nid); 3062 if (err < 0) 3063 return err; 3064 } 3065 } 3066 } 3067 3068 alc_free_kctls(codec); /* no longer needed */ 3069 3070 return 0; 3071} 3072 3073 3074/* 3075 * initialize the codec volumes, etc 3076 */ 3077 3078/* 3079 * generic initialization of ADC, input mixers and output mixers 3080 */ 3081static struct hda_verb alc880_volume_init_verbs[] = { 3082 /* 3083 * Unmute ADC0-2 and set the default input to mic-in 3084 */ 3085 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 3086 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3087 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 3088 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3089 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 3090 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3091 3092 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 3093 * mixer widget 3094 * Note: PASD motherboards uses the Line In 2 as the input for front 3095 * panel mic (mic 2) 3096 */ 3097 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 3098 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3099 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 3100 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 3101 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 3102 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 3103 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 3104 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 3105 3106 /* 3107 * Set up output mixers (0x0c - 0x0f) 3108 */ 3109 /* set vol=0 to output mixers */ 3110 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 3111 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 3112 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 3113 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 3114 /* set up input amps for analog loopback */ 3115 /* Amp Indices: DAC = 0, mixer = 1 */ 3116 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3117 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 3118 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3119 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 3120 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3121 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 3122 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3123 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 3124 3125 { } 3126}; 3127 3128/* 3129 * 3-stack pin configuration: 3130 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b 3131 */ 3132static struct hda_verb alc880_pin_3stack_init_verbs[] = { 3133 /* 3134 * preset connection lists of input pins 3135 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround 3136 */ 3137 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 3138 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 3139 {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */ 3140 3141 /* 3142 * Set pin mode and muting 3143 */ 3144 /* set front pin widgets 0x14 for output */ 3145 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3146 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3147 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 3148 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3149 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3150 /* Mic2 (as headphone out) for HP output */ 3151 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3152 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3153 /* Line In pin widget for input */ 3154 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3155 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3156 /* Line2 (as front mic) pin widget for input and vref at 80% */ 3157 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3158 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3159 /* CD pin widget for input */ 3160 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3161 3162 { } 3163}; 3164 3165/* 3166 * 5-stack pin configuration: 3167 * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19, 3168 * line-in/side = 0x1a, f-mic = 0x1b 3169 */ 3170static struct hda_verb alc880_pin_5stack_init_verbs[] = { 3171 /* 3172 * preset connection lists of input pins 3173 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround 3174 */ 3175 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 3176 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */ 3177 3178 /* 3179 * Set pin mode and muting 3180 */ 3181 /* set pin widgets 0x14-0x17 for output */ 3182 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3183 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3184 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3185 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3186 /* unmute pins for output (no gain on this amp) */ 3187 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3188 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3189 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3190 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3191 3192 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 3193 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3194 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3195 /* Mic2 (as headphone out) for HP output */ 3196 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3197 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3198 /* Line In pin widget for input */ 3199 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3200 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3201 /* Line2 (as front mic) pin widget for input and vref at 80% */ 3202 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3203 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3204 /* CD pin widget for input */ 3205 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3206 3207 { } 3208}; 3209 3210/* 3211 * W810 pin configuration: 3212 * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b 3213 */ 3214static struct hda_verb alc880_pin_w810_init_verbs[] = { 3215 /* hphone/speaker input selector: front DAC */ 3216 {0x13, AC_VERB_SET_CONNECT_SEL, 0x0}, 3217 3218 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3219 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3220 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3221 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3222 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3223 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3224 3225 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3226 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3227 3228 { } 3229}; 3230 3231/* 3232 * Z71V pin configuration: 3233 * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?) 3234 */ 3235static struct hda_verb alc880_pin_z71v_init_verbs[] = { 3236 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3237 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3238 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3239 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3240 3241 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3242 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3243 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3244 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3245 3246 { } 3247}; 3248 3249/* 3250 * 6-stack pin configuration: 3251 * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18, 3252 * f-mic = 0x19, line = 0x1a, HP = 0x1b 3253 */ 3254static struct hda_verb alc880_pin_6stack_init_verbs[] = { 3255 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 3256 3257 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3258 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3259 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3260 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3261 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3262 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3263 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3264 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3265 3266 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3267 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3268 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3269 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3270 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3271 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3272 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3273 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3274 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3275 3276 { } 3277}; 3278 3279/* 3280 * Uniwill pin configuration: 3281 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19, 3282 * line = 0x1a 3283 */ 3284static struct hda_verb alc880_uniwill_init_verbs[] = { 3285 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 3286 3287 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3288 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3289 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3290 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3291 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3292 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3293 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3294 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3295 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 3296 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 3297 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 3298 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 3299 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 3300 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 3301 3302 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3303 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3304 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3305 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3306 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3307 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3308 /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */ 3309 /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */ 3310 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3311 3312 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 3313 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 3314 3315 { } 3316}; 3317 3318/* 3319* Uniwill P53 3320* HP = 0x14, InternalSpeaker = 0x15, mic = 0x19, 3321 */ 3322static struct hda_verb alc880_uniwill_p53_init_verbs[] = { 3323 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 3324 3325 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3326 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3327 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3328 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3329 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3330 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3331 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 3332 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 3333 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 3334 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 3335 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 3336 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 3337 3338 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3339 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3340 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3341 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3342 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3343 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3344 3345 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 3346 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT}, 3347 3348 { } 3349}; 3350 3351static struct hda_verb alc880_beep_init_verbs[] = { 3352 { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) }, 3353 { } 3354}; 3355 3356/* auto-toggle front mic */ 3357static void alc88x_simple_mic_automute(struct hda_codec *codec) 3358{ 3359 unsigned int present; 3360 unsigned char bits; 3361 3362 present = snd_hda_jack_detect(codec, 0x18); 3363 bits = present ? HDA_AMP_MUTE : 0; 3364 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits); 3365} 3366 3367static void alc880_uniwill_setup(struct hda_codec *codec) 3368{ 3369 struct alc_spec *spec = codec->spec; 3370 3371 spec->autocfg.hp_pins[0] = 0x14; 3372 spec->autocfg.speaker_pins[0] = 0x15; 3373 spec->autocfg.speaker_pins[0] = 0x16; 3374} 3375 3376static void alc880_uniwill_init_hook(struct hda_codec *codec) 3377{ 3378 alc_automute_amp(codec); 3379 alc88x_simple_mic_automute(codec); 3380} 3381 3382static void alc880_uniwill_unsol_event(struct hda_codec *codec, 3383 unsigned int res) 3384{ 3385 /* Looks like the unsol event is incompatible with the standard 3386 * definition. 4bit tag is placed at 28 bit! 3387 */ 3388 switch (res >> 28) { 3389 case ALC880_MIC_EVENT: 3390 alc88x_simple_mic_automute(codec); 3391 break; 3392 default: 3393 alc_automute_amp_unsol_event(codec, res); 3394 break; 3395 } 3396} 3397 3398static void alc880_uniwill_p53_setup(struct hda_codec *codec) 3399{ 3400 struct alc_spec *spec = codec->spec; 3401 3402 spec->autocfg.hp_pins[0] = 0x14; 3403 spec->autocfg.speaker_pins[0] = 0x15; 3404} 3405 3406static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec) 3407{ 3408 unsigned int present; 3409 3410 present = snd_hda_codec_read(codec, 0x21, 0, 3411 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0); 3412 present &= HDA_AMP_VOLMASK; 3413 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, 3414 HDA_AMP_VOLMASK, present); 3415 snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0, 3416 HDA_AMP_VOLMASK, present); 3417} 3418 3419static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec, 3420 unsigned int res) 3421{ 3422 /* Looks like the unsol event is incompatible with the standard 3423 * definition. 4bit tag is placed at 28 bit! 3424 */ 3425 if ((res >> 28) == ALC880_DCVOL_EVENT) 3426 alc880_uniwill_p53_dcvol_automute(codec); 3427 else 3428 alc_automute_amp_unsol_event(codec, res); 3429} 3430 3431/* 3432 * F1734 pin configuration: 3433 * HP = 0x14, speaker-out = 0x15, mic = 0x18 3434 */ 3435static struct hda_verb alc880_pin_f1734_init_verbs[] = { 3436 {0x07, AC_VERB_SET_CONNECT_SEL, 0x01}, 3437 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, 3438 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, 3439 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, 3440 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, 3441 3442 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3443 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3444 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3445 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3446 3447 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3448 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3449 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50}, 3450 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3451 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3452 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3453 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3454 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3455 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3456 3457 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT}, 3458 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT}, 3459 3460 { } 3461}; 3462 3463/* 3464 * ASUS pin configuration: 3465 * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a 3466 */ 3467static struct hda_verb alc880_pin_asus_init_verbs[] = { 3468 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, 3469 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, 3470 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, 3471 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, 3472 3473 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3474 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3475 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3476 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3477 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3478 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3479 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3480 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3481 3482 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3483 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3484 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3485 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3486 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3487 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3488 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3489 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3490 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3491 3492 { } 3493}; 3494 3495/* Enable GPIO mask and set output */ 3496#define alc880_gpio1_init_verbs alc_gpio1_init_verbs 3497#define alc880_gpio2_init_verbs alc_gpio2_init_verbs 3498#define alc880_gpio3_init_verbs alc_gpio3_init_verbs 3499 3500/* Clevo m520g init */ 3501static struct hda_verb alc880_pin_clevo_init_verbs[] = { 3502 /* headphone output */ 3503 {0x11, AC_VERB_SET_CONNECT_SEL, 0x01}, 3504 /* line-out */ 3505 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3506 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3507 /* Line-in */ 3508 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3509 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3510 /* CD */ 3511 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3512 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3513 /* Mic1 (rear panel) */ 3514 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3515 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3516 /* Mic2 (front panel) */ 3517 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3518 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3519 /* headphone */ 3520 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3521 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3522 /* change to EAPD mode */ 3523 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 3524 {0x20, AC_VERB_SET_PROC_COEF, 0x3060}, 3525 3526 { } 3527}; 3528 3529static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = { 3530 /* change to EAPD mode */ 3531 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 3532 {0x20, AC_VERB_SET_PROC_COEF, 0x3060}, 3533 3534 /* Headphone output */ 3535 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3536 /* Front output*/ 3537 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3538 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 3539 3540 /* Line In pin widget for input */ 3541 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3542 /* CD pin widget for input */ 3543 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3544 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 3545 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3546 3547 /* change to EAPD mode */ 3548 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 3549 {0x20, AC_VERB_SET_PROC_COEF, 0x3070}, 3550 3551 { } 3552}; 3553 3554/* 3555 * LG m1 express dual 3556 * 3557 * Pin assignment: 3558 * Rear Line-In/Out (blue): 0x14 3559 * Build-in Mic-In: 0x15 3560 * Speaker-out: 0x17 3561 * HP-Out (green): 0x1b 3562 * Mic-In/Out (red): 0x19 3563 * SPDIF-Out: 0x1e 3564 */ 3565 3566/* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */ 3567static hda_nid_t alc880_lg_dac_nids[3] = { 3568 0x05, 0x02, 0x03 3569}; 3570 3571/* seems analog CD is not working */ 3572static struct hda_input_mux alc880_lg_capture_source = { 3573 .num_items = 3, 3574 .items = { 3575 { "Mic", 0x1 }, 3576 { "Line", 0x5 }, 3577 { "Internal Mic", 0x6 }, 3578 }, 3579}; 3580 3581/* 2,4,6 channel modes */ 3582static struct hda_verb alc880_lg_ch2_init[] = { 3583 /* set line-in and mic-in to input */ 3584 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 3585 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 3586 { } 3587}; 3588 3589static struct hda_verb alc880_lg_ch4_init[] = { 3590 /* set line-in to out and mic-in to input */ 3591 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, 3592 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 3593 { } 3594}; 3595 3596static struct hda_verb alc880_lg_ch6_init[] = { 3597 /* set line-in and mic-in to output */ 3598 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, 3599 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, 3600 { } 3601}; 3602 3603static struct hda_channel_mode alc880_lg_ch_modes[3] = { 3604 { 2, alc880_lg_ch2_init }, 3605 { 4, alc880_lg_ch4_init }, 3606 { 6, alc880_lg_ch6_init }, 3607}; 3608 3609static struct snd_kcontrol_new alc880_lg_mixer[] = { 3610 HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 3611 HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT), 3612 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 3613 HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT), 3614 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT), 3615 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT), 3616 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT), 3617 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT), 3618 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 3619 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 3620 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT), 3621 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT), 3622 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT), 3623 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT), 3624 { 3625 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3626 .name = "Channel Mode", 3627 .info = alc_ch_mode_info, 3628 .get = alc_ch_mode_get, 3629 .put = alc_ch_mode_put, 3630 }, 3631 { } /* end */ 3632}; 3633 3634static struct hda_verb alc880_lg_init_verbs[] = { 3635 /* set capture source to mic-in */ 3636 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3637 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3638 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3639 /* mute all amp mixer inputs */ 3640 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)}, 3641 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 3642 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 3643 /* line-in to input */ 3644 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3645 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3646 /* built-in mic */ 3647 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3648 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3649 /* speaker-out */ 3650 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3651 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3652 /* mic-in to input */ 3653 {0x11, AC_VERB_SET_CONNECT_SEL, 0x01}, 3654 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3655 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3656 /* HP-out */ 3657 {0x13, AC_VERB_SET_CONNECT_SEL, 0x03}, 3658 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3659 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3660 /* jack sense */ 3661 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 3662 { } 3663}; 3664 3665/* toggle speaker-output according to the hp-jack state */ 3666static void alc880_lg_setup(struct hda_codec *codec) 3667{ 3668 struct alc_spec *spec = codec->spec; 3669 3670 spec->autocfg.hp_pins[0] = 0x1b; 3671 spec->autocfg.speaker_pins[0] = 0x17; 3672} 3673 3674/* 3675 * LG LW20 3676 * 3677 * Pin assignment: 3678 * Speaker-out: 0x14 3679 * Mic-In: 0x18 3680 * Built-in Mic-In: 0x19 3681 * Line-In: 0x1b 3682 * HP-Out: 0x1a 3683 * SPDIF-Out: 0x1e 3684 */ 3685 3686static struct hda_input_mux alc880_lg_lw_capture_source = { 3687 .num_items = 3, 3688 .items = { 3689 { "Mic", 0x0 }, 3690 { "Internal Mic", 0x1 }, 3691 { "Line In", 0x2 }, 3692 }, 3693}; 3694 3695#define alc880_lg_lw_modes alc880_threestack_modes 3696 3697static struct snd_kcontrol_new alc880_lg_lw_mixer[] = { 3698 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 3699 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 3700 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 3701 HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT), 3702 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 3703 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 3704 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 3705 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 3706 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 3707 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 3708 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 3709 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 3710 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 3711 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 3712 { 3713 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3714 .name = "Channel Mode", 3715 .info = alc_ch_mode_info, 3716 .get = alc_ch_mode_get, 3717 .put = alc_ch_mode_put, 3718 }, 3719 { } /* end */ 3720}; 3721 3722static struct hda_verb alc880_lg_lw_init_verbs[] = { 3723 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 3724 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 3725 {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */ 3726 3727 /* set capture source to mic-in */ 3728 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3729 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3730 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3731 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 3732 /* speaker-out */ 3733 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3734 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3735 /* HP-out */ 3736 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3737 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3738 /* mic-in to input */ 3739 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3740 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3741 /* built-in mic */ 3742 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3743 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3744 /* jack sense */ 3745 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 3746 { } 3747}; 3748 3749/* toggle speaker-output according to the hp-jack state */ 3750static void alc880_lg_lw_setup(struct hda_codec *codec) 3751{ 3752 struct alc_spec *spec = codec->spec; 3753 3754 spec->autocfg.hp_pins[0] = 0x1b; 3755 spec->autocfg.speaker_pins[0] = 0x14; 3756} 3757 3758static struct snd_kcontrol_new alc880_medion_rim_mixer[] = { 3759 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 3760 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT), 3761 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 3762 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 3763 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 3764 HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT), 3765 { } /* end */ 3766}; 3767 3768static struct hda_input_mux alc880_medion_rim_capture_source = { 3769 .num_items = 2, 3770 .items = { 3771 { "Mic", 0x0 }, 3772 { "Internal Mic", 0x1 }, 3773 }, 3774}; 3775 3776static struct hda_verb alc880_medion_rim_init_verbs[] = { 3777 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 3778 3779 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3780 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3781 3782 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 3783 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3784 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3785 /* Mic2 (as headphone out) for HP output */ 3786 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3787 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3788 /* Internal Speaker */ 3789 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3790 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3791 3792 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 3793 {0x20, AC_VERB_SET_PROC_COEF, 0x3060}, 3794 3795 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 3796 { } 3797}; 3798 3799/* toggle speaker-output according to the hp-jack state */ 3800static void alc880_medion_rim_automute(struct hda_codec *codec) 3801{ 3802 struct alc_spec *spec = codec->spec; 3803 alc_automute_amp(codec); 3804 /* toggle EAPD */ 3805 if (spec->jack_present) 3806 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0); 3807 else 3808 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2); 3809} 3810 3811static void alc880_medion_rim_unsol_event(struct hda_codec *codec, 3812 unsigned int res) 3813{ 3814 /* Looks like the unsol event is incompatible with the standard 3815 * definition. 4bit tag is placed at 28 bit! 3816 */ 3817 if ((res >> 28) == ALC880_HP_EVENT) 3818 alc880_medion_rim_automute(codec); 3819} 3820 3821static void alc880_medion_rim_setup(struct hda_codec *codec) 3822{ 3823 struct alc_spec *spec = codec->spec; 3824 3825 spec->autocfg.hp_pins[0] = 0x14; 3826 spec->autocfg.speaker_pins[0] = 0x1b; 3827} 3828 3829#ifdef CONFIG_SND_HDA_POWER_SAVE 3830static struct hda_amp_list alc880_loopbacks[] = { 3831 { 0x0b, HDA_INPUT, 0 }, 3832 { 0x0b, HDA_INPUT, 1 }, 3833 { 0x0b, HDA_INPUT, 2 }, 3834 { 0x0b, HDA_INPUT, 3 }, 3835 { 0x0b, HDA_INPUT, 4 }, 3836 { } /* end */ 3837}; 3838 3839static struct hda_amp_list alc880_lg_loopbacks[] = { 3840 { 0x0b, HDA_INPUT, 1 }, 3841 { 0x0b, HDA_INPUT, 6 }, 3842 { 0x0b, HDA_INPUT, 7 }, 3843 { } /* end */ 3844}; 3845#endif 3846 3847/* 3848 * Common callbacks 3849 */ 3850 3851static void alc_init_special_input_src(struct hda_codec *codec); 3852 3853static int alc_init(struct hda_codec *codec) 3854{ 3855 struct alc_spec *spec = codec->spec; 3856 unsigned int i; 3857 3858 alc_fix_pll(codec); 3859 alc_auto_init_amp(codec, spec->init_amp); 3860 3861 for (i = 0; i < spec->num_init_verbs; i++) 3862 snd_hda_sequence_write(codec, spec->init_verbs[i]); 3863 alc_init_special_input_src(codec); 3864 3865 if (spec->init_hook) 3866 spec->init_hook(codec); 3867 3868 alc_apply_fixup(codec, ALC_FIXUP_ACT_INIT); 3869 3870 hda_call_check_power_status(codec, 0x01); 3871 return 0; 3872} 3873 3874static void alc_unsol_event(struct hda_codec *codec, unsigned int res) 3875{ 3876 struct alc_spec *spec = codec->spec; 3877 3878 if (spec->unsol_event) 3879 spec->unsol_event(codec, res); 3880} 3881 3882#ifdef CONFIG_SND_HDA_POWER_SAVE 3883static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid) 3884{ 3885 struct alc_spec *spec = codec->spec; 3886 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid); 3887} 3888#endif 3889 3890/* 3891 * Analog playback callbacks 3892 */ 3893static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo, 3894 struct hda_codec *codec, 3895 struct snd_pcm_substream *substream) 3896{ 3897 struct alc_spec *spec = codec->spec; 3898 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, 3899 hinfo); 3900} 3901 3902static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 3903 struct hda_codec *codec, 3904 unsigned int stream_tag, 3905 unsigned int format, 3906 struct snd_pcm_substream *substream) 3907{ 3908 struct alc_spec *spec = codec->spec; 3909 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, 3910 stream_tag, format, substream); 3911} 3912 3913static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 3914 struct hda_codec *codec, 3915 struct snd_pcm_substream *substream) 3916{ 3917 struct alc_spec *spec = codec->spec; 3918 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); 3919} 3920 3921/* 3922 * Digital out 3923 */ 3924static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, 3925 struct hda_codec *codec, 3926 struct snd_pcm_substream *substream) 3927{ 3928 struct alc_spec *spec = codec->spec; 3929 return snd_hda_multi_out_dig_open(codec, &spec->multiout); 3930} 3931 3932static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 3933 struct hda_codec *codec, 3934 unsigned int stream_tag, 3935 unsigned int format, 3936 struct snd_pcm_substream *substream) 3937{ 3938 struct alc_spec *spec = codec->spec; 3939 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, 3940 stream_tag, format, substream); 3941} 3942 3943static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 3944 struct hda_codec *codec, 3945 struct snd_pcm_substream *substream) 3946{ 3947 struct alc_spec *spec = codec->spec; 3948 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout); 3949} 3950 3951static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, 3952 struct hda_codec *codec, 3953 struct snd_pcm_substream *substream) 3954{ 3955 struct alc_spec *spec = codec->spec; 3956 return snd_hda_multi_out_dig_close(codec, &spec->multiout); 3957} 3958 3959/* 3960 * Analog capture 3961 */ 3962static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 3963 struct hda_codec *codec, 3964 unsigned int stream_tag, 3965 unsigned int format, 3966 struct snd_pcm_substream *substream) 3967{ 3968 struct alc_spec *spec = codec->spec; 3969 3970 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1], 3971 stream_tag, 0, format); 3972 return 0; 3973} 3974 3975static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 3976 struct hda_codec *codec, 3977 struct snd_pcm_substream *substream) 3978{ 3979 struct alc_spec *spec = codec->spec; 3980 3981 snd_hda_codec_cleanup_stream(codec, 3982 spec->adc_nids[substream->number + 1]); 3983 return 0; 3984} 3985 3986/* analog capture with dynamic dual-adc changes */ 3987static int dualmic_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 3988 struct hda_codec *codec, 3989 unsigned int stream_tag, 3990 unsigned int format, 3991 struct snd_pcm_substream *substream) 3992{ 3993 struct alc_spec *spec = codec->spec; 3994 spec->cur_adc = spec->adc_nids[spec->cur_adc_idx]; 3995 spec->cur_adc_stream_tag = stream_tag; 3996 spec->cur_adc_format = format; 3997 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format); 3998 return 0; 3999} 4000 4001static int dualmic_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 4002 struct hda_codec *codec, 4003 struct snd_pcm_substream *substream) 4004{ 4005 struct alc_spec *spec = codec->spec; 4006 snd_hda_codec_cleanup_stream(codec, spec->cur_adc); 4007 spec->cur_adc = 0; 4008 return 0; 4009} 4010 4011static struct hda_pcm_stream dualmic_pcm_analog_capture = { 4012 .substreams = 1, 4013 .channels_min = 2, 4014 .channels_max = 2, 4015 .nid = 0, /* fill later */ 4016 .ops = { 4017 .prepare = dualmic_capture_pcm_prepare, 4018 .cleanup = dualmic_capture_pcm_cleanup 4019 }, 4020}; 4021 4022/* 4023 */ 4024static struct hda_pcm_stream alc880_pcm_analog_playback = { 4025 .substreams = 1, 4026 .channels_min = 2, 4027 .channels_max = 8, 4028 /* NID is set in alc_build_pcms */ 4029 .ops = { 4030 .open = alc880_playback_pcm_open, 4031 .prepare = alc880_playback_pcm_prepare, 4032 .cleanup = alc880_playback_pcm_cleanup 4033 }, 4034}; 4035 4036static struct hda_pcm_stream alc880_pcm_analog_capture = { 4037 .substreams = 1, 4038 .channels_min = 2, 4039 .channels_max = 2, 4040 /* NID is set in alc_build_pcms */ 4041}; 4042 4043static struct hda_pcm_stream alc880_pcm_analog_alt_playback = { 4044 .substreams = 1, 4045 .channels_min = 2, 4046 .channels_max = 2, 4047 /* NID is set in alc_build_pcms */ 4048}; 4049 4050static struct hda_pcm_stream alc880_pcm_analog_alt_capture = { 4051 .substreams = 2, /* can be overridden */ 4052 .channels_min = 2, 4053 .channels_max = 2, 4054 /* NID is set in alc_build_pcms */ 4055 .ops = { 4056 .prepare = alc880_alt_capture_pcm_prepare, 4057 .cleanup = alc880_alt_capture_pcm_cleanup 4058 }, 4059}; 4060 4061static struct hda_pcm_stream alc880_pcm_digital_playback = { 4062 .substreams = 1, 4063 .channels_min = 2, 4064 .channels_max = 2, 4065 /* NID is set in alc_build_pcms */ 4066 .ops = { 4067 .open = alc880_dig_playback_pcm_open, 4068 .close = alc880_dig_playback_pcm_close, 4069 .prepare = alc880_dig_playback_pcm_prepare, 4070 .cleanup = alc880_dig_playback_pcm_cleanup 4071 }, 4072}; 4073 4074static struct hda_pcm_stream alc880_pcm_digital_capture = { 4075 .substreams = 1, 4076 .channels_min = 2, 4077 .channels_max = 2, 4078 /* NID is set in alc_build_pcms */ 4079}; 4080 4081/* Used by alc_build_pcms to flag that a PCM has no playback stream */ 4082static struct hda_pcm_stream alc_pcm_null_stream = { 4083 .substreams = 0, 4084 .channels_min = 0, 4085 .channels_max = 0, 4086}; 4087 4088static int alc_build_pcms(struct hda_codec *codec) 4089{ 4090 struct alc_spec *spec = codec->spec; 4091 struct hda_pcm *info = spec->pcm_rec; 4092 int i; 4093 4094 codec->num_pcms = 1; 4095 codec->pcm_info = info; 4096 4097 if (spec->no_analog) 4098 goto skip_analog; 4099 4100 snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog), 4101 "%s Analog", codec->chip_name); 4102 info->name = spec->stream_name_analog; 4103 4104 if (spec->stream_analog_playback) { 4105 if (snd_BUG_ON(!spec->multiout.dac_nids)) 4106 return -EINVAL; 4107 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback); 4108 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0]; 4109 } 4110 if (spec->stream_analog_capture) { 4111 if (snd_BUG_ON(!spec->adc_nids)) 4112 return -EINVAL; 4113 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture); 4114 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; 4115 } 4116 4117 if (spec->channel_mode) { 4118 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0; 4119 for (i = 0; i < spec->num_channel_mode; i++) { 4120 if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) { 4121 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels; 4122 } 4123 } 4124 } 4125 4126 skip_analog: 4127 /* SPDIF for stream index #1 */ 4128 if (spec->multiout.dig_out_nid || spec->dig_in_nid) { 4129 snprintf(spec->stream_name_digital, 4130 sizeof(spec->stream_name_digital), 4131 "%s Digital", codec->chip_name); 4132 codec->num_pcms = 2; 4133 codec->slave_dig_outs = spec->multiout.slave_dig_outs; 4134 info = spec->pcm_rec + 1; 4135 info->name = spec->stream_name_digital; 4136 if (spec->dig_out_type) 4137 info->pcm_type = spec->dig_out_type; 4138 else 4139 info->pcm_type = HDA_PCM_TYPE_SPDIF; 4140 if (spec->multiout.dig_out_nid && 4141 spec->stream_digital_playback) { 4142 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback); 4143 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid; 4144 } 4145 if (spec->dig_in_nid && 4146 spec->stream_digital_capture) { 4147 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture); 4148 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid; 4149 } 4150 /* FIXME: do we need this for all Realtek codec models? */ 4151 codec->spdif_status_reset = 1; 4152 } 4153 4154 if (spec->no_analog) 4155 return 0; 4156 4157 /* If the use of more than one ADC is requested for the current 4158 * model, configure a second analog capture-only PCM. 4159 */ 4160 /* Additional Analaog capture for index #2 */ 4161 if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) || 4162 (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) { 4163 codec->num_pcms = 3; 4164 info = spec->pcm_rec + 2; 4165 info->name = spec->stream_name_analog; 4166 if (spec->alt_dac_nid) { 4167 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 4168 *spec->stream_analog_alt_playback; 4169 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 4170 spec->alt_dac_nid; 4171 } else { 4172 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 4173 alc_pcm_null_stream; 4174 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0; 4175 } 4176 if (spec->num_adc_nids > 1) { 4177 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 4178 *spec->stream_analog_alt_capture; 4179 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 4180 spec->adc_nids[1]; 4181 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 4182 spec->num_adc_nids - 1; 4183 } else { 4184 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 4185 alc_pcm_null_stream; 4186 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0; 4187 } 4188 } 4189 4190 return 0; 4191} 4192 4193static inline void alc_shutup(struct hda_codec *codec) 4194{ 4195 snd_hda_shutup_pins(codec); 4196} 4197 4198static void alc_free_kctls(struct hda_codec *codec) 4199{ 4200 struct alc_spec *spec = codec->spec; 4201 4202 if (spec->kctls.list) { 4203 struct snd_kcontrol_new *kctl = spec->kctls.list; 4204 int i; 4205 for (i = 0; i < spec->kctls.used; i++) 4206 kfree(kctl[i].name); 4207 } 4208 snd_array_free(&spec->kctls); 4209} 4210 4211static void alc_free(struct hda_codec *codec) 4212{ 4213 struct alc_spec *spec = codec->spec; 4214 4215 if (!spec) 4216 return; 4217 4218 alc_shutup(codec); 4219 snd_hda_input_jack_free(codec); 4220 alc_free_kctls(codec); 4221 kfree(spec); 4222 snd_hda_detach_beep_device(codec); 4223} 4224 4225#ifdef CONFIG_SND_HDA_POWER_SAVE 4226static void alc_power_eapd(struct hda_codec *codec) 4227{ 4228 /* We currently only handle front, HP */ 4229 switch (codec->vendor_id) { 4230 case 0x10ec0260: 4231 set_eapd(codec, 0x0f, 0); 4232 set_eapd(codec, 0x10, 0); 4233 break; 4234 case 0x10ec0262: 4235 case 0x10ec0267: 4236 case 0x10ec0268: 4237 case 0x10ec0269: 4238 case 0x10ec0270: 4239 case 0x10ec0272: 4240 case 0x10ec0660: 4241 case 0x10ec0662: 4242 case 0x10ec0663: 4243 case 0x10ec0862: 4244 case 0x10ec0889: 4245 set_eapd(codec, 0x14, 0); 4246 set_eapd(codec, 0x15, 0); 4247 break; 4248 } 4249} 4250 4251static int alc_suspend(struct hda_codec *codec, pm_message_t state) 4252{ 4253 struct alc_spec *spec = codec->spec; 4254 alc_shutup(codec); 4255 if (spec && spec->power_hook) 4256 spec->power_hook(codec); 4257 return 0; 4258} 4259#endif 4260 4261#ifdef SND_HDA_NEEDS_RESUME 4262static int alc_resume(struct hda_codec *codec) 4263{ 4264 codec->patch_ops.init(codec); 4265 snd_hda_codec_resume_amp(codec); 4266 snd_hda_codec_resume_cache(codec); 4267 hda_call_check_power_status(codec, 0x01); 4268 return 0; 4269} 4270#endif 4271 4272/* 4273 */ 4274static struct hda_codec_ops alc_patch_ops = { 4275 .build_controls = alc_build_controls, 4276 .build_pcms = alc_build_pcms, 4277 .init = alc_init, 4278 .free = alc_free, 4279 .unsol_event = alc_unsol_event, 4280#ifdef SND_HDA_NEEDS_RESUME 4281 .resume = alc_resume, 4282#endif 4283#ifdef CONFIG_SND_HDA_POWER_SAVE 4284 .suspend = alc_suspend, 4285 .check_power_status = alc_check_power_status, 4286#endif 4287 .reboot_notify = alc_shutup, 4288}; 4289 4290/* replace the codec chip_name with the given string */ 4291static int alc_codec_rename(struct hda_codec *codec, const char *name) 4292{ 4293 kfree(codec->chip_name); 4294 codec->chip_name = kstrdup(name, GFP_KERNEL); 4295 if (!codec->chip_name) { 4296 alc_free(codec); 4297 return -ENOMEM; 4298 } 4299 return 0; 4300} 4301 4302/* 4303 * Test configuration for debugging 4304 * 4305 * Almost all inputs/outputs are enabled. I/O pins can be configured via 4306 * enum controls. 4307 */ 4308#ifdef CONFIG_SND_DEBUG 4309static hda_nid_t alc880_test_dac_nids[4] = { 4310 0x02, 0x03, 0x04, 0x05 4311}; 4312 4313static struct hda_input_mux alc880_test_capture_source = { 4314 .num_items = 7, 4315 .items = { 4316 { "In-1", 0x0 }, 4317 { "In-2", 0x1 }, 4318 { "In-3", 0x2 }, 4319 { "In-4", 0x3 }, 4320 { "CD", 0x4 }, 4321 { "Front", 0x5 }, 4322 { "Surround", 0x6 }, 4323 }, 4324}; 4325 4326static struct hda_channel_mode alc880_test_modes[4] = { 4327 { 2, NULL }, 4328 { 4, NULL }, 4329 { 6, NULL }, 4330 { 8, NULL }, 4331}; 4332 4333static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol, 4334 struct snd_ctl_elem_info *uinfo) 4335{ 4336 static char *texts[] = { 4337 "N/A", "Line Out", "HP Out", 4338 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%" 4339 }; 4340 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 4341 uinfo->count = 1; 4342 uinfo->value.enumerated.items = 8; 4343 if (uinfo->value.enumerated.item >= 8) 4344 uinfo->value.enumerated.item = 7; 4345 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 4346 return 0; 4347} 4348 4349static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol, 4350 struct snd_ctl_elem_value *ucontrol) 4351{ 4352 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 4353 hda_nid_t nid = (hda_nid_t)kcontrol->private_value; 4354 unsigned int pin_ctl, item = 0; 4355 4356 pin_ctl = snd_hda_codec_read(codec, nid, 0, 4357 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 4358 if (pin_ctl & AC_PINCTL_OUT_EN) { 4359 if (pin_ctl & AC_PINCTL_HP_EN) 4360 item = 2; 4361 else 4362 item = 1; 4363 } else if (pin_ctl & AC_PINCTL_IN_EN) { 4364 switch (pin_ctl & AC_PINCTL_VREFEN) { 4365 case AC_PINCTL_VREF_HIZ: item = 3; break; 4366 case AC_PINCTL_VREF_50: item = 4; break; 4367 case AC_PINCTL_VREF_GRD: item = 5; break; 4368 case AC_PINCTL_VREF_80: item = 6; break; 4369 case AC_PINCTL_VREF_100: item = 7; break; 4370 } 4371 } 4372 ucontrol->value.enumerated.item[0] = item; 4373 return 0; 4374} 4375 4376static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol, 4377 struct snd_ctl_elem_value *ucontrol) 4378{ 4379 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 4380 hda_nid_t nid = (hda_nid_t)kcontrol->private_value; 4381 static unsigned int ctls[] = { 4382 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN, 4383 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ, 4384 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50, 4385 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD, 4386 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80, 4387 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100, 4388 }; 4389 unsigned int old_ctl, new_ctl; 4390 4391 old_ctl = snd_hda_codec_read(codec, nid, 0, 4392 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 4393 new_ctl = ctls[ucontrol->value.enumerated.item[0]]; 4394 if (old_ctl != new_ctl) { 4395 int val; 4396 snd_hda_codec_write_cache(codec, nid, 0, 4397 AC_VERB_SET_PIN_WIDGET_CONTROL, 4398 new_ctl); 4399 val = ucontrol->value.enumerated.item[0] >= 3 ? 4400 HDA_AMP_MUTE : 0; 4401 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 4402 HDA_AMP_MUTE, val); 4403 return 1; 4404 } 4405 return 0; 4406} 4407 4408static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol, 4409 struct snd_ctl_elem_info *uinfo) 4410{ 4411 static char *texts[] = { 4412 "Front", "Surround", "CLFE", "Side" 4413 }; 4414 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 4415 uinfo->count = 1; 4416 uinfo->value.enumerated.items = 4; 4417 if (uinfo->value.enumerated.item >= 4) 4418 uinfo->value.enumerated.item = 3; 4419 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 4420 return 0; 4421} 4422 4423static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol, 4424 struct snd_ctl_elem_value *ucontrol) 4425{ 4426 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 4427 hda_nid_t nid = (hda_nid_t)kcontrol->private_value; 4428 unsigned int sel; 4429 4430 sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0); 4431 ucontrol->value.enumerated.item[0] = sel & 3; 4432 return 0; 4433} 4434 4435static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol, 4436 struct snd_ctl_elem_value *ucontrol) 4437{ 4438 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 4439 hda_nid_t nid = (hda_nid_t)kcontrol->private_value; 4440 unsigned int sel; 4441 4442 sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3; 4443 if (ucontrol->value.enumerated.item[0] != sel) { 4444 sel = ucontrol->value.enumerated.item[0] & 3; 4445 snd_hda_codec_write_cache(codec, nid, 0, 4446 AC_VERB_SET_CONNECT_SEL, sel); 4447 return 1; 4448 } 4449 return 0; 4450} 4451 4452#define PIN_CTL_TEST(xname,nid) { \ 4453 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 4454 .name = xname, \ 4455 .subdevice = HDA_SUBDEV_NID_FLAG | nid, \ 4456 .info = alc_test_pin_ctl_info, \ 4457 .get = alc_test_pin_ctl_get, \ 4458 .put = alc_test_pin_ctl_put, \ 4459 .private_value = nid \ 4460 } 4461 4462#define PIN_SRC_TEST(xname,nid) { \ 4463 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 4464 .name = xname, \ 4465 .subdevice = HDA_SUBDEV_NID_FLAG | nid, \ 4466 .info = alc_test_pin_src_info, \ 4467 .get = alc_test_pin_src_get, \ 4468 .put = alc_test_pin_src_put, \ 4469 .private_value = nid \ 4470 } 4471 4472static struct snd_kcontrol_new alc880_test_mixer[] = { 4473 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 4474 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 4475 HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT), 4476 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 4477 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 4478 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 4479 HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT), 4480 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 4481 PIN_CTL_TEST("Front Pin Mode", 0x14), 4482 PIN_CTL_TEST("Surround Pin Mode", 0x15), 4483 PIN_CTL_TEST("CLFE Pin Mode", 0x16), 4484 PIN_CTL_TEST("Side Pin Mode", 0x17), 4485 PIN_CTL_TEST("In-1 Pin Mode", 0x18), 4486 PIN_CTL_TEST("In-2 Pin Mode", 0x19), 4487 PIN_CTL_TEST("In-3 Pin Mode", 0x1a), 4488 PIN_CTL_TEST("In-4 Pin Mode", 0x1b), 4489 PIN_SRC_TEST("In-1 Pin Source", 0x18), 4490 PIN_SRC_TEST("In-2 Pin Source", 0x19), 4491 PIN_SRC_TEST("In-3 Pin Source", 0x1a), 4492 PIN_SRC_TEST("In-4 Pin Source", 0x1b), 4493 HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT), 4494 HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT), 4495 HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT), 4496 HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT), 4497 HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT), 4498 HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT), 4499 HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT), 4500 HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT), 4501 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT), 4502 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT), 4503 { 4504 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4505 .name = "Channel Mode", 4506 .info = alc_ch_mode_info, 4507 .get = alc_ch_mode_get, 4508 .put = alc_ch_mode_put, 4509 }, 4510 { } /* end */ 4511}; 4512 4513static struct hda_verb alc880_test_init_verbs[] = { 4514 /* Unmute inputs of 0x0c - 0x0f */ 4515 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4516 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 4517 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4518 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 4519 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4520 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 4521 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4522 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 4523 /* Vol output for 0x0c-0x0f */ 4524 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4525 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4526 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4527 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4528 /* Set output pins 0x14-0x17 */ 4529 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4530 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4531 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4532 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4533 /* Unmute output pins 0x14-0x17 */ 4534 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4535 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4536 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4537 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4538 /* Set input pins 0x18-0x1c */ 4539 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 4540 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 4541 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 4542 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 4543 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 4544 /* Mute input pins 0x18-0x1b */ 4545 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 4546 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 4547 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 4548 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 4549 /* ADC set up */ 4550 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4551 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 4552 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4553 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 4554 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4555 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 4556 /* Analog input/passthru */ 4557 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4558 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4559 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 4560 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 4561 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 4562 { } 4563}; 4564#endif 4565 4566/* 4567 */ 4568 4569static const char * const alc880_models[ALC880_MODEL_LAST] = { 4570 [ALC880_3ST] = "3stack", 4571 [ALC880_TCL_S700] = "tcl", 4572 [ALC880_3ST_DIG] = "3stack-digout", 4573 [ALC880_CLEVO] = "clevo", 4574 [ALC880_5ST] = "5stack", 4575 [ALC880_5ST_DIG] = "5stack-digout", 4576 [ALC880_W810] = "w810", 4577 [ALC880_Z71V] = "z71v", 4578 [ALC880_6ST] = "6stack", 4579 [ALC880_6ST_DIG] = "6stack-digout", 4580 [ALC880_ASUS] = "asus", 4581 [ALC880_ASUS_W1V] = "asus-w1v", 4582 [ALC880_ASUS_DIG] = "asus-dig", 4583 [ALC880_ASUS_DIG2] = "asus-dig2", 4584 [ALC880_UNIWILL_DIG] = "uniwill", 4585 [ALC880_UNIWILL_P53] = "uniwill-p53", 4586 [ALC880_FUJITSU] = "fujitsu", 4587 [ALC880_F1734] = "F1734", 4588 [ALC880_LG] = "lg", 4589 [ALC880_LG_LW] = "lg-lw", 4590 [ALC880_MEDION_RIM] = "medion", 4591#ifdef CONFIG_SND_DEBUG 4592 [ALC880_TEST] = "test", 4593#endif 4594 [ALC880_AUTO] = "auto", 4595}; 4596 4597static struct snd_pci_quirk alc880_cfg_tbl[] = { 4598 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810), 4599 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG), 4600 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST), 4601 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG), 4602 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG), 4603 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG), 4604 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG), 4605 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG), 4606 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST), 4607 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG), 4608 SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST), 4609 SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V), 4610 SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG), 4611 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG), 4612 SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG), 4613 SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG), 4614 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG), 4615 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V), 4616 /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */ 4617 SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG), 4618 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG), 4619 SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG), 4620 SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG), 4621 SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST), 4622 SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST), 4623 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */ 4624 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST), 4625 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST), 4626 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST), 4627 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST), 4628 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST), 4629 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG), 4630 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG), 4631 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG), 4632 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG), 4633 SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO), 4634 SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO), 4635 SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2), 4636 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG), 4637 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG), 4638 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734), 4639 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL), 4640 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53), 4641 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810), 4642 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM), 4643 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG), 4644 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG), 4645 SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734), 4646 SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU), 4647 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_F1734), 4648 SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU), 4649 SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW), 4650 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG), 4651 SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_LG), 4652 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG), 4653 SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW), 4654 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700), 4655 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */ 4656 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG), 4657 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG), 4658 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG), 4659 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG), 4660 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG), 4661 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG), 4662 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG), 4663 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG), 4664 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG), 4665 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG), 4666 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG), 4667 /* default Intel */ 4668 SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST), 4669 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG), 4670 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG), 4671 {} 4672}; 4673 4674/* 4675 * ALC880 codec presets 4676 */ 4677static struct alc_config_preset alc880_presets[] = { 4678 [ALC880_3ST] = { 4679 .mixers = { alc880_three_stack_mixer }, 4680 .init_verbs = { alc880_volume_init_verbs, 4681 alc880_pin_3stack_init_verbs }, 4682 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 4683 .dac_nids = alc880_dac_nids, 4684 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 4685 .channel_mode = alc880_threestack_modes, 4686 .need_dac_fix = 1, 4687 .input_mux = &alc880_capture_source, 4688 }, 4689 [ALC880_3ST_DIG] = { 4690 .mixers = { alc880_three_stack_mixer }, 4691 .init_verbs = { alc880_volume_init_verbs, 4692 alc880_pin_3stack_init_verbs }, 4693 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 4694 .dac_nids = alc880_dac_nids, 4695 .dig_out_nid = ALC880_DIGOUT_NID, 4696 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 4697 .channel_mode = alc880_threestack_modes, 4698 .need_dac_fix = 1, 4699 .input_mux = &alc880_capture_source, 4700 }, 4701 [ALC880_TCL_S700] = { 4702 .mixers = { alc880_tcl_s700_mixer }, 4703 .init_verbs = { alc880_volume_init_verbs, 4704 alc880_pin_tcl_S700_init_verbs, 4705 alc880_gpio2_init_verbs }, 4706 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 4707 .dac_nids = alc880_dac_nids, 4708 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */ 4709 .num_adc_nids = 1, /* single ADC */ 4710 .hp_nid = 0x03, 4711 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 4712 .channel_mode = alc880_2_jack_modes, 4713 .input_mux = &alc880_capture_source, 4714 }, 4715 [ALC880_5ST] = { 4716 .mixers = { alc880_three_stack_mixer, 4717 alc880_five_stack_mixer}, 4718 .init_verbs = { alc880_volume_init_verbs, 4719 alc880_pin_5stack_init_verbs }, 4720 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 4721 .dac_nids = alc880_dac_nids, 4722 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes), 4723 .channel_mode = alc880_fivestack_modes, 4724 .input_mux = &alc880_capture_source, 4725 }, 4726 [ALC880_5ST_DIG] = { 4727 .mixers = { alc880_three_stack_mixer, 4728 alc880_five_stack_mixer }, 4729 .init_verbs = { alc880_volume_init_verbs, 4730 alc880_pin_5stack_init_verbs }, 4731 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 4732 .dac_nids = alc880_dac_nids, 4733 .dig_out_nid = ALC880_DIGOUT_NID, 4734 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes), 4735 .channel_mode = alc880_fivestack_modes, 4736 .input_mux = &alc880_capture_source, 4737 }, 4738 [ALC880_6ST] = { 4739 .mixers = { alc880_six_stack_mixer }, 4740 .init_verbs = { alc880_volume_init_verbs, 4741 alc880_pin_6stack_init_verbs }, 4742 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids), 4743 .dac_nids = alc880_6st_dac_nids, 4744 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes), 4745 .channel_mode = alc880_sixstack_modes, 4746 .input_mux = &alc880_6stack_capture_source, 4747 }, 4748 [ALC880_6ST_DIG] = { 4749 .mixers = { alc880_six_stack_mixer }, 4750 .init_verbs = { alc880_volume_init_verbs, 4751 alc880_pin_6stack_init_verbs }, 4752 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids), 4753 .dac_nids = alc880_6st_dac_nids, 4754 .dig_out_nid = ALC880_DIGOUT_NID, 4755 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes), 4756 .channel_mode = alc880_sixstack_modes, 4757 .input_mux = &alc880_6stack_capture_source, 4758 }, 4759 [ALC880_W810] = { 4760 .mixers = { alc880_w810_base_mixer }, 4761 .init_verbs = { alc880_volume_init_verbs, 4762 alc880_pin_w810_init_verbs, 4763 alc880_gpio2_init_verbs }, 4764 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids), 4765 .dac_nids = alc880_w810_dac_nids, 4766 .dig_out_nid = ALC880_DIGOUT_NID, 4767 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes), 4768 .channel_mode = alc880_w810_modes, 4769 .input_mux = &alc880_capture_source, 4770 }, 4771 [ALC880_Z71V] = { 4772 .mixers = { alc880_z71v_mixer }, 4773 .init_verbs = { alc880_volume_init_verbs, 4774 alc880_pin_z71v_init_verbs }, 4775 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids), 4776 .dac_nids = alc880_z71v_dac_nids, 4777 .dig_out_nid = ALC880_DIGOUT_NID, 4778 .hp_nid = 0x03, 4779 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 4780 .channel_mode = alc880_2_jack_modes, 4781 .input_mux = &alc880_capture_source, 4782 }, 4783 [ALC880_F1734] = { 4784 .mixers = { alc880_f1734_mixer }, 4785 .init_verbs = { alc880_volume_init_verbs, 4786 alc880_pin_f1734_init_verbs }, 4787 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids), 4788 .dac_nids = alc880_f1734_dac_nids, 4789 .hp_nid = 0x02, 4790 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 4791 .channel_mode = alc880_2_jack_modes, 4792 .input_mux = &alc880_f1734_capture_source, 4793 .unsol_event = alc880_uniwill_p53_unsol_event, 4794 .setup = alc880_uniwill_p53_setup, 4795 .init_hook = alc_automute_amp, 4796 }, 4797 [ALC880_ASUS] = { 4798 .mixers = { alc880_asus_mixer }, 4799 .init_verbs = { alc880_volume_init_verbs, 4800 alc880_pin_asus_init_verbs, 4801 alc880_gpio1_init_verbs }, 4802 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 4803 .dac_nids = alc880_asus_dac_nids, 4804 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 4805 .channel_mode = alc880_asus_modes, 4806 .need_dac_fix = 1, 4807 .input_mux = &alc880_capture_source, 4808 }, 4809 [ALC880_ASUS_DIG] = { 4810 .mixers = { alc880_asus_mixer }, 4811 .init_verbs = { alc880_volume_init_verbs, 4812 alc880_pin_asus_init_verbs, 4813 alc880_gpio1_init_verbs }, 4814 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 4815 .dac_nids = alc880_asus_dac_nids, 4816 .dig_out_nid = ALC880_DIGOUT_NID, 4817 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 4818 .channel_mode = alc880_asus_modes, 4819 .need_dac_fix = 1, 4820 .input_mux = &alc880_capture_source, 4821 }, 4822 [ALC880_ASUS_DIG2] = { 4823 .mixers = { alc880_asus_mixer }, 4824 .init_verbs = { alc880_volume_init_verbs, 4825 alc880_pin_asus_init_verbs, 4826 alc880_gpio2_init_verbs }, /* use GPIO2 */ 4827 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 4828 .dac_nids = alc880_asus_dac_nids, 4829 .dig_out_nid = ALC880_DIGOUT_NID, 4830 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 4831 .channel_mode = alc880_asus_modes, 4832 .need_dac_fix = 1, 4833 .input_mux = &alc880_capture_source, 4834 }, 4835 [ALC880_ASUS_W1V] = { 4836 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer }, 4837 .init_verbs = { alc880_volume_init_verbs, 4838 alc880_pin_asus_init_verbs, 4839 alc880_gpio1_init_verbs }, 4840 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 4841 .dac_nids = alc880_asus_dac_nids, 4842 .dig_out_nid = ALC880_DIGOUT_NID, 4843 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 4844 .channel_mode = alc880_asus_modes, 4845 .need_dac_fix = 1, 4846 .input_mux = &alc880_capture_source, 4847 }, 4848 [ALC880_UNIWILL_DIG] = { 4849 .mixers = { alc880_asus_mixer }, 4850 .init_verbs = { alc880_volume_init_verbs, 4851 alc880_pin_asus_init_verbs }, 4852 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 4853 .dac_nids = alc880_asus_dac_nids, 4854 .dig_out_nid = ALC880_DIGOUT_NID, 4855 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 4856 .channel_mode = alc880_asus_modes, 4857 .need_dac_fix = 1, 4858 .input_mux = &alc880_capture_source, 4859 }, 4860 [ALC880_UNIWILL] = { 4861 .mixers = { alc880_uniwill_mixer }, 4862 .init_verbs = { alc880_volume_init_verbs, 4863 alc880_uniwill_init_verbs }, 4864 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 4865 .dac_nids = alc880_asus_dac_nids, 4866 .dig_out_nid = ALC880_DIGOUT_NID, 4867 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 4868 .channel_mode = alc880_threestack_modes, 4869 .need_dac_fix = 1, 4870 .input_mux = &alc880_capture_source, 4871 .unsol_event = alc880_uniwill_unsol_event, 4872 .setup = alc880_uniwill_setup, 4873 .init_hook = alc880_uniwill_init_hook, 4874 }, 4875 [ALC880_UNIWILL_P53] = { 4876 .mixers = { alc880_uniwill_p53_mixer }, 4877 .init_verbs = { alc880_volume_init_verbs, 4878 alc880_uniwill_p53_init_verbs }, 4879 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 4880 .dac_nids = alc880_asus_dac_nids, 4881 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes), 4882 .channel_mode = alc880_threestack_modes, 4883 .input_mux = &alc880_capture_source, 4884 .unsol_event = alc880_uniwill_p53_unsol_event, 4885 .setup = alc880_uniwill_p53_setup, 4886 .init_hook = alc_automute_amp, 4887 }, 4888 [ALC880_FUJITSU] = { 4889 .mixers = { alc880_fujitsu_mixer }, 4890 .init_verbs = { alc880_volume_init_verbs, 4891 alc880_uniwill_p53_init_verbs, 4892 alc880_beep_init_verbs }, 4893 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 4894 .dac_nids = alc880_dac_nids, 4895 .dig_out_nid = ALC880_DIGOUT_NID, 4896 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 4897 .channel_mode = alc880_2_jack_modes, 4898 .input_mux = &alc880_capture_source, 4899 .unsol_event = alc880_uniwill_p53_unsol_event, 4900 .setup = alc880_uniwill_p53_setup, 4901 .init_hook = alc_automute_amp, 4902 }, 4903 [ALC880_CLEVO] = { 4904 .mixers = { alc880_three_stack_mixer }, 4905 .init_verbs = { alc880_volume_init_verbs, 4906 alc880_pin_clevo_init_verbs }, 4907 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 4908 .dac_nids = alc880_dac_nids, 4909 .hp_nid = 0x03, 4910 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 4911 .channel_mode = alc880_threestack_modes, 4912 .need_dac_fix = 1, 4913 .input_mux = &alc880_capture_source, 4914 }, 4915 [ALC880_LG] = { 4916 .mixers = { alc880_lg_mixer }, 4917 .init_verbs = { alc880_volume_init_verbs, 4918 alc880_lg_init_verbs }, 4919 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids), 4920 .dac_nids = alc880_lg_dac_nids, 4921 .dig_out_nid = ALC880_DIGOUT_NID, 4922 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes), 4923 .channel_mode = alc880_lg_ch_modes, 4924 .need_dac_fix = 1, 4925 .input_mux = &alc880_lg_capture_source, 4926 .unsol_event = alc_automute_amp_unsol_event, 4927 .setup = alc880_lg_setup, 4928 .init_hook = alc_automute_amp, 4929#ifdef CONFIG_SND_HDA_POWER_SAVE 4930 .loopbacks = alc880_lg_loopbacks, 4931#endif 4932 }, 4933 [ALC880_LG_LW] = { 4934 .mixers = { alc880_lg_lw_mixer }, 4935 .init_verbs = { alc880_volume_init_verbs, 4936 alc880_lg_lw_init_verbs }, 4937 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 4938 .dac_nids = alc880_dac_nids, 4939 .dig_out_nid = ALC880_DIGOUT_NID, 4940 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes), 4941 .channel_mode = alc880_lg_lw_modes, 4942 .input_mux = &alc880_lg_lw_capture_source, 4943 .unsol_event = alc_automute_amp_unsol_event, 4944 .setup = alc880_lg_lw_setup, 4945 .init_hook = alc_automute_amp, 4946 }, 4947 [ALC880_MEDION_RIM] = { 4948 .mixers = { alc880_medion_rim_mixer }, 4949 .init_verbs = { alc880_volume_init_verbs, 4950 alc880_medion_rim_init_verbs, 4951 alc_gpio2_init_verbs }, 4952 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 4953 .dac_nids = alc880_dac_nids, 4954 .dig_out_nid = ALC880_DIGOUT_NID, 4955 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 4956 .channel_mode = alc880_2_jack_modes, 4957 .input_mux = &alc880_medion_rim_capture_source, 4958 .unsol_event = alc880_medion_rim_unsol_event, 4959 .setup = alc880_medion_rim_setup, 4960 .init_hook = alc880_medion_rim_automute, 4961 }, 4962#ifdef CONFIG_SND_DEBUG 4963 [ALC880_TEST] = { 4964 .mixers = { alc880_test_mixer }, 4965 .init_verbs = { alc880_test_init_verbs }, 4966 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids), 4967 .dac_nids = alc880_test_dac_nids, 4968 .dig_out_nid = ALC880_DIGOUT_NID, 4969 .num_channel_mode = ARRAY_SIZE(alc880_test_modes), 4970 .channel_mode = alc880_test_modes, 4971 .input_mux = &alc880_test_capture_source, 4972 }, 4973#endif 4974}; 4975 4976/* 4977 * Automatic parse of I/O pins from the BIOS configuration 4978 */ 4979 4980enum { 4981 ALC_CTL_WIDGET_VOL, 4982 ALC_CTL_WIDGET_MUTE, 4983 ALC_CTL_BIND_MUTE, 4984}; 4985static struct snd_kcontrol_new alc880_control_templates[] = { 4986 HDA_CODEC_VOLUME(NULL, 0, 0, 0), 4987 HDA_CODEC_MUTE(NULL, 0, 0, 0), 4988 HDA_BIND_MUTE(NULL, 0, 0, 0), 4989}; 4990 4991/* add dynamic controls */ 4992static int add_control(struct alc_spec *spec, int type, const char *name, 4993 int cidx, unsigned long val) 4994{ 4995 struct snd_kcontrol_new *knew; 4996 4997 snd_array_init(&spec->kctls, sizeof(*knew), 32); 4998 knew = snd_array_new(&spec->kctls); 4999 if (!knew) 5000 return -ENOMEM; 5001 *knew = alc880_control_templates[type]; 5002 knew->name = kstrdup(name, GFP_KERNEL); 5003 if (!knew->name) 5004 return -ENOMEM; 5005 knew->index = cidx; 5006 if (get_amp_nid_(val)) 5007 knew->subdevice = HDA_SUBDEV_AMP_FLAG; 5008 knew->private_value = val; 5009 return 0; 5010} 5011 5012static int add_control_with_pfx(struct alc_spec *spec, int type, 5013 const char *pfx, const char *dir, 5014 const char *sfx, int cidx, unsigned long val) 5015{ 5016 char name[32]; 5017 snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx); 5018 return add_control(spec, type, name, cidx, val); 5019} 5020 5021#define add_pb_vol_ctrl(spec, type, pfx, val) \ 5022 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val) 5023#define add_pb_sw_ctrl(spec, type, pfx, val) \ 5024 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val) 5025#define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \ 5026 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val) 5027#define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \ 5028 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val) 5029 5030#define alc880_is_fixed_pin(nid) ((nid) >= 0x14 && (nid) <= 0x17) 5031#define alc880_fixed_pin_idx(nid) ((nid) - 0x14) 5032#define alc880_is_multi_pin(nid) ((nid) >= 0x18) 5033#define alc880_multi_pin_idx(nid) ((nid) - 0x18) 5034#define alc880_idx_to_dac(nid) ((nid) + 0x02) 5035#define alc880_dac_to_idx(nid) ((nid) - 0x02) 5036#define alc880_idx_to_mixer(nid) ((nid) + 0x0c) 5037#define alc880_idx_to_selector(nid) ((nid) + 0x10) 5038#define ALC880_PIN_CD_NID 0x1c 5039 5040/* fill in the dac_nids table from the parsed pin configuration */ 5041static int alc880_auto_fill_dac_nids(struct alc_spec *spec, 5042 const struct auto_pin_cfg *cfg) 5043{ 5044 hda_nid_t nid; 5045 int assigned[4]; 5046 int i, j; 5047 5048 memset(assigned, 0, sizeof(assigned)); 5049 spec->multiout.dac_nids = spec->private_dac_nids; 5050 5051 /* check the pins hardwired to audio widget */ 5052 for (i = 0; i < cfg->line_outs; i++) { 5053 nid = cfg->line_out_pins[i]; 5054 if (alc880_is_fixed_pin(nid)) { 5055 int idx = alc880_fixed_pin_idx(nid); 5056 spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx); 5057 assigned[idx] = 1; 5058 } 5059 } 5060 /* left pins can be connect to any audio widget */ 5061 for (i = 0; i < cfg->line_outs; i++) { 5062 nid = cfg->line_out_pins[i]; 5063 if (alc880_is_fixed_pin(nid)) 5064 continue; 5065 /* search for an empty channel */ 5066 for (j = 0; j < cfg->line_outs; j++) { 5067 if (!assigned[j]) { 5068 spec->multiout.dac_nids[i] = 5069 alc880_idx_to_dac(j); 5070 assigned[j] = 1; 5071 break; 5072 } 5073 } 5074 } 5075 spec->multiout.num_dacs = cfg->line_outs; 5076 return 0; 5077} 5078 5079static const char *alc_get_line_out_pfx(const struct auto_pin_cfg *cfg, 5080 bool can_be_master) 5081{ 5082 if (!cfg->hp_outs && !cfg->speaker_outs && can_be_master) 5083 return "Master"; 5084 5085 switch (cfg->line_out_type) { 5086 case AUTO_PIN_SPEAKER_OUT: 5087 if (cfg->line_outs == 1) 5088 return "Speaker"; 5089 break; 5090 case AUTO_PIN_HP_OUT: 5091 return "Headphone"; 5092 default: 5093 if (cfg->line_outs == 1) 5094 return "PCM"; 5095 break; 5096 } 5097 return NULL; 5098} 5099 5100/* add playback controls from the parsed DAC table */ 5101static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec, 5102 const struct auto_pin_cfg *cfg) 5103{ 5104 static const char * const chname[4] = { 5105 "Front", "Surround", NULL /*CLFE*/, "Side" 5106 }; 5107 const char *pfx = alc_get_line_out_pfx(cfg, false); 5108 hda_nid_t nid; 5109 int i, err; 5110 5111 for (i = 0; i < cfg->line_outs; i++) { 5112 if (!spec->multiout.dac_nids[i]) 5113 continue; 5114 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i])); 5115 if (!pfx && i == 2) { 5116 /* Center/LFE */ 5117 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, 5118 "Center", 5119 HDA_COMPOSE_AMP_VAL(nid, 1, 0, 5120 HDA_OUTPUT)); 5121 if (err < 0) 5122 return err; 5123 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, 5124 "LFE", 5125 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 5126 HDA_OUTPUT)); 5127 if (err < 0) 5128 return err; 5129 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, 5130 "Center", 5131 HDA_COMPOSE_AMP_VAL(nid, 1, 2, 5132 HDA_INPUT)); 5133 if (err < 0) 5134 return err; 5135 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, 5136 "LFE", 5137 HDA_COMPOSE_AMP_VAL(nid, 2, 2, 5138 HDA_INPUT)); 5139 if (err < 0) 5140 return err; 5141 } else { 5142 const char *name = pfx; 5143 int index = i; 5144 if (!name) { 5145 name = chname[i]; 5146 index = 0; 5147 } 5148 err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, 5149 name, index, 5150 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 5151 HDA_OUTPUT)); 5152 if (err < 0) 5153 return err; 5154 err = __add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, 5155 name, index, 5156 HDA_COMPOSE_AMP_VAL(nid, 3, 2, 5157 HDA_INPUT)); 5158 if (err < 0) 5159 return err; 5160 } 5161 } 5162 return 0; 5163} 5164 5165/* add playback controls for speaker and HP outputs */ 5166static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin, 5167 const char *pfx) 5168{ 5169 hda_nid_t nid; 5170 int err; 5171 5172 if (!pin) 5173 return 0; 5174 5175 if (alc880_is_fixed_pin(pin)) { 5176 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin)); 5177 /* specify the DAC as the extra output */ 5178 if (!spec->multiout.hp_nid) 5179 spec->multiout.hp_nid = nid; 5180 else 5181 spec->multiout.extra_out_nid[0] = nid; 5182 /* control HP volume/switch on the output mixer amp */ 5183 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin)); 5184 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, 5185 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 5186 if (err < 0) 5187 return err; 5188 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx, 5189 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT)); 5190 if (err < 0) 5191 return err; 5192 } else if (alc880_is_multi_pin(pin)) { 5193 /* set manual connection */ 5194 /* we have only a switch on HP-out PIN */ 5195 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, 5196 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 5197 if (err < 0) 5198 return err; 5199 } 5200 return 0; 5201} 5202 5203/* create input playback/capture controls for the given pin */ 5204static int new_analog_input(struct alc_spec *spec, hda_nid_t pin, 5205 const char *ctlname, int ctlidx, 5206 int idx, hda_nid_t mix_nid) 5207{ 5208 int err; 5209 5210 err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx, 5211 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); 5212 if (err < 0) 5213 return err; 5214 err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx, 5215 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); 5216 if (err < 0) 5217 return err; 5218 return 0; 5219} 5220 5221static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid) 5222{ 5223 unsigned int pincap = snd_hda_query_pin_caps(codec, nid); 5224 return (pincap & AC_PINCAP_IN) != 0; 5225} 5226 5227/* create playback/capture controls for input pins */ 5228static int alc_auto_create_input_ctls(struct hda_codec *codec, 5229 const struct auto_pin_cfg *cfg, 5230 hda_nid_t mixer, 5231 hda_nid_t cap1, hda_nid_t cap2) 5232{ 5233 struct alc_spec *spec = codec->spec; 5234 struct hda_input_mux *imux = &spec->private_imux[0]; 5235 int i, err, idx, type_idx = 0; 5236 const char *prev_label = NULL; 5237 5238 for (i = 0; i < cfg->num_inputs; i++) { 5239 hda_nid_t pin; 5240 const char *label; 5241 5242 pin = cfg->inputs[i].pin; 5243 if (!alc_is_input_pin(codec, pin)) 5244 continue; 5245 5246 label = hda_get_autocfg_input_label(codec, cfg, i); 5247 if (prev_label && !strcmp(label, prev_label)) 5248 type_idx++; 5249 else 5250 type_idx = 0; 5251 prev_label = label; 5252 5253 if (mixer) { 5254 idx = get_connection_index(codec, mixer, pin); 5255 if (idx >= 0) { 5256 err = new_analog_input(spec, pin, 5257 label, type_idx, 5258 idx, mixer); 5259 if (err < 0) 5260 return err; 5261 } 5262 } 5263 5264 if (!cap1) 5265 continue; 5266 idx = get_connection_index(codec, cap1, pin); 5267 if (idx < 0 && cap2) 5268 idx = get_connection_index(codec, cap2, pin); 5269 if (idx >= 0) 5270 snd_hda_add_imux_item(imux, label, idx, NULL); 5271 } 5272 return 0; 5273} 5274 5275static int alc880_auto_create_input_ctls(struct hda_codec *codec, 5276 const struct auto_pin_cfg *cfg) 5277{ 5278 return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09); 5279} 5280 5281static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid, 5282 unsigned int pin_type) 5283{ 5284 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 5285 pin_type); 5286 /* unmute pin */ 5287 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, 5288 AMP_OUT_UNMUTE); 5289} 5290 5291static void alc880_auto_set_output_and_unmute(struct hda_codec *codec, 5292 hda_nid_t nid, int pin_type, 5293 int dac_idx) 5294{ 5295 alc_set_pin_output(codec, nid, pin_type); 5296 /* need the manual connection? */ 5297 if (alc880_is_multi_pin(nid)) { 5298 struct alc_spec *spec = codec->spec; 5299 int idx = alc880_multi_pin_idx(nid); 5300 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0, 5301 AC_VERB_SET_CONNECT_SEL, 5302 alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx])); 5303 } 5304} 5305 5306static int get_pin_type(int line_out_type) 5307{ 5308 if (line_out_type == AUTO_PIN_HP_OUT) 5309 return PIN_HP; 5310 else 5311 return PIN_OUT; 5312} 5313 5314static void alc880_auto_init_multi_out(struct hda_codec *codec) 5315{ 5316 struct alc_spec *spec = codec->spec; 5317 int i; 5318 5319 for (i = 0; i < spec->autocfg.line_outs; i++) { 5320 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 5321 int pin_type = get_pin_type(spec->autocfg.line_out_type); 5322 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i); 5323 } 5324} 5325 5326static void alc880_auto_init_extra_out(struct hda_codec *codec) 5327{ 5328 struct alc_spec *spec = codec->spec; 5329 hda_nid_t pin; 5330 5331 pin = spec->autocfg.speaker_pins[0]; 5332 if (pin) /* connect to front */ 5333 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 5334 pin = spec->autocfg.hp_pins[0]; 5335 if (pin) /* connect to front */ 5336 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 5337} 5338 5339static void alc880_auto_init_analog_input(struct hda_codec *codec) 5340{ 5341 struct alc_spec *spec = codec->spec; 5342 struct auto_pin_cfg *cfg = &spec->autocfg; 5343 int i; 5344 5345 for (i = 0; i < cfg->num_inputs; i++) { 5346 hda_nid_t nid = cfg->inputs[i].pin; 5347 if (alc_is_input_pin(codec, nid)) { 5348 alc_set_input_pin(codec, nid, cfg->inputs[i].type); 5349 if (nid != ALC880_PIN_CD_NID && 5350 (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)) 5351 snd_hda_codec_write(codec, nid, 0, 5352 AC_VERB_SET_AMP_GAIN_MUTE, 5353 AMP_OUT_MUTE); 5354 } 5355 } 5356} 5357 5358static void alc880_auto_init_input_src(struct hda_codec *codec) 5359{ 5360 struct alc_spec *spec = codec->spec; 5361 int c; 5362 5363 for (c = 0; c < spec->num_adc_nids; c++) { 5364 unsigned int mux_idx; 5365 const struct hda_input_mux *imux; 5366 mux_idx = c >= spec->num_mux_defs ? 0 : c; 5367 imux = &spec->input_mux[mux_idx]; 5368 if (!imux->num_items && mux_idx > 0) 5369 imux = &spec->input_mux[0]; 5370 if (imux) 5371 snd_hda_codec_write(codec, spec->adc_nids[c], 0, 5372 AC_VERB_SET_CONNECT_SEL, 5373 imux->items[0].index); 5374 } 5375} 5376 5377/* parse the BIOS configuration and set up the alc_spec */ 5378/* return 1 if successful, 0 if the proper config is not found, 5379 * or a negative error code 5380 */ 5381static int alc880_parse_auto_config(struct hda_codec *codec) 5382{ 5383 struct alc_spec *spec = codec->spec; 5384 int err; 5385 static hda_nid_t alc880_ignore[] = { 0x1d, 0 }; 5386 5387 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 5388 alc880_ignore); 5389 if (err < 0) 5390 return err; 5391 if (!spec->autocfg.line_outs) 5392 return 0; /* can't find valid BIOS pin config */ 5393 5394 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg); 5395 if (err < 0) 5396 return err; 5397 err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg); 5398 if (err < 0) 5399 return err; 5400 err = alc880_auto_create_extra_out(spec, 5401 spec->autocfg.speaker_pins[0], 5402 "Speaker"); 5403 if (err < 0) 5404 return err; 5405 err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0], 5406 "Headphone"); 5407 if (err < 0) 5408 return err; 5409 err = alc880_auto_create_input_ctls(codec, &spec->autocfg); 5410 if (err < 0) 5411 return err; 5412 5413 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 5414 5415 alc_auto_parse_digital(codec); 5416 5417 if (spec->kctls.list) 5418 add_mixer(spec, spec->kctls.list); 5419 5420 add_verb(spec, alc880_volume_init_verbs); 5421 5422 spec->num_mux_defs = 1; 5423 spec->input_mux = &spec->private_imux[0]; 5424 5425 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0); 5426 5427 return 1; 5428} 5429 5430/* additional initialization for auto-configuration model */ 5431static void alc880_auto_init(struct hda_codec *codec) 5432{ 5433 struct alc_spec *spec = codec->spec; 5434 alc880_auto_init_multi_out(codec); 5435 alc880_auto_init_extra_out(codec); 5436 alc880_auto_init_analog_input(codec); 5437 alc880_auto_init_input_src(codec); 5438 alc_auto_init_digital(codec); 5439 if (spec->unsol_event) 5440 alc_inithook(codec); 5441} 5442 5443/* check the ADC/MUX contains all input pins; some ADC/MUX contains only 5444 * one of two digital mic pins, e.g. on ALC272 5445 */ 5446static void fixup_automic_adc(struct hda_codec *codec) 5447{ 5448 struct alc_spec *spec = codec->spec; 5449 int i; 5450 5451 for (i = 0; i < spec->num_adc_nids; i++) { 5452 hda_nid_t cap = spec->capsrc_nids ? 5453 spec->capsrc_nids[i] : spec->adc_nids[i]; 5454 int iidx, eidx; 5455 5456 iidx = get_connection_index(codec, cap, spec->int_mic.pin); 5457 if (iidx < 0) 5458 continue; 5459 eidx = get_connection_index(codec, cap, spec->ext_mic.pin); 5460 if (eidx < 0) 5461 continue; 5462 spec->int_mic.mux_idx = iidx; 5463 spec->ext_mic.mux_idx = eidx; 5464 if (spec->capsrc_nids) 5465 spec->capsrc_nids += i; 5466 spec->adc_nids += i; 5467 spec->num_adc_nids = 1; 5468 return; 5469 } 5470 snd_printd(KERN_INFO "hda_codec: %s: " 5471 "No ADC/MUX containing both 0x%x and 0x%x pins\n", 5472 codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin); 5473 spec->auto_mic = 0; /* disable auto-mic to be sure */ 5474} 5475 5476/* select or unmute the given capsrc route */ 5477static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap, 5478 int idx) 5479{ 5480 if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) { 5481 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx, 5482 HDA_AMP_MUTE, 0); 5483 } else { 5484 snd_hda_codec_write_cache(codec, cap, 0, 5485 AC_VERB_SET_CONNECT_SEL, idx); 5486 } 5487} 5488 5489/* set the default connection to that pin */ 5490static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin) 5491{ 5492 struct alc_spec *spec = codec->spec; 5493 int i; 5494 5495 for (i = 0; i < spec->num_adc_nids; i++) { 5496 hda_nid_t cap = spec->capsrc_nids ? 5497 spec->capsrc_nids[i] : spec->adc_nids[i]; 5498 int idx; 5499 5500 idx = get_connection_index(codec, cap, pin); 5501 if (idx < 0) 5502 continue; 5503 select_or_unmute_capsrc(codec, cap, idx); 5504 return i; /* return the found index */ 5505 } 5506 return -1; /* not found */ 5507} 5508 5509/* choose the ADC/MUX containing the input pin and initialize the setup */ 5510static void fixup_single_adc(struct hda_codec *codec) 5511{ 5512 struct alc_spec *spec = codec->spec; 5513 struct auto_pin_cfg *cfg = &spec->autocfg; 5514 int i; 5515 5516 /* search for the input pin; there must be only one */ 5517 if (cfg->num_inputs != 1) 5518 return; 5519 i = init_capsrc_for_pin(codec, cfg->inputs[0].pin); 5520 if (i >= 0) { 5521 /* use only this ADC */ 5522 if (spec->capsrc_nids) 5523 spec->capsrc_nids += i; 5524 spec->adc_nids += i; 5525 spec->num_adc_nids = 1; 5526 spec->single_input_src = 1; 5527 } 5528} 5529 5530/* initialize dual adcs */ 5531static void fixup_dual_adc_switch(struct hda_codec *codec) 5532{ 5533 struct alc_spec *spec = codec->spec; 5534 init_capsrc_for_pin(codec, spec->ext_mic.pin); 5535 init_capsrc_for_pin(codec, spec->int_mic.pin); 5536} 5537 5538/* initialize some special cases for input sources */ 5539static void alc_init_special_input_src(struct hda_codec *codec) 5540{ 5541 struct alc_spec *spec = codec->spec; 5542 if (spec->dual_adc_switch) 5543 fixup_dual_adc_switch(codec); 5544 else if (spec->single_input_src) 5545 init_capsrc_for_pin(codec, spec->autocfg.inputs[0].pin); 5546} 5547 5548static void set_capture_mixer(struct hda_codec *codec) 5549{ 5550 struct alc_spec *spec = codec->spec; 5551 static struct snd_kcontrol_new *caps[2][3] = { 5552 { alc_capture_mixer_nosrc1, 5553 alc_capture_mixer_nosrc2, 5554 alc_capture_mixer_nosrc3 }, 5555 { alc_capture_mixer1, 5556 alc_capture_mixer2, 5557 alc_capture_mixer3 }, 5558 }; 5559 if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) { 5560 int mux = 0; 5561 int num_adcs = spec->num_adc_nids; 5562 if (spec->dual_adc_switch) 5563 num_adcs = 1; 5564 else if (spec->auto_mic) 5565 fixup_automic_adc(codec); 5566 else if (spec->input_mux) { 5567 if (spec->input_mux->num_items > 1) 5568 mux = 1; 5569 else if (spec->input_mux->num_items == 1) 5570 fixup_single_adc(codec); 5571 } 5572 spec->cap_mixer = caps[mux][num_adcs - 1]; 5573 } 5574} 5575 5576/* fill adc_nids (and capsrc_nids) containing all active input pins */ 5577static void fillup_priv_adc_nids(struct hda_codec *codec, hda_nid_t *nids, 5578 int num_nids) 5579{ 5580 struct alc_spec *spec = codec->spec; 5581 struct auto_pin_cfg *cfg = &spec->autocfg; 5582 int n; 5583 hda_nid_t fallback_adc = 0, fallback_cap = 0; 5584 5585 for (n = 0; n < num_nids; n++) { 5586 hda_nid_t adc, cap; 5587 hda_nid_t conn[HDA_MAX_NUM_INPUTS]; 5588 int nconns, i, j; 5589 5590 adc = nids[n]; 5591 if (get_wcaps_type(get_wcaps(codec, adc)) != AC_WID_AUD_IN) 5592 continue; 5593 cap = adc; 5594 nconns = snd_hda_get_connections(codec, cap, conn, 5595 ARRAY_SIZE(conn)); 5596 if (nconns == 1) { 5597 cap = conn[0]; 5598 nconns = snd_hda_get_connections(codec, cap, conn, 5599 ARRAY_SIZE(conn)); 5600 } 5601 if (nconns <= 0) 5602 continue; 5603 if (!fallback_adc) { 5604 fallback_adc = adc; 5605 fallback_cap = cap; 5606 } 5607 for (i = 0; i < cfg->num_inputs; i++) { 5608 hda_nid_t nid = cfg->inputs[i].pin; 5609 for (j = 0; j < nconns; j++) { 5610 if (conn[j] == nid) 5611 break; 5612 } 5613 if (j >= nconns) 5614 break; 5615 } 5616 if (i >= cfg->num_inputs) { 5617 int num_adcs = spec->num_adc_nids; 5618 spec->private_adc_nids[num_adcs] = adc; 5619 spec->private_capsrc_nids[num_adcs] = cap; 5620 spec->num_adc_nids++; 5621 spec->adc_nids = spec->private_adc_nids; 5622 if (adc != cap) 5623 spec->capsrc_nids = spec->private_capsrc_nids; 5624 } 5625 } 5626 if (!spec->num_adc_nids) { 5627 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;" 5628 " using fallback 0x%x\n", 5629 codec->chip_name, fallback_adc); 5630 spec->private_adc_nids[0] = fallback_adc; 5631 spec->adc_nids = spec->private_adc_nids; 5632 if (fallback_adc != fallback_cap) { 5633 spec->private_capsrc_nids[0] = fallback_cap; 5634 spec->capsrc_nids = spec->private_adc_nids; 5635 } 5636 } 5637} 5638 5639#ifdef CONFIG_SND_HDA_INPUT_BEEP 5640#define set_beep_amp(spec, nid, idx, dir) \ 5641 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir)) 5642 5643static struct snd_pci_quirk beep_white_list[] = { 5644 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1), 5645 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1), 5646 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1), 5647 {} 5648}; 5649 5650static inline int has_cdefine_beep(struct hda_codec *codec) 5651{ 5652 struct alc_spec *spec = codec->spec; 5653 const struct snd_pci_quirk *q; 5654 q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list); 5655 if (q) 5656 return q->value; 5657 return spec->cdefine.enable_pcbeep; 5658} 5659#else 5660#define set_beep_amp(spec, nid, idx, dir) /* NOP */ 5661#define has_cdefine_beep(codec) 0 5662#endif 5663 5664/* 5665 * OK, here we have finally the patch for ALC880 5666 */ 5667 5668static int patch_alc880(struct hda_codec *codec) 5669{ 5670 struct alc_spec *spec; 5671 int board_config; 5672 int err; 5673 5674 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5675 if (spec == NULL) 5676 return -ENOMEM; 5677 5678 codec->spec = spec; 5679 5680 board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST, 5681 alc880_models, 5682 alc880_cfg_tbl); 5683 if (board_config < 0) { 5684 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 5685 codec->chip_name); 5686 board_config = ALC880_AUTO; 5687 } 5688 5689 if (board_config == ALC880_AUTO) { 5690 /* automatic parse from the BIOS config */ 5691 err = alc880_parse_auto_config(codec); 5692 if (err < 0) { 5693 alc_free(codec); 5694 return err; 5695 } else if (!err) { 5696 printk(KERN_INFO 5697 "hda_codec: Cannot set up configuration " 5698 "from BIOS. Using 3-stack mode...\n"); 5699 board_config = ALC880_3ST; 5700 } 5701 } 5702 5703 err = snd_hda_attach_beep_device(codec, 0x1); 5704 if (err < 0) { 5705 alc_free(codec); 5706 return err; 5707 } 5708 5709 if (board_config != ALC880_AUTO) 5710 setup_preset(codec, &alc880_presets[board_config]); 5711 5712 spec->stream_analog_playback = &alc880_pcm_analog_playback; 5713 spec->stream_analog_capture = &alc880_pcm_analog_capture; 5714 spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture; 5715 5716 spec->stream_digital_playback = &alc880_pcm_digital_playback; 5717 spec->stream_digital_capture = &alc880_pcm_digital_capture; 5718 5719 if (!spec->adc_nids && spec->input_mux) { 5720 /* check whether NID 0x07 is valid */ 5721 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]); 5722 /* get type */ 5723 wcap = get_wcaps_type(wcap); 5724 if (wcap != AC_WID_AUD_IN) { 5725 spec->adc_nids = alc880_adc_nids_alt; 5726 spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt); 5727 } else { 5728 spec->adc_nids = alc880_adc_nids; 5729 spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids); 5730 } 5731 } 5732 set_capture_mixer(codec); 5733 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 5734 5735 spec->vmaster_nid = 0x0c; 5736 5737 codec->patch_ops = alc_patch_ops; 5738 if (board_config == ALC880_AUTO) 5739 spec->init_hook = alc880_auto_init; 5740#ifdef CONFIG_SND_HDA_POWER_SAVE 5741 if (!spec->loopback.amplist) 5742 spec->loopback.amplist = alc880_loopbacks; 5743#endif 5744 5745 return 0; 5746} 5747 5748 5749/* 5750 * ALC260 support 5751 */ 5752 5753static hda_nid_t alc260_dac_nids[1] = { 5754 /* front */ 5755 0x02, 5756}; 5757 5758static hda_nid_t alc260_adc_nids[1] = { 5759 /* ADC0 */ 5760 0x04, 5761}; 5762 5763static hda_nid_t alc260_adc_nids_alt[1] = { 5764 /* ADC1 */ 5765 0x05, 5766}; 5767 5768/* NIDs used when simultaneous access to both ADCs makes sense. Note that 5769 * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC. 5770 */ 5771static hda_nid_t alc260_dual_adc_nids[2] = { 5772 /* ADC0, ADC1 */ 5773 0x04, 0x05 5774}; 5775 5776#define ALC260_DIGOUT_NID 0x03 5777#define ALC260_DIGIN_NID 0x06 5778 5779static struct hda_input_mux alc260_capture_source = { 5780 .num_items = 4, 5781 .items = { 5782 { "Mic", 0x0 }, 5783 { "Front Mic", 0x1 }, 5784 { "Line", 0x2 }, 5785 { "CD", 0x4 }, 5786 }, 5787}; 5788 5789/* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack, 5790 * headphone jack and the internal CD lines since these are the only pins at 5791 * which audio can appear. For flexibility, also allow the option of 5792 * recording the mixer output on the second ADC (ADC0 doesn't have a 5793 * connection to the mixer output). 5794 */ 5795static struct hda_input_mux alc260_fujitsu_capture_sources[2] = { 5796 { 5797 .num_items = 3, 5798 .items = { 5799 { "Mic/Line", 0x0 }, 5800 { "CD", 0x4 }, 5801 { "Headphone", 0x2 }, 5802 }, 5803 }, 5804 { 5805 .num_items = 4, 5806 .items = { 5807 { "Mic/Line", 0x0 }, 5808 { "CD", 0x4 }, 5809 { "Headphone", 0x2 }, 5810 { "Mixer", 0x5 }, 5811 }, 5812 }, 5813 5814}; 5815 5816/* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to 5817 * the Fujitsu S702x, but jacks are marked differently. 5818 */ 5819static struct hda_input_mux alc260_acer_capture_sources[2] = { 5820 { 5821 .num_items = 4, 5822 .items = { 5823 { "Mic", 0x0 }, 5824 { "Line", 0x2 }, 5825 { "CD", 0x4 }, 5826 { "Headphone", 0x5 }, 5827 }, 5828 }, 5829 { 5830 .num_items = 5, 5831 .items = { 5832 { "Mic", 0x0 }, 5833 { "Line", 0x2 }, 5834 { "CD", 0x4 }, 5835 { "Headphone", 0x6 }, 5836 { "Mixer", 0x5 }, 5837 }, 5838 }, 5839}; 5840 5841/* Maxdata Favorit 100XS */ 5842static struct hda_input_mux alc260_favorit100_capture_sources[2] = { 5843 { 5844 .num_items = 2, 5845 .items = { 5846 { "Line/Mic", 0x0 }, 5847 { "CD", 0x4 }, 5848 }, 5849 }, 5850 { 5851 .num_items = 3, 5852 .items = { 5853 { "Line/Mic", 0x0 }, 5854 { "CD", 0x4 }, 5855 { "Mixer", 0x5 }, 5856 }, 5857 }, 5858}; 5859 5860/* 5861 * This is just place-holder, so there's something for alc_build_pcms to look 5862 * at when it calculates the maximum number of channels. ALC260 has no mixer 5863 * element which allows changing the channel mode, so the verb list is 5864 * never used. 5865 */ 5866static struct hda_channel_mode alc260_modes[1] = { 5867 { 2, NULL }, 5868}; 5869 5870 5871/* Mixer combinations 5872 * 5873 * basic: base_output + input + pc_beep + capture 5874 * HP: base_output + input + capture_alt 5875 * HP_3013: hp_3013 + input + capture 5876 * fujitsu: fujitsu + capture 5877 * acer: acer + capture 5878 */ 5879 5880static struct snd_kcontrol_new alc260_base_output_mixer[] = { 5881 HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT), 5882 HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT), 5883 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT), 5884 HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT), 5885 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT), 5886 HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT), 5887 { } /* end */ 5888}; 5889 5890static struct snd_kcontrol_new alc260_input_mixer[] = { 5891 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 5892 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 5893 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT), 5894 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT), 5895 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT), 5896 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT), 5897 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT), 5898 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT), 5899 { } /* end */ 5900}; 5901 5902/* update HP, line and mono out pins according to the master switch */ 5903static void alc260_hp_master_update(struct hda_codec *codec, 5904 hda_nid_t hp, hda_nid_t line, 5905 hda_nid_t mono) 5906{ 5907 struct alc_spec *spec = codec->spec; 5908 unsigned int val = spec->master_sw ? PIN_HP : 0; 5909 /* change HP and line-out pins */ 5910 snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 5911 val); 5912 snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 5913 val); 5914 /* mono (speaker) depending on the HP jack sense */ 5915 val = (val && !spec->jack_present) ? PIN_OUT : 0; 5916 snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 5917 val); 5918} 5919 5920static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol, 5921 struct snd_ctl_elem_value *ucontrol) 5922{ 5923 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 5924 struct alc_spec *spec = codec->spec; 5925 *ucontrol->value.integer.value = spec->master_sw; 5926 return 0; 5927} 5928 5929static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol, 5930 struct snd_ctl_elem_value *ucontrol) 5931{ 5932 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 5933 struct alc_spec *spec = codec->spec; 5934 int val = !!*ucontrol->value.integer.value; 5935 hda_nid_t hp, line, mono; 5936 5937 if (val == spec->master_sw) 5938 return 0; 5939 spec->master_sw = val; 5940 hp = (kcontrol->private_value >> 16) & 0xff; 5941 line = (kcontrol->private_value >> 8) & 0xff; 5942 mono = kcontrol->private_value & 0xff; 5943 alc260_hp_master_update(codec, hp, line, mono); 5944 return 1; 5945} 5946 5947static struct snd_kcontrol_new alc260_hp_output_mixer[] = { 5948 { 5949 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 5950 .name = "Master Playback Switch", 5951 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11, 5952 .info = snd_ctl_boolean_mono_info, 5953 .get = alc260_hp_master_sw_get, 5954 .put = alc260_hp_master_sw_put, 5955 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11 5956 }, 5957 HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT), 5958 HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT), 5959 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT), 5960 HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT), 5961 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, 5962 HDA_OUTPUT), 5963 HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT), 5964 { } /* end */ 5965}; 5966 5967static struct hda_verb alc260_hp_unsol_verbs[] = { 5968 {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 5969 {}, 5970}; 5971 5972static void alc260_hp_automute(struct hda_codec *codec) 5973{ 5974 struct alc_spec *spec = codec->spec; 5975 5976 spec->jack_present = snd_hda_jack_detect(codec, 0x10); 5977 alc260_hp_master_update(codec, 0x0f, 0x10, 0x11); 5978} 5979 5980static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res) 5981{ 5982 if ((res >> 26) == ALC880_HP_EVENT) 5983 alc260_hp_automute(codec); 5984} 5985 5986static struct snd_kcontrol_new alc260_hp_3013_mixer[] = { 5987 { 5988 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 5989 .name = "Master Playback Switch", 5990 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11, 5991 .info = snd_ctl_boolean_mono_info, 5992 .get = alc260_hp_master_sw_get, 5993 .put = alc260_hp_master_sw_put, 5994 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11 5995 }, 5996 HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT), 5997 HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT), 5998 HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT), 5999 HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT), 6000 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT), 6001 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 6002 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT), 6003 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT), 6004 { } /* end */ 6005}; 6006 6007static struct hda_bind_ctls alc260_dc7600_bind_master_vol = { 6008 .ops = &snd_hda_bind_vol, 6009 .values = { 6010 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT), 6011 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT), 6012 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT), 6013 0 6014 }, 6015}; 6016 6017static struct hda_bind_ctls alc260_dc7600_bind_switch = { 6018 .ops = &snd_hda_bind_sw, 6019 .values = { 6020 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT), 6021 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT), 6022 0 6023 }, 6024}; 6025 6026static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = { 6027 HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol), 6028 HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch), 6029 HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT), 6030 HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT), 6031 { } /* end */ 6032}; 6033 6034static struct hda_verb alc260_hp_3013_unsol_verbs[] = { 6035 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 6036 {}, 6037}; 6038 6039static void alc260_hp_3013_automute(struct hda_codec *codec) 6040{ 6041 struct alc_spec *spec = codec->spec; 6042 6043 spec->jack_present = snd_hda_jack_detect(codec, 0x15); 6044 alc260_hp_master_update(codec, 0x15, 0x10, 0x11); 6045} 6046 6047static void alc260_hp_3013_unsol_event(struct hda_codec *codec, 6048 unsigned int res) 6049{ 6050 if ((res >> 26) == ALC880_HP_EVENT) 6051 alc260_hp_3013_automute(codec); 6052} 6053 6054static void alc260_hp_3012_automute(struct hda_codec *codec) 6055{ 6056 unsigned int bits = snd_hda_jack_detect(codec, 0x10) ? 0 : PIN_OUT; 6057 6058 snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 6059 bits); 6060 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 6061 bits); 6062 snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 6063 bits); 6064} 6065 6066static void alc260_hp_3012_unsol_event(struct hda_codec *codec, 6067 unsigned int res) 6068{ 6069 if ((res >> 26) == ALC880_HP_EVENT) 6070 alc260_hp_3012_automute(codec); 6071} 6072 6073/* Fujitsu S702x series laptops. ALC260 pin usage: Mic/Line jack = 0x12, 6074 * HP jack = 0x14, CD audio = 0x16, internal speaker = 0x10. 6075 */ 6076static struct snd_kcontrol_new alc260_fujitsu_mixer[] = { 6077 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT), 6078 HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT), 6079 ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT), 6080 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 6081 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 6082 HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT), 6083 HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT), 6084 ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN), 6085 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT), 6086 HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT), 6087 { } /* end */ 6088}; 6089 6090/* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks. Note that current 6091 * versions of the ALC260 don't act on requests to enable mic bias from NID 6092 * 0x0f (used to drive the headphone jack in these laptops). The ALC260 6093 * datasheet doesn't mention this restriction. At this stage it's not clear 6094 * whether this behaviour is intentional or is a hardware bug in chip 6095 * revisions available in early 2006. Therefore for now allow the 6096 * "Headphone Jack Mode" control to span all choices, but if it turns out 6097 * that the lack of mic bias for this NID is intentional we could change the 6098 * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS. 6099 * 6100 * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006 6101 * don't appear to make the mic bias available from the "line" jack, even 6102 * though the NID used for this jack (0x14) can supply it. The theory is 6103 * that perhaps Acer have included blocking capacitors between the ALC260 6104 * and the output jack. If this turns out to be the case for all such 6105 * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT 6106 * to ALC_PIN_DIR_INOUT_NOMICBIAS. 6107 * 6108 * The C20x Tablet series have a mono internal speaker which is controlled 6109 * via the chip's Mono sum widget and pin complex, so include the necessary 6110 * controls for such models. On models without a "mono speaker" the control 6111 * won't do anything. 6112 */ 6113static struct snd_kcontrol_new alc260_acer_mixer[] = { 6114 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT), 6115 HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT), 6116 ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT), 6117 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, 6118 HDA_OUTPUT), 6119 HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, 6120 HDA_INPUT), 6121 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 6122 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 6123 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT), 6124 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT), 6125 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN), 6126 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT), 6127 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT), 6128 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT), 6129 { } /* end */ 6130}; 6131 6132/* Maxdata Favorit 100XS: one output and one input (0x12) jack 6133 */ 6134static struct snd_kcontrol_new alc260_favorit100_mixer[] = { 6135 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT), 6136 HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT), 6137 ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT), 6138 HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT), 6139 HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT), 6140 ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN), 6141 { } /* end */ 6142}; 6143 6144/* Packard bell V7900 ALC260 pin usage: HP = 0x0f, Mic jack = 0x12, 6145 * Line In jack = 0x14, CD audio = 0x16, pc beep = 0x17. 6146 */ 6147static struct snd_kcontrol_new alc260_will_mixer[] = { 6148 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT), 6149 HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT), 6150 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT), 6151 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT), 6152 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN), 6153 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT), 6154 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT), 6155 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT), 6156 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 6157 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 6158 { } /* end */ 6159}; 6160 6161/* Replacer 672V ALC260 pin usage: Mic jack = 0x12, 6162 * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f. 6163 */ 6164static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = { 6165 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT), 6166 HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT), 6167 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT), 6168 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT), 6169 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN), 6170 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT), 6171 HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT), 6172 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT), 6173 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT), 6174 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT), 6175 { } /* end */ 6176}; 6177 6178/* 6179 * initialization verbs 6180 */ 6181static struct hda_verb alc260_init_verbs[] = { 6182 /* Line In pin widget for input */ 6183 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 6184 /* CD pin widget for input */ 6185 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 6186 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 6187 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 6188 /* Mic2 (front panel) pin widget for input and vref at 80% */ 6189 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 6190 /* LINE-2 is used for line-out in rear */ 6191 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6192 /* select line-out */ 6193 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00}, 6194 /* LINE-OUT pin */ 6195 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6196 /* enable HP */ 6197 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 6198 /* enable Mono */ 6199 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6200 /* mute capture amp left and right */ 6201 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6202 /* set connection select to line in (default select for this ADC) */ 6203 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02}, 6204 /* mute capture amp left and right */ 6205 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6206 /* set connection select to line in (default select for this ADC) */ 6207 {0x05, AC_VERB_SET_CONNECT_SEL, 0x02}, 6208 /* set vol=0 Line-Out mixer amp left and right */ 6209 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6210 /* unmute pin widget amp left and right (no gain on this amp) */ 6211 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6212 /* set vol=0 HP mixer amp left and right */ 6213 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6214 /* unmute pin widget amp left and right (no gain on this amp) */ 6215 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6216 /* set vol=0 Mono mixer amp left and right */ 6217 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6218 /* unmute pin widget amp left and right (no gain on this amp) */ 6219 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6220 /* unmute LINE-2 out pin */ 6221 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6222 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & 6223 * Line In 2 = 0x03 6224 */ 6225 /* mute analog inputs */ 6226 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6227 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6228 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6229 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6230 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6231 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */ 6232 /* mute Front out path */ 6233 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6234 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6235 /* mute Headphone out path */ 6236 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6237 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6238 /* mute Mono out path */ 6239 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6240 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6241 { } 6242}; 6243 6244#if 0 /* should be identical with alc260_init_verbs? */ 6245static struct hda_verb alc260_hp_init_verbs[] = { 6246 /* Headphone and output */ 6247 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 6248 /* mono output */ 6249 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 6250 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 6251 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 6252 /* Mic2 (front panel) pin widget for input and vref at 80% */ 6253 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 6254 /* Line In pin widget for input */ 6255 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 6256 /* Line-2 pin widget for output */ 6257 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 6258 /* CD pin widget for input */ 6259 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 6260 /* unmute amp left and right */ 6261 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000}, 6262 /* set connection select to line in (default select for this ADC) */ 6263 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02}, 6264 /* unmute Line-Out mixer amp left and right (volume = 0) */ 6265 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 6266 /* mute pin widget amp left and right (no gain on this amp) */ 6267 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 6268 /* unmute HP mixer amp left and right (volume = 0) */ 6269 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 6270 /* mute pin widget amp left and right (no gain on this amp) */ 6271 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 6272 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & 6273 * Line In 2 = 0x03 6274 */ 6275 /* mute analog inputs */ 6276 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6277 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6278 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6279 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6280 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6281 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */ 6282 /* Unmute Front out path */ 6283 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 6284 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 6285 /* Unmute Headphone out path */ 6286 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 6287 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 6288 /* Unmute Mono out path */ 6289 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 6290 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 6291 { } 6292}; 6293#endif 6294 6295static struct hda_verb alc260_hp_3013_init_verbs[] = { 6296 /* Line out and output */ 6297 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 6298 /* mono output */ 6299 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 6300 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 6301 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 6302 /* Mic2 (front panel) pin widget for input and vref at 80% */ 6303 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 6304 /* Line In pin widget for input */ 6305 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 6306 /* Headphone pin widget for output */ 6307 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 6308 /* CD pin widget for input */ 6309 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 6310 /* unmute amp left and right */ 6311 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000}, 6312 /* set connection select to line in (default select for this ADC) */ 6313 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02}, 6314 /* unmute Line-Out mixer amp left and right (volume = 0) */ 6315 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 6316 /* mute pin widget amp left and right (no gain on this amp) */ 6317 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 6318 /* unmute HP mixer amp left and right (volume = 0) */ 6319 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 6320 /* mute pin widget amp left and right (no gain on this amp) */ 6321 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 6322 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & 6323 * Line In 2 = 0x03 6324 */ 6325 /* mute analog inputs */ 6326 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6327 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6328 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6329 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6330 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6331 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */ 6332 /* Unmute Front out path */ 6333 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 6334 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 6335 /* Unmute Headphone out path */ 6336 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 6337 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 6338 /* Unmute Mono out path */ 6339 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 6340 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 6341 { } 6342}; 6343 6344/* Initialisation sequence for ALC260 as configured in Fujitsu S702x 6345 * laptops. ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD 6346 * audio = 0x16, internal speaker = 0x10. 6347 */ 6348static struct hda_verb alc260_fujitsu_init_verbs[] = { 6349 /* Disable all GPIOs */ 6350 {0x01, AC_VERB_SET_GPIO_MASK, 0}, 6351 /* Internal speaker is connected to headphone pin */ 6352 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 6353 /* Headphone/Line-out jack connects to Line1 pin; make it an output */ 6354 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6355 /* Mic/Line-in jack is connected to mic1 pin, so make it an input */ 6356 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 6357 /* Ensure all other unused pins are disabled and muted. */ 6358 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 6359 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6360 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 6361 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6362 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 6363 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6364 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 6365 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6366 6367 /* Disable digital (SPDIF) pins */ 6368 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0}, 6369 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0}, 6370 6371 /* Ensure Line1 pin widget takes its input from the OUT1 sum bus 6372 * when acting as an output. 6373 */ 6374 {0x0d, AC_VERB_SET_CONNECT_SEL, 0}, 6375 6376 /* Start with output sum widgets muted and their output gains at min */ 6377 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6378 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6379 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6380 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6381 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6382 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6383 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6384 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6385 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6386 6387 /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */ 6388 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6389 /* Unmute Line1 pin widget output buffer since it starts as an output. 6390 * If the pin mode is changed by the user the pin mode control will 6391 * take care of enabling the pin's input/output buffers as needed. 6392 * Therefore there's no need to enable the input buffer at this 6393 * stage. 6394 */ 6395 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6396 /* Unmute input buffer of pin widget used for Line-in (no equiv 6397 * mixer ctrl) 6398 */ 6399 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6400 6401 /* Mute capture amp left and right */ 6402 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6403 /* Set ADC connection select to match default mixer setting - line 6404 * in (on mic1 pin) 6405 */ 6406 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00}, 6407 6408 /* Do the same for the second ADC: mute capture input amp and 6409 * set ADC connection to line in (on mic1 pin) 6410 */ 6411 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6412 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00}, 6413 6414 /* Mute all inputs to mixer widget (even unconnected ones) */ 6415 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */ 6416 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */ 6417 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */ 6418 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */ 6419 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */ 6420 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */ 6421 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */ 6422 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */ 6423 6424 { } 6425}; 6426 6427/* Initialisation sequence for ALC260 as configured in Acer TravelMate and 6428 * similar laptops (adapted from Fujitsu init verbs). 6429 */ 6430static struct hda_verb alc260_acer_init_verbs[] = { 6431 /* On TravelMate laptops, GPIO 0 enables the internal speaker and 6432 * the headphone jack. Turn this on and rely on the standard mute 6433 * methods whenever the user wants to turn these outputs off. 6434 */ 6435 {0x01, AC_VERB_SET_GPIO_MASK, 0x01}, 6436 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, 6437 {0x01, AC_VERB_SET_GPIO_DATA, 0x01}, 6438 /* Internal speaker/Headphone jack is connected to Line-out pin */ 6439 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 6440 /* Internal microphone/Mic jack is connected to Mic1 pin */ 6441 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50}, 6442 /* Line In jack is connected to Line1 pin */ 6443 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 6444 /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */ 6445 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 6446 /* Ensure all other unused pins are disabled and muted. */ 6447 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 6448 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6449 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 6450 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6451 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 6452 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6453 /* Disable digital (SPDIF) pins */ 6454 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0}, 6455 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0}, 6456 6457 /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum 6458 * bus when acting as outputs. 6459 */ 6460 {0x0b, AC_VERB_SET_CONNECT_SEL, 0}, 6461 {0x0d, AC_VERB_SET_CONNECT_SEL, 0}, 6462 6463 /* Start with output sum widgets muted and their output gains at min */ 6464 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6465 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6466 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6467 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6468 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6469 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6470 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6471 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6472 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6473 6474 /* Unmute Line-out pin widget amp left and right 6475 * (no equiv mixer ctrl) 6476 */ 6477 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6478 /* Unmute mono pin widget amp output (no equiv mixer ctrl) */ 6479 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6480 /* Unmute Mic1 and Line1 pin widget input buffers since they start as 6481 * inputs. If the pin mode is changed by the user the pin mode control 6482 * will take care of enabling the pin's input/output buffers as needed. 6483 * Therefore there's no need to enable the input buffer at this 6484 * stage. 6485 */ 6486 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6487 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6488 6489 /* Mute capture amp left and right */ 6490 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6491 /* Set ADC connection select to match default mixer setting - mic 6492 * (on mic1 pin) 6493 */ 6494 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00}, 6495 6496 /* Do similar with the second ADC: mute capture input amp and 6497 * set ADC connection to mic to match ALSA's default state. 6498 */ 6499 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6500 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00}, 6501 6502 /* Mute all inputs to mixer widget (even unconnected ones) */ 6503 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */ 6504 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */ 6505 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */ 6506 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */ 6507 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */ 6508 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */ 6509 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */ 6510 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */ 6511 6512 { } 6513}; 6514 6515/* Initialisation sequence for Maxdata Favorit 100XS 6516 * (adapted from Acer init verbs). 6517 */ 6518static struct hda_verb alc260_favorit100_init_verbs[] = { 6519 /* GPIO 0 enables the output jack. 6520 * Turn this on and rely on the standard mute 6521 * methods whenever the user wants to turn these outputs off. 6522 */ 6523 {0x01, AC_VERB_SET_GPIO_MASK, 0x01}, 6524 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, 6525 {0x01, AC_VERB_SET_GPIO_DATA, 0x01}, 6526 /* Line/Mic input jack is connected to Mic1 pin */ 6527 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50}, 6528 /* Ensure all other unused pins are disabled and muted. */ 6529 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 6530 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6531 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 6532 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6533 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 6534 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6535 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 6536 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6537 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 6538 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6539 /* Disable digital (SPDIF) pins */ 6540 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0}, 6541 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0}, 6542 6543 /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum 6544 * bus when acting as outputs. 6545 */ 6546 {0x0b, AC_VERB_SET_CONNECT_SEL, 0}, 6547 {0x0d, AC_VERB_SET_CONNECT_SEL, 0}, 6548 6549 /* Start with output sum widgets muted and their output gains at min */ 6550 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6551 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6552 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6553 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6554 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6555 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6556 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6557 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6558 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6559 6560 /* Unmute Line-out pin widget amp left and right 6561 * (no equiv mixer ctrl) 6562 */ 6563 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6564 /* Unmute Mic1 and Line1 pin widget input buffers since they start as 6565 * inputs. If the pin mode is changed by the user the pin mode control 6566 * will take care of enabling the pin's input/output buffers as needed. 6567 * Therefore there's no need to enable the input buffer at this 6568 * stage. 6569 */ 6570 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6571 6572 /* Mute capture amp left and right */ 6573 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6574 /* Set ADC connection select to match default mixer setting - mic 6575 * (on mic1 pin) 6576 */ 6577 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00}, 6578 6579 /* Do similar with the second ADC: mute capture input amp and 6580 * set ADC connection to mic to match ALSA's default state. 6581 */ 6582 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6583 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00}, 6584 6585 /* Mute all inputs to mixer widget (even unconnected ones) */ 6586 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */ 6587 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */ 6588 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */ 6589 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */ 6590 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */ 6591 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */ 6592 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */ 6593 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */ 6594 6595 { } 6596}; 6597 6598static struct hda_verb alc260_will_verbs[] = { 6599 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 6600 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00}, 6601 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00}, 6602 {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02}, 6603 {0x1a, AC_VERB_SET_COEF_INDEX, 0x07}, 6604 {0x1a, AC_VERB_SET_PROC_COEF, 0x3040}, 6605 {} 6606}; 6607 6608static struct hda_verb alc260_replacer_672v_verbs[] = { 6609 {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02}, 6610 {0x1a, AC_VERB_SET_COEF_INDEX, 0x07}, 6611 {0x1a, AC_VERB_SET_PROC_COEF, 0x3050}, 6612 6613 {0x01, AC_VERB_SET_GPIO_MASK, 0x01}, 6614 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, 6615 {0x01, AC_VERB_SET_GPIO_DATA, 0x00}, 6616 6617 {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 6618 {} 6619}; 6620 6621/* toggle speaker-output according to the hp-jack state */ 6622static void alc260_replacer_672v_automute(struct hda_codec *codec) 6623{ 6624 unsigned int present; 6625 6626 /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */ 6627 present = snd_hda_jack_detect(codec, 0x0f); 6628 if (present) { 6629 snd_hda_codec_write_cache(codec, 0x01, 0, 6630 AC_VERB_SET_GPIO_DATA, 1); 6631 snd_hda_codec_write_cache(codec, 0x0f, 0, 6632 AC_VERB_SET_PIN_WIDGET_CONTROL, 6633 PIN_HP); 6634 } else { 6635 snd_hda_codec_write_cache(codec, 0x01, 0, 6636 AC_VERB_SET_GPIO_DATA, 0); 6637 snd_hda_codec_write_cache(codec, 0x0f, 0, 6638 AC_VERB_SET_PIN_WIDGET_CONTROL, 6639 PIN_OUT); 6640 } 6641} 6642 6643static void alc260_replacer_672v_unsol_event(struct hda_codec *codec, 6644 unsigned int res) 6645{ 6646 if ((res >> 26) == ALC880_HP_EVENT) 6647 alc260_replacer_672v_automute(codec); 6648} 6649 6650static struct hda_verb alc260_hp_dc7600_verbs[] = { 6651 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01}, 6652 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 6653 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6654 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 6655 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6656 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6657 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 6658 {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 6659 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 6660 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 6661 {} 6662}; 6663 6664/* Test configuration for debugging, modelled after the ALC880 test 6665 * configuration. 6666 */ 6667#ifdef CONFIG_SND_DEBUG 6668static hda_nid_t alc260_test_dac_nids[1] = { 6669 0x02, 6670}; 6671static hda_nid_t alc260_test_adc_nids[2] = { 6672 0x04, 0x05, 6673}; 6674/* For testing the ALC260, each input MUX needs its own definition since 6675 * the signal assignments are different. This assumes that the first ADC 6676 * is NID 0x04. 6677 */ 6678static struct hda_input_mux alc260_test_capture_sources[2] = { 6679 { 6680 .num_items = 7, 6681 .items = { 6682 { "MIC1 pin", 0x0 }, 6683 { "MIC2 pin", 0x1 }, 6684 { "LINE1 pin", 0x2 }, 6685 { "LINE2 pin", 0x3 }, 6686 { "CD pin", 0x4 }, 6687 { "LINE-OUT pin", 0x5 }, 6688 { "HP-OUT pin", 0x6 }, 6689 }, 6690 }, 6691 { 6692 .num_items = 8, 6693 .items = { 6694 { "MIC1 pin", 0x0 }, 6695 { "MIC2 pin", 0x1 }, 6696 { "LINE1 pin", 0x2 }, 6697 { "LINE2 pin", 0x3 }, 6698 { "CD pin", 0x4 }, 6699 { "Mixer", 0x5 }, 6700 { "LINE-OUT pin", 0x6 }, 6701 { "HP-OUT pin", 0x7 }, 6702 }, 6703 }, 6704}; 6705static struct snd_kcontrol_new alc260_test_mixer[] = { 6706 /* Output driver widgets */ 6707 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT), 6708 HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT), 6709 HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT), 6710 HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT), 6711 HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT), 6712 HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT), 6713 6714 /* Modes for retasking pin widgets 6715 * Note: the ALC260 doesn't seem to act on requests to enable mic 6716 * bias from NIDs 0x0f and 0x10. The ALC260 datasheet doesn't 6717 * mention this restriction. At this stage it's not clear whether 6718 * this behaviour is intentional or is a hardware bug in chip 6719 * revisions available at least up until early 2006. Therefore for 6720 * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all 6721 * choices, but if it turns out that the lack of mic bias for these 6722 * NIDs is intentional we could change their modes from 6723 * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS. 6724 */ 6725 ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT), 6726 ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT), 6727 ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT), 6728 ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT), 6729 ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT), 6730 ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT), 6731 6732 /* Loopback mixer controls */ 6733 HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT), 6734 HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT), 6735 HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT), 6736 HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT), 6737 HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT), 6738 HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT), 6739 HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT), 6740 HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT), 6741 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 6742 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 6743 HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT), 6744 HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT), 6745 HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT), 6746 HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT), 6747 6748 /* Controls for GPIO pins, assuming they are configured as outputs */ 6749 ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01), 6750 ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02), 6751 ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04), 6752 ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08), 6753 6754 /* Switches to allow the digital IO pins to be enabled. The datasheet 6755 * is ambigious as to which NID is which; testing on laptops which 6756 * make this output available should provide clarification. 6757 */ 6758 ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01), 6759 ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01), 6760 6761 /* A switch allowing EAPD to be enabled. Some laptops seem to use 6762 * this output to turn on an external amplifier. 6763 */ 6764 ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02), 6765 ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02), 6766 6767 { } /* end */ 6768}; 6769static struct hda_verb alc260_test_init_verbs[] = { 6770 /* Enable all GPIOs as outputs with an initial value of 0 */ 6771 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f}, 6772 {0x01, AC_VERB_SET_GPIO_DATA, 0x00}, 6773 {0x01, AC_VERB_SET_GPIO_MASK, 0x0f}, 6774 6775 /* Enable retasking pins as output, initially without power amp */ 6776 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6777 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6778 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6779 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6780 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6781 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6782 6783 /* Disable digital (SPDIF) pins initially, but users can enable 6784 * them via a mixer switch. In the case of SPDIF-out, this initverb 6785 * payload also sets the generation to 0, output to be in "consumer" 6786 * PCM format, copyright asserted, no pre-emphasis and no validity 6787 * control. 6788 */ 6789 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0}, 6790 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0}, 6791 6792 /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the 6793 * OUT1 sum bus when acting as an output. 6794 */ 6795 {0x0b, AC_VERB_SET_CONNECT_SEL, 0}, 6796 {0x0c, AC_VERB_SET_CONNECT_SEL, 0}, 6797 {0x0d, AC_VERB_SET_CONNECT_SEL, 0}, 6798 {0x0e, AC_VERB_SET_CONNECT_SEL, 0}, 6799 6800 /* Start with output sum widgets muted and their output gains at min */ 6801 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6802 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6803 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6804 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6805 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6806 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6807 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6808 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6809 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6810 6811 /* Unmute retasking pin widget output buffers since the default 6812 * state appears to be output. As the pin mode is changed by the 6813 * user the pin mode control will take care of enabling the pin's 6814 * input/output buffers as needed. 6815 */ 6816 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6817 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6818 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6819 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6820 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6821 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6822 /* Also unmute the mono-out pin widget */ 6823 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6824 6825 /* Mute capture amp left and right */ 6826 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6827 /* Set ADC connection select to match default mixer setting (mic1 6828 * pin) 6829 */ 6830 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00}, 6831 6832 /* Do the same for the second ADC: mute capture input amp and 6833 * set ADC connection to mic1 pin 6834 */ 6835 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6836 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00}, 6837 6838 /* Mute all inputs to mixer widget (even unconnected ones) */ 6839 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */ 6840 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */ 6841 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */ 6842 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */ 6843 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */ 6844 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */ 6845 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */ 6846 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */ 6847 6848 { } 6849}; 6850#endif 6851 6852#define alc260_pcm_analog_playback alc880_pcm_analog_alt_playback 6853#define alc260_pcm_analog_capture alc880_pcm_analog_capture 6854 6855#define alc260_pcm_digital_playback alc880_pcm_digital_playback 6856#define alc260_pcm_digital_capture alc880_pcm_digital_capture 6857 6858/* 6859 * for BIOS auto-configuration 6860 */ 6861 6862static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid, 6863 const char *pfx, int *vol_bits) 6864{ 6865 hda_nid_t nid_vol; 6866 unsigned long vol_val, sw_val; 6867 int err; 6868 6869 if (nid >= 0x0f && nid < 0x11) { 6870 nid_vol = nid - 0x7; 6871 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT); 6872 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 6873 } else if (nid == 0x11) { 6874 nid_vol = nid - 0x7; 6875 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT); 6876 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT); 6877 } else if (nid >= 0x12 && nid <= 0x15) { 6878 nid_vol = 0x08; 6879 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT); 6880 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 6881 } else 6882 return 0; /* N/A */ 6883 6884 if (!(*vol_bits & (1 << nid_vol))) { 6885 /* first control for the volume widget */ 6886 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val); 6887 if (err < 0) 6888 return err; 6889 *vol_bits |= (1 << nid_vol); 6890 } 6891 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val); 6892 if (err < 0) 6893 return err; 6894 return 1; 6895} 6896 6897/* add playback controls from the parsed DAC table */ 6898static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec, 6899 const struct auto_pin_cfg *cfg) 6900{ 6901 hda_nid_t nid; 6902 int err; 6903 int vols = 0; 6904 6905 spec->multiout.num_dacs = 1; 6906 spec->multiout.dac_nids = spec->private_dac_nids; 6907 spec->multiout.dac_nids[0] = 0x02; 6908 6909 nid = cfg->line_out_pins[0]; 6910 if (nid) { 6911 const char *pfx; 6912 if (!cfg->speaker_pins[0] && !cfg->hp_pins[0]) 6913 pfx = "Master"; 6914 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) 6915 pfx = "Speaker"; 6916 else 6917 pfx = "Front"; 6918 err = alc260_add_playback_controls(spec, nid, pfx, &vols); 6919 if (err < 0) 6920 return err; 6921 } 6922 6923 nid = cfg->speaker_pins[0]; 6924 if (nid) { 6925 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols); 6926 if (err < 0) 6927 return err; 6928 } 6929 6930 nid = cfg->hp_pins[0]; 6931 if (nid) { 6932 err = alc260_add_playback_controls(spec, nid, "Headphone", 6933 &vols); 6934 if (err < 0) 6935 return err; 6936 } 6937 return 0; 6938} 6939 6940/* create playback/capture controls for input pins */ 6941static int alc260_auto_create_input_ctls(struct hda_codec *codec, 6942 const struct auto_pin_cfg *cfg) 6943{ 6944 return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05); 6945} 6946 6947static void alc260_auto_set_output_and_unmute(struct hda_codec *codec, 6948 hda_nid_t nid, int pin_type, 6949 int sel_idx) 6950{ 6951 alc_set_pin_output(codec, nid, pin_type); 6952 /* need the manual connection? */ 6953 if (nid >= 0x12) { 6954 int idx = nid - 0x12; 6955 snd_hda_codec_write(codec, idx + 0x0b, 0, 6956 AC_VERB_SET_CONNECT_SEL, sel_idx); 6957 } 6958} 6959 6960static void alc260_auto_init_multi_out(struct hda_codec *codec) 6961{ 6962 struct alc_spec *spec = codec->spec; 6963 hda_nid_t nid; 6964 6965 nid = spec->autocfg.line_out_pins[0]; 6966 if (nid) { 6967 int pin_type = get_pin_type(spec->autocfg.line_out_type); 6968 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0); 6969 } 6970 6971 nid = spec->autocfg.speaker_pins[0]; 6972 if (nid) 6973 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0); 6974 6975 nid = spec->autocfg.hp_pins[0]; 6976 if (nid) 6977 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0); 6978} 6979 6980#define ALC260_PIN_CD_NID 0x16 6981static void alc260_auto_init_analog_input(struct hda_codec *codec) 6982{ 6983 struct alc_spec *spec = codec->spec; 6984 struct auto_pin_cfg *cfg = &spec->autocfg; 6985 int i; 6986 6987 for (i = 0; i < cfg->num_inputs; i++) { 6988 hda_nid_t nid = cfg->inputs[i].pin; 6989 if (nid >= 0x12) { 6990 alc_set_input_pin(codec, nid, cfg->inputs[i].type); 6991 if (nid != ALC260_PIN_CD_NID && 6992 (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)) 6993 snd_hda_codec_write(codec, nid, 0, 6994 AC_VERB_SET_AMP_GAIN_MUTE, 6995 AMP_OUT_MUTE); 6996 } 6997 } 6998} 6999 7000#define alc260_auto_init_input_src alc880_auto_init_input_src 7001 7002/* 7003 * generic initialization of ADC, input mixers and output mixers 7004 */ 7005static struct hda_verb alc260_volume_init_verbs[] = { 7006 /* 7007 * Unmute ADC0-1 and set the default input to mic-in 7008 */ 7009 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00}, 7010 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7011 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00}, 7012 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7013 7014 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 7015 * mixer widget 7016 * Note: PASD motherboards uses the Line In 2 as the input for 7017 * front panel mic (mic 2) 7018 */ 7019 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 7020 /* mute analog inputs */ 7021 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7022 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7023 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 7024 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 7025 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 7026 7027 /* 7028 * Set up output mixers (0x08 - 0x0a) 7029 */ 7030 /* set vol=0 to output mixers */ 7031 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7032 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7033 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7034 /* set up input amps for analog loopback */ 7035 /* Amp Indices: DAC = 0, mixer = 1 */ 7036 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7037 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7038 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7039 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7040 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7041 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7042 7043 { } 7044}; 7045 7046static int alc260_parse_auto_config(struct hda_codec *codec) 7047{ 7048 struct alc_spec *spec = codec->spec; 7049 int err; 7050 static hda_nid_t alc260_ignore[] = { 0x17, 0 }; 7051 7052 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 7053 alc260_ignore); 7054 if (err < 0) 7055 return err; 7056 err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg); 7057 if (err < 0) 7058 return err; 7059 if (!spec->kctls.list) 7060 return 0; /* can't find valid BIOS pin config */ 7061 err = alc260_auto_create_input_ctls(codec, &spec->autocfg); 7062 if (err < 0) 7063 return err; 7064 7065 spec->multiout.max_channels = 2; 7066 7067 if (spec->autocfg.dig_outs) 7068 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID; 7069 if (spec->kctls.list) 7070 add_mixer(spec, spec->kctls.list); 7071 7072 add_verb(spec, alc260_volume_init_verbs); 7073 7074 spec->num_mux_defs = 1; 7075 spec->input_mux = &spec->private_imux[0]; 7076 7077 alc_ssid_check(codec, 0x10, 0x15, 0x0f, 0); 7078 7079 return 1; 7080} 7081 7082/* additional initialization for auto-configuration model */ 7083static void alc260_auto_init(struct hda_codec *codec) 7084{ 7085 struct alc_spec *spec = codec->spec; 7086 alc260_auto_init_multi_out(codec); 7087 alc260_auto_init_analog_input(codec); 7088 alc260_auto_init_input_src(codec); 7089 alc_auto_init_digital(codec); 7090 if (spec->unsol_event) 7091 alc_inithook(codec); 7092} 7093 7094#ifdef CONFIG_SND_HDA_POWER_SAVE 7095static struct hda_amp_list alc260_loopbacks[] = { 7096 { 0x07, HDA_INPUT, 0 }, 7097 { 0x07, HDA_INPUT, 1 }, 7098 { 0x07, HDA_INPUT, 2 }, 7099 { 0x07, HDA_INPUT, 3 }, 7100 { 0x07, HDA_INPUT, 4 }, 7101 { } /* end */ 7102}; 7103#endif 7104 7105/* 7106 * Pin config fixes 7107 */ 7108enum { 7109 PINFIX_HP_DC5750, 7110}; 7111 7112static const struct alc_fixup alc260_fixups[] = { 7113 [PINFIX_HP_DC5750] = { 7114 .type = ALC_FIXUP_PINS, 7115 .v.pins = (const struct alc_pincfg[]) { 7116 { 0x11, 0x90130110 }, /* speaker */ 7117 { } 7118 } 7119 }, 7120}; 7121 7122static struct snd_pci_quirk alc260_fixup_tbl[] = { 7123 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750), 7124 {} 7125}; 7126 7127/* 7128 * ALC260 configurations 7129 */ 7130static const char * const alc260_models[ALC260_MODEL_LAST] = { 7131 [ALC260_BASIC] = "basic", 7132 [ALC260_HP] = "hp", 7133 [ALC260_HP_3013] = "hp-3013", 7134 [ALC260_HP_DC7600] = "hp-dc7600", 7135 [ALC260_FUJITSU_S702X] = "fujitsu", 7136 [ALC260_ACER] = "acer", 7137 [ALC260_WILL] = "will", 7138 [ALC260_REPLACER_672V] = "replacer", 7139 [ALC260_FAVORIT100] = "favorit100", 7140#ifdef CONFIG_SND_DEBUG 7141 [ALC260_TEST] = "test", 7142#endif 7143 [ALC260_AUTO] = "auto", 7144}; 7145 7146static struct snd_pci_quirk alc260_cfg_tbl[] = { 7147 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER), 7148 SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL), 7149 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER), 7150 SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100), 7151 SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013), 7152 SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_AUTO), /* no quirk */ 7153 SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013), 7154 SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013), 7155 SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600), 7156 SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013), 7157 SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP), 7158 SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP), 7159 SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP), 7160 SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC), 7161 SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC), 7162 SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC), 7163 SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X), 7164 SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC), 7165 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V), 7166 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL), 7167 {} 7168}; 7169 7170static struct alc_config_preset alc260_presets[] = { 7171 [ALC260_BASIC] = { 7172 .mixers = { alc260_base_output_mixer, 7173 alc260_input_mixer }, 7174 .init_verbs = { alc260_init_verbs }, 7175 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 7176 .dac_nids = alc260_dac_nids, 7177 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids), 7178 .adc_nids = alc260_dual_adc_nids, 7179 .num_channel_mode = ARRAY_SIZE(alc260_modes), 7180 .channel_mode = alc260_modes, 7181 .input_mux = &alc260_capture_source, 7182 }, 7183 [ALC260_HP] = { 7184 .mixers = { alc260_hp_output_mixer, 7185 alc260_input_mixer }, 7186 .init_verbs = { alc260_init_verbs, 7187 alc260_hp_unsol_verbs }, 7188 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 7189 .dac_nids = alc260_dac_nids, 7190 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt), 7191 .adc_nids = alc260_adc_nids_alt, 7192 .num_channel_mode = ARRAY_SIZE(alc260_modes), 7193 .channel_mode = alc260_modes, 7194 .input_mux = &alc260_capture_source, 7195 .unsol_event = alc260_hp_unsol_event, 7196 .init_hook = alc260_hp_automute, 7197 }, 7198 [ALC260_HP_DC7600] = { 7199 .mixers = { alc260_hp_dc7600_mixer, 7200 alc260_input_mixer }, 7201 .init_verbs = { alc260_init_verbs, 7202 alc260_hp_dc7600_verbs }, 7203 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 7204 .dac_nids = alc260_dac_nids, 7205 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt), 7206 .adc_nids = alc260_adc_nids_alt, 7207 .num_channel_mode = ARRAY_SIZE(alc260_modes), 7208 .channel_mode = alc260_modes, 7209 .input_mux = &alc260_capture_source, 7210 .unsol_event = alc260_hp_3012_unsol_event, 7211 .init_hook = alc260_hp_3012_automute, 7212 }, 7213 [ALC260_HP_3013] = { 7214 .mixers = { alc260_hp_3013_mixer, 7215 alc260_input_mixer }, 7216 .init_verbs = { alc260_hp_3013_init_verbs, 7217 alc260_hp_3013_unsol_verbs }, 7218 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 7219 .dac_nids = alc260_dac_nids, 7220 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt), 7221 .adc_nids = alc260_adc_nids_alt, 7222 .num_channel_mode = ARRAY_SIZE(alc260_modes), 7223 .channel_mode = alc260_modes, 7224 .input_mux = &alc260_capture_source, 7225 .unsol_event = alc260_hp_3013_unsol_event, 7226 .init_hook = alc260_hp_3013_automute, 7227 }, 7228 [ALC260_FUJITSU_S702X] = { 7229 .mixers = { alc260_fujitsu_mixer }, 7230 .init_verbs = { alc260_fujitsu_init_verbs }, 7231 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 7232 .dac_nids = alc260_dac_nids, 7233 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids), 7234 .adc_nids = alc260_dual_adc_nids, 7235 .num_channel_mode = ARRAY_SIZE(alc260_modes), 7236 .channel_mode = alc260_modes, 7237 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources), 7238 .input_mux = alc260_fujitsu_capture_sources, 7239 }, 7240 [ALC260_ACER] = { 7241 .mixers = { alc260_acer_mixer }, 7242 .init_verbs = { alc260_acer_init_verbs }, 7243 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 7244 .dac_nids = alc260_dac_nids, 7245 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids), 7246 .adc_nids = alc260_dual_adc_nids, 7247 .num_channel_mode = ARRAY_SIZE(alc260_modes), 7248 .channel_mode = alc260_modes, 7249 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources), 7250 .input_mux = alc260_acer_capture_sources, 7251 }, 7252 [ALC260_FAVORIT100] = { 7253 .mixers = { alc260_favorit100_mixer }, 7254 .init_verbs = { alc260_favorit100_init_verbs }, 7255 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 7256 .dac_nids = alc260_dac_nids, 7257 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids), 7258 .adc_nids = alc260_dual_adc_nids, 7259 .num_channel_mode = ARRAY_SIZE(alc260_modes), 7260 .channel_mode = alc260_modes, 7261 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources), 7262 .input_mux = alc260_favorit100_capture_sources, 7263 }, 7264 [ALC260_WILL] = { 7265 .mixers = { alc260_will_mixer }, 7266 .init_verbs = { alc260_init_verbs, alc260_will_verbs }, 7267 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 7268 .dac_nids = alc260_dac_nids, 7269 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids), 7270 .adc_nids = alc260_adc_nids, 7271 .dig_out_nid = ALC260_DIGOUT_NID, 7272 .num_channel_mode = ARRAY_SIZE(alc260_modes), 7273 .channel_mode = alc260_modes, 7274 .input_mux = &alc260_capture_source, 7275 }, 7276 [ALC260_REPLACER_672V] = { 7277 .mixers = { alc260_replacer_672v_mixer }, 7278 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs }, 7279 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 7280 .dac_nids = alc260_dac_nids, 7281 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids), 7282 .adc_nids = alc260_adc_nids, 7283 .dig_out_nid = ALC260_DIGOUT_NID, 7284 .num_channel_mode = ARRAY_SIZE(alc260_modes), 7285 .channel_mode = alc260_modes, 7286 .input_mux = &alc260_capture_source, 7287 .unsol_event = alc260_replacer_672v_unsol_event, 7288 .init_hook = alc260_replacer_672v_automute, 7289 }, 7290#ifdef CONFIG_SND_DEBUG 7291 [ALC260_TEST] = { 7292 .mixers = { alc260_test_mixer }, 7293 .init_verbs = { alc260_test_init_verbs }, 7294 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids), 7295 .dac_nids = alc260_test_dac_nids, 7296 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids), 7297 .adc_nids = alc260_test_adc_nids, 7298 .num_channel_mode = ARRAY_SIZE(alc260_modes), 7299 .channel_mode = alc260_modes, 7300 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources), 7301 .input_mux = alc260_test_capture_sources, 7302 }, 7303#endif 7304}; 7305 7306static int patch_alc260(struct hda_codec *codec) 7307{ 7308 struct alc_spec *spec; 7309 int err, board_config; 7310 7311 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 7312 if (spec == NULL) 7313 return -ENOMEM; 7314 7315 codec->spec = spec; 7316 7317 board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST, 7318 alc260_models, 7319 alc260_cfg_tbl); 7320 if (board_config < 0) { 7321 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 7322 codec->chip_name); 7323 board_config = ALC260_AUTO; 7324 } 7325 7326 if (board_config == ALC260_AUTO) { 7327 alc_pick_fixup(codec, NULL, alc260_fixup_tbl, alc260_fixups); 7328 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE); 7329 } 7330 7331 if (board_config == ALC260_AUTO) { 7332 /* automatic parse from the BIOS config */ 7333 err = alc260_parse_auto_config(codec); 7334 if (err < 0) { 7335 alc_free(codec); 7336 return err; 7337 } else if (!err) { 7338 printk(KERN_INFO 7339 "hda_codec: Cannot set up configuration " 7340 "from BIOS. Using base mode...\n"); 7341 board_config = ALC260_BASIC; 7342 } 7343 } 7344 7345 err = snd_hda_attach_beep_device(codec, 0x1); 7346 if (err < 0) { 7347 alc_free(codec); 7348 return err; 7349 } 7350 7351 if (board_config != ALC260_AUTO) 7352 setup_preset(codec, &alc260_presets[board_config]); 7353 7354 spec->stream_analog_playback = &alc260_pcm_analog_playback; 7355 spec->stream_analog_capture = &alc260_pcm_analog_capture; 7356 spec->stream_analog_alt_capture = &alc260_pcm_analog_capture; 7357 7358 spec->stream_digital_playback = &alc260_pcm_digital_playback; 7359 spec->stream_digital_capture = &alc260_pcm_digital_capture; 7360 7361 if (!spec->adc_nids && spec->input_mux) { 7362 /* check whether NID 0x04 is valid */ 7363 unsigned int wcap = get_wcaps(codec, 0x04); 7364 wcap = get_wcaps_type(wcap); 7365 /* get type */ 7366 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) { 7367 spec->adc_nids = alc260_adc_nids_alt; 7368 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt); 7369 } else { 7370 spec->adc_nids = alc260_adc_nids; 7371 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids); 7372 } 7373 } 7374 set_capture_mixer(codec); 7375 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT); 7376 7377 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE); 7378 7379 spec->vmaster_nid = 0x08; 7380 7381 codec->patch_ops = alc_patch_ops; 7382 if (board_config == ALC260_AUTO) 7383 spec->init_hook = alc260_auto_init; 7384#ifdef CONFIG_SND_HDA_POWER_SAVE 7385 if (!spec->loopback.amplist) 7386 spec->loopback.amplist = alc260_loopbacks; 7387#endif 7388 7389 return 0; 7390} 7391 7392 7393/* 7394 * ALC882/883/885/888/889 support 7395 * 7396 * ALC882 is almost identical with ALC880 but has cleaner and more flexible 7397 * configuration. Each pin widget can choose any input DACs and a mixer. 7398 * Each ADC is connected from a mixer of all inputs. This makes possible 7399 * 6-channel independent captures. 7400 * 7401 * In addition, an independent DAC for the multi-playback (not used in this 7402 * driver yet). 7403 */ 7404#define ALC882_DIGOUT_NID 0x06 7405#define ALC882_DIGIN_NID 0x0a 7406#define ALC883_DIGOUT_NID ALC882_DIGOUT_NID 7407#define ALC883_DIGIN_NID ALC882_DIGIN_NID 7408#define ALC1200_DIGOUT_NID 0x10 7409 7410 7411static struct hda_channel_mode alc882_ch_modes[1] = { 7412 { 8, NULL } 7413}; 7414 7415/* DACs */ 7416static hda_nid_t alc882_dac_nids[4] = { 7417 /* front, rear, clfe, rear_surr */ 7418 0x02, 0x03, 0x04, 0x05 7419}; 7420#define alc883_dac_nids alc882_dac_nids 7421 7422/* ADCs */ 7423#define alc882_adc_nids alc880_adc_nids 7424#define alc882_adc_nids_alt alc880_adc_nids_alt 7425#define alc883_adc_nids alc882_adc_nids_alt 7426static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 }; 7427static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 }; 7428#define alc889_adc_nids alc880_adc_nids 7429 7430static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 }; 7431static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 }; 7432#define alc883_capsrc_nids alc882_capsrc_nids_alt 7433static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 }; 7434#define alc889_capsrc_nids alc882_capsrc_nids 7435 7436/* input MUX */ 7437/* FIXME: should be a matrix-type input source selection */ 7438 7439static struct hda_input_mux alc882_capture_source = { 7440 .num_items = 4, 7441 .items = { 7442 { "Mic", 0x0 }, 7443 { "Front Mic", 0x1 }, 7444 { "Line", 0x2 }, 7445 { "CD", 0x4 }, 7446 }, 7447}; 7448 7449#define alc883_capture_source alc882_capture_source 7450 7451static struct hda_input_mux alc889_capture_source = { 7452 .num_items = 3, 7453 .items = { 7454 { "Front Mic", 0x0 }, 7455 { "Mic", 0x3 }, 7456 { "Line", 0x2 }, 7457 }, 7458}; 7459 7460static struct hda_input_mux mb5_capture_source = { 7461 .num_items = 3, 7462 .items = { 7463 { "Mic", 0x1 }, 7464 { "Line", 0x7 }, 7465 { "CD", 0x4 }, 7466 }, 7467}; 7468 7469static struct hda_input_mux macmini3_capture_source = { 7470 .num_items = 2, 7471 .items = { 7472 { "Line", 0x2 }, 7473 { "CD", 0x4 }, 7474 }, 7475}; 7476 7477static struct hda_input_mux alc883_3stack_6ch_intel = { 7478 .num_items = 4, 7479 .items = { 7480 { "Mic", 0x1 }, 7481 { "Front Mic", 0x0 }, 7482 { "Line", 0x2 }, 7483 { "CD", 0x4 }, 7484 }, 7485}; 7486 7487static struct hda_input_mux alc883_lenovo_101e_capture_source = { 7488 .num_items = 2, 7489 .items = { 7490 { "Mic", 0x1 }, 7491 { "Line", 0x2 }, 7492 }, 7493}; 7494 7495static struct hda_input_mux alc883_lenovo_nb0763_capture_source = { 7496 .num_items = 4, 7497 .items = { 7498 { "Mic", 0x0 }, 7499 { "Internal Mic", 0x1 }, 7500 { "Line", 0x2 }, 7501 { "CD", 0x4 }, 7502 }, 7503}; 7504 7505static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = { 7506 .num_items = 2, 7507 .items = { 7508 { "Mic", 0x0 }, 7509 { "Internal Mic", 0x1 }, 7510 }, 7511}; 7512 7513static struct hda_input_mux alc883_lenovo_sky_capture_source = { 7514 .num_items = 3, 7515 .items = { 7516 { "Mic", 0x0 }, 7517 { "Front Mic", 0x1 }, 7518 { "Line", 0x4 }, 7519 }, 7520}; 7521 7522static struct hda_input_mux alc883_asus_eee1601_capture_source = { 7523 .num_items = 2, 7524 .items = { 7525 { "Mic", 0x0 }, 7526 { "Line", 0x2 }, 7527 }, 7528}; 7529 7530static struct hda_input_mux alc889A_mb31_capture_source = { 7531 .num_items = 2, 7532 .items = { 7533 { "Mic", 0x0 }, 7534 /* Front Mic (0x01) unused */ 7535 { "Line", 0x2 }, 7536 /* Line 2 (0x03) unused */ 7537 /* CD (0x04) unused? */ 7538 }, 7539}; 7540 7541static struct hda_input_mux alc889A_imac91_capture_source = { 7542 .num_items = 2, 7543 .items = { 7544 { "Mic", 0x01 }, 7545 { "Line", 0x2 }, /* Not sure! */ 7546 }, 7547}; 7548 7549/* 7550 * 2ch mode 7551 */ 7552static struct hda_channel_mode alc883_3ST_2ch_modes[1] = { 7553 { 2, NULL } 7554}; 7555 7556/* 7557 * 2ch mode 7558 */ 7559static struct hda_verb alc882_3ST_ch2_init[] = { 7560 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 7561 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7562 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 7563 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7564 { } /* end */ 7565}; 7566 7567/* 7568 * 4ch mode 7569 */ 7570static struct hda_verb alc882_3ST_ch4_init[] = { 7571 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 7572 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7573 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7574 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7575 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 7576 { } /* end */ 7577}; 7578 7579/* 7580 * 6ch mode 7581 */ 7582static struct hda_verb alc882_3ST_ch6_init[] = { 7583 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7584 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7585 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 }, 7586 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7587 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7588 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 7589 { } /* end */ 7590}; 7591 7592static struct hda_channel_mode alc882_3ST_6ch_modes[3] = { 7593 { 2, alc882_3ST_ch2_init }, 7594 { 4, alc882_3ST_ch4_init }, 7595 { 6, alc882_3ST_ch6_init }, 7596}; 7597 7598#define alc883_3ST_6ch_modes alc882_3ST_6ch_modes 7599 7600/* 7601 * 2ch mode 7602 */ 7603static struct hda_verb alc883_3ST_ch2_clevo_init[] = { 7604 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, 7605 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 7606 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7607 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 7608 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7609 { } /* end */ 7610}; 7611 7612/* 7613 * 4ch mode 7614 */ 7615static struct hda_verb alc883_3ST_ch4_clevo_init[] = { 7616 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7617 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 7618 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7619 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7620 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7621 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 7622 { } /* end */ 7623}; 7624 7625/* 7626 * 6ch mode 7627 */ 7628static struct hda_verb alc883_3ST_ch6_clevo_init[] = { 7629 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7630 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7631 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7632 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 }, 7633 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7634 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7635 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 7636 { } /* end */ 7637}; 7638 7639static struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = { 7640 { 2, alc883_3ST_ch2_clevo_init }, 7641 { 4, alc883_3ST_ch4_clevo_init }, 7642 { 6, alc883_3ST_ch6_clevo_init }, 7643}; 7644 7645 7646/* 7647 * 6ch mode 7648 */ 7649static struct hda_verb alc882_sixstack_ch6_init[] = { 7650 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 7651 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7652 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7653 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7654 { } /* end */ 7655}; 7656 7657/* 7658 * 8ch mode 7659 */ 7660static struct hda_verb alc882_sixstack_ch8_init[] = { 7661 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7662 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7663 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7664 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7665 { } /* end */ 7666}; 7667 7668static struct hda_channel_mode alc882_sixstack_modes[2] = { 7669 { 6, alc882_sixstack_ch6_init }, 7670 { 8, alc882_sixstack_ch8_init }, 7671}; 7672 7673 7674/* Macbook Air 2,1 */ 7675 7676static struct hda_channel_mode alc885_mba21_ch_modes[1] = { 7677 { 2, NULL }, 7678}; 7679 7680/* 7681 * macbook pro ALC885 can switch LineIn to LineOut without losing Mic 7682 */ 7683 7684/* 7685 * 2ch mode 7686 */ 7687static struct hda_verb alc885_mbp_ch2_init[] = { 7688 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 7689 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7690 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7691 { } /* end */ 7692}; 7693 7694/* 7695 * 4ch mode 7696 */ 7697static struct hda_verb alc885_mbp_ch4_init[] = { 7698 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7699 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7700 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 7701 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7702 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7703 { } /* end */ 7704}; 7705 7706static struct hda_channel_mode alc885_mbp_4ch_modes[2] = { 7707 { 2, alc885_mbp_ch2_init }, 7708 { 4, alc885_mbp_ch4_init }, 7709}; 7710 7711/* 7712 * 2ch 7713 * Speakers/Woofer/HP = Front 7714 * LineIn = Input 7715 */ 7716static struct hda_verb alc885_mb5_ch2_init[] = { 7717 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 7718 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 7719 { } /* end */ 7720}; 7721 7722/* 7723 * 6ch mode 7724 * Speakers/HP = Front 7725 * Woofer = LFE 7726 * LineIn = Surround 7727 */ 7728static struct hda_verb alc885_mb5_ch6_init[] = { 7729 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7730 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7731 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 7732 { } /* end */ 7733}; 7734 7735static struct hda_channel_mode alc885_mb5_6ch_modes[2] = { 7736 { 2, alc885_mb5_ch2_init }, 7737 { 6, alc885_mb5_ch6_init }, 7738}; 7739 7740#define alc885_macmini3_6ch_modes alc885_mb5_6ch_modes 7741 7742/* 7743 * 2ch mode 7744 */ 7745static struct hda_verb alc883_4ST_ch2_init[] = { 7746 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7747 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7748 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 7749 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7750 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 7751 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7752 { } /* end */ 7753}; 7754 7755/* 7756 * 4ch mode 7757 */ 7758static struct hda_verb alc883_4ST_ch4_init[] = { 7759 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7760 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7761 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 7762 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7763 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7764 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7765 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 7766 { } /* end */ 7767}; 7768 7769/* 7770 * 6ch mode 7771 */ 7772static struct hda_verb alc883_4ST_ch6_init[] = { 7773 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7774 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7775 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7776 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7777 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 }, 7778 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7779 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7780 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 7781 { } /* end */ 7782}; 7783 7784/* 7785 * 8ch mode 7786 */ 7787static struct hda_verb alc883_4ST_ch8_init[] = { 7788 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7789 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7790 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 }, 7791 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7792 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7793 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 }, 7794 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7795 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7796 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 7797 { } /* end */ 7798}; 7799 7800static struct hda_channel_mode alc883_4ST_8ch_modes[4] = { 7801 { 2, alc883_4ST_ch2_init }, 7802 { 4, alc883_4ST_ch4_init }, 7803 { 6, alc883_4ST_ch6_init }, 7804 { 8, alc883_4ST_ch8_init }, 7805}; 7806 7807 7808/* 7809 * 2ch mode 7810 */ 7811static struct hda_verb alc883_3ST_ch2_intel_init[] = { 7812 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 7813 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7814 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 7815 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7816 { } /* end */ 7817}; 7818 7819/* 7820 * 4ch mode 7821 */ 7822static struct hda_verb alc883_3ST_ch4_intel_init[] = { 7823 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 7824 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7825 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7826 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7827 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 7828 { } /* end */ 7829}; 7830 7831/* 7832 * 6ch mode 7833 */ 7834static struct hda_verb alc883_3ST_ch6_intel_init[] = { 7835 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7836 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7837 { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 }, 7838 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7839 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7840 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 7841 { } /* end */ 7842}; 7843 7844static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = { 7845 { 2, alc883_3ST_ch2_intel_init }, 7846 { 4, alc883_3ST_ch4_intel_init }, 7847 { 6, alc883_3ST_ch6_intel_init }, 7848}; 7849 7850/* 7851 * 2ch mode 7852 */ 7853static struct hda_verb alc889_ch2_intel_init[] = { 7854 { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 }, 7855 { 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 }, 7856 { 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 }, 7857 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 }, 7858 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 7859 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7860 { } /* end */ 7861}; 7862 7863/* 7864 * 6ch mode 7865 */ 7866static struct hda_verb alc889_ch6_intel_init[] = { 7867 { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 }, 7868 { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 }, 7869 { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 }, 7870 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 }, 7871 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 7872 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7873 { } /* end */ 7874}; 7875 7876/* 7877 * 8ch mode 7878 */ 7879static struct hda_verb alc889_ch8_intel_init[] = { 7880 { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 }, 7881 { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 }, 7882 { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 }, 7883 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 }, 7884 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 }, 7885 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7886 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7887 { } /* end */ 7888}; 7889 7890static struct hda_channel_mode alc889_8ch_intel_modes[3] = { 7891 { 2, alc889_ch2_intel_init }, 7892 { 6, alc889_ch6_intel_init }, 7893 { 8, alc889_ch8_intel_init }, 7894}; 7895 7896/* 7897 * 6ch mode 7898 */ 7899static struct hda_verb alc883_sixstack_ch6_init[] = { 7900 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 7901 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7902 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7903 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7904 { } /* end */ 7905}; 7906 7907/* 7908 * 8ch mode 7909 */ 7910static struct hda_verb alc883_sixstack_ch8_init[] = { 7911 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7912 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7913 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7914 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7915 { } /* end */ 7916}; 7917 7918static struct hda_channel_mode alc883_sixstack_modes[2] = { 7919 { 6, alc883_sixstack_ch6_init }, 7920 { 8, alc883_sixstack_ch8_init }, 7921}; 7922 7923 7924/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17 7925 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b 7926 */ 7927static struct snd_kcontrol_new alc882_base_mixer[] = { 7928 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7929 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7930 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7931 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 7932 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 7933 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 7934 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 7935 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 7936 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 7937 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 7938 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7939 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7940 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7941 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7942 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7943 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7944 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 7945 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7946 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7947 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT), 7948 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7949 { } /* end */ 7950}; 7951 7952/* Macbook Air 2,1 same control for HP and internal Speaker */ 7953 7954static struct snd_kcontrol_new alc885_mba21_mixer[] = { 7955 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT), 7956 HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_OUTPUT), 7957 { } 7958}; 7959 7960 7961static struct snd_kcontrol_new alc885_mbp3_mixer[] = { 7962 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT), 7963 HDA_BIND_MUTE ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT), 7964 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT), 7965 HDA_BIND_MUTE ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT), 7966 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT), 7967 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7968 HDA_CODEC_MUTE ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7969 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT), 7970 HDA_CODEC_MUTE ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT), 7971 HDA_CODEC_VOLUME("Line Boost Volume", 0x1a, 0x00, HDA_INPUT), 7972 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0x00, HDA_INPUT), 7973 { } /* end */ 7974}; 7975 7976static struct snd_kcontrol_new alc885_mb5_mixer[] = { 7977 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT), 7978 HDA_BIND_MUTE ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT), 7979 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT), 7980 HDA_BIND_MUTE ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT), 7981 HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT), 7982 HDA_BIND_MUTE ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT), 7983 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT), 7984 HDA_BIND_MUTE ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT), 7985 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT), 7986 HDA_CODEC_MUTE ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT), 7987 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 7988 HDA_CODEC_MUTE ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 7989 HDA_CODEC_VOLUME("Line Boost Volume", 0x15, 0x00, HDA_INPUT), 7990 HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0x00, HDA_INPUT), 7991 { } /* end */ 7992}; 7993 7994static struct snd_kcontrol_new alc885_macmini3_mixer[] = { 7995 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT), 7996 HDA_BIND_MUTE ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT), 7997 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT), 7998 HDA_BIND_MUTE ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT), 7999 HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT), 8000 HDA_BIND_MUTE ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT), 8001 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT), 8002 HDA_BIND_MUTE ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT), 8003 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT), 8004 HDA_CODEC_MUTE ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT), 8005 HDA_CODEC_VOLUME("Line Boost Volume", 0x15, 0x00, HDA_INPUT), 8006 { } /* end */ 8007}; 8008 8009static struct snd_kcontrol_new alc885_imac91_mixer[] = { 8010 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT), 8011 HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT), 8012 { } /* end */ 8013}; 8014 8015 8016static struct snd_kcontrol_new alc882_w2jc_mixer[] = { 8017 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8018 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 8019 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 8020 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 8021 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 8022 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 8023 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8024 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 8025 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8026 { } /* end */ 8027}; 8028 8029static struct snd_kcontrol_new alc882_targa_mixer[] = { 8030 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8031 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 8032 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 8033 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 8034 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 8035 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 8036 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 8037 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8038 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8039 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 8040 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 8041 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 8042 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT), 8043 { } /* end */ 8044}; 8045 8046/* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ??? 8047 * Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c 8048 */ 8049static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = { 8050 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8051 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 8052 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 8053 HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT), 8054 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 8055 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 8056 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 8057 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 8058 HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT), 8059 HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT), 8060 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8061 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8062 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 8063 { } /* end */ 8064}; 8065 8066static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = { 8067 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8068 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 8069 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 8070 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 8071 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 8072 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 8073 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 8074 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8075 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 8076 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8077 { } /* end */ 8078}; 8079 8080static struct snd_kcontrol_new alc882_chmode_mixer[] = { 8081 { 8082 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 8083 .name = "Channel Mode", 8084 .info = alc_ch_mode_info, 8085 .get = alc_ch_mode_get, 8086 .put = alc_ch_mode_put, 8087 }, 8088 { } /* end */ 8089}; 8090 8091static struct hda_verb alc882_base_init_verbs[] = { 8092 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 8093 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8094 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8095 /* Rear mixer */ 8096 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8097 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8098 /* CLFE mixer */ 8099 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8100 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8101 /* Side mixer */ 8102 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8103 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8104 8105 /* Front Pin: output 0 (0x0c) */ 8106 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8107 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8108 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 8109 /* Rear Pin: output 1 (0x0d) */ 8110 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8111 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8112 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 8113 /* CLFE Pin: output 2 (0x0e) */ 8114 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8115 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8116 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02}, 8117 /* Side Pin: output 3 (0x0f) */ 8118 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8119 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8120 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 8121 /* Mic (rear) pin: input vref at 80% */ 8122 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 8123 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 8124 /* Front Mic pin: input vref at 80% */ 8125 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 8126 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 8127 /* Line In pin: input */ 8128 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 8129 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 8130 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 8131 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8132 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8133 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 8134 /* CD pin widget for input */ 8135 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 8136 8137 /* FIXME: use matrix-type input source selection */ 8138 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 8139 /* Input mixer2 */ 8140 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8141 /* Input mixer3 */ 8142 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8143 /* ADC2: mute amp left and right */ 8144 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8145 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 8146 /* ADC3: mute amp left and right */ 8147 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8148 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 8149 8150 { } 8151}; 8152 8153static struct hda_verb alc882_adc1_init_verbs[] = { 8154 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 8155 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8156 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 8157 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 8158 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 8159 /* ADC1: mute amp left and right */ 8160 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8161 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 8162 { } 8163}; 8164 8165static struct hda_verb alc882_eapd_verbs[] = { 8166 /* change to EAPD mode */ 8167 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 8168 {0x20, AC_VERB_SET_PROC_COEF, 0x3060}, 8169 { } 8170}; 8171 8172static struct hda_verb alc889_eapd_verbs[] = { 8173 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 8174 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 8175 { } 8176}; 8177 8178static struct hda_verb alc_hp15_unsol_verbs[] = { 8179 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 8180 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8181 {} 8182}; 8183 8184static struct hda_verb alc885_init_verbs[] = { 8185 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 8186 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8187 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8188 /* Rear mixer */ 8189 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8190 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8191 /* CLFE mixer */ 8192 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8193 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8194 /* Side mixer */ 8195 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8196 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8197 8198 /* Front HP Pin: output 0 (0x0c) */ 8199 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8200 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8201 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 8202 /* Front Pin: output 0 (0x0c) */ 8203 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8204 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8205 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 8206 /* Rear Pin: output 1 (0x0d) */ 8207 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8208 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8209 {0x19, AC_VERB_SET_CONNECT_SEL, 0x01}, 8210 /* CLFE Pin: output 2 (0x0e) */ 8211 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8212 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8213 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02}, 8214 /* Side Pin: output 3 (0x0f) */ 8215 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8216 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8217 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 8218 /* Mic (rear) pin: input vref at 80% */ 8219 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 8220 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 8221 /* Front Mic pin: input vref at 80% */ 8222 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 8223 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 8224 /* Line In pin: input */ 8225 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 8226 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 8227 8228 /* Mixer elements: 0x18, , 0x1a, 0x1b */ 8229 /* Input mixer1 */ 8230 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8231 /* Input mixer2 */ 8232 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8233 /* Input mixer3 */ 8234 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8235 /* ADC2: mute amp left and right */ 8236 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8237 /* ADC3: mute amp left and right */ 8238 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8239 8240 { } 8241}; 8242 8243static struct hda_verb alc885_init_input_verbs[] = { 8244 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8245 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 8246 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 8247 { } 8248}; 8249 8250 8251/* Unmute Selector 24h and set the default input to front mic */ 8252static struct hda_verb alc889_init_input_verbs[] = { 8253 {0x24, AC_VERB_SET_CONNECT_SEL, 0x00}, 8254 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8255 { } 8256}; 8257 8258 8259#define alc883_init_verbs alc882_base_init_verbs 8260 8261/* Mac Pro test */ 8262static struct snd_kcontrol_new alc882_macpro_mixer[] = { 8263 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8264 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 8265 HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT), 8266 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT), 8267 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT), 8268 /* FIXME: this looks suspicious... 8269 HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT), 8270 HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT), 8271 */ 8272 { } /* end */ 8273}; 8274 8275static struct hda_verb alc882_macpro_init_verbs[] = { 8276 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 8277 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8278 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8279 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8280 /* Front Pin: output 0 (0x0c) */ 8281 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8282 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8283 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 8284 /* Front Mic pin: input vref at 80% */ 8285 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 8286 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 8287 /* Speaker: output */ 8288 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8289 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8290 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04}, 8291 /* Headphone output (output 0 - 0x0c) */ 8292 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8293 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8294 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00}, 8295 8296 /* FIXME: use matrix-type input source selection */ 8297 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 8298 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 8299 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8300 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 8301 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 8302 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 8303 /* Input mixer2 */ 8304 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8305 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 8306 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 8307 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 8308 /* Input mixer3 */ 8309 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8310 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 8311 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 8312 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 8313 /* ADC1: mute amp left and right */ 8314 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8315 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 8316 /* ADC2: mute amp left and right */ 8317 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8318 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 8319 /* ADC3: mute amp left and right */ 8320 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8321 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 8322 8323 { } 8324}; 8325 8326/* Macbook 5,1 */ 8327static struct hda_verb alc885_mb5_init_verbs[] = { 8328 /* DACs */ 8329 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8330 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8331 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8332 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8333 /* Front mixer */ 8334 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8335 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8336 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8337 /* Surround mixer */ 8338 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8339 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8340 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8341 /* LFE mixer */ 8342 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8343 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8344 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8345 /* HP mixer */ 8346 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8347 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8348 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8349 /* Front Pin (0x0c) */ 8350 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01}, 8351 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8352 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00}, 8353 /* LFE Pin (0x0e) */ 8354 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01}, 8355 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8356 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02}, 8357 /* HP Pin (0x0f) */ 8358 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8359 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8360 {0x14, AC_VERB_SET_CONNECT_SEL, 0x03}, 8361 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 8362 /* Front Mic pin: input vref at 80% */ 8363 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 8364 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 8365 /* Line In pin */ 8366 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 8367 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 8368 8369 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0x1)}, 8370 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x7)}, 8371 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x4)}, 8372 { } 8373}; 8374 8375/* Macmini 3,1 */ 8376static struct hda_verb alc885_macmini3_init_verbs[] = { 8377 /* DACs */ 8378 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8379 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8380 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8381 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8382 /* Front mixer */ 8383 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8384 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8385 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8386 /* Surround mixer */ 8387 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8388 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8389 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8390 /* LFE mixer */ 8391 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8392 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8393 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8394 /* HP mixer */ 8395 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8396 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8397 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8398 /* Front Pin (0x0c) */ 8399 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01}, 8400 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8401 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00}, 8402 /* LFE Pin (0x0e) */ 8403 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01}, 8404 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8405 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02}, 8406 /* HP Pin (0x0f) */ 8407 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8408 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8409 {0x14, AC_VERB_SET_CONNECT_SEL, 0x03}, 8410 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 8411 /* Line In pin */ 8412 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 8413 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 8414 8415 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8416 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 8417 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 8418 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 8419 { } 8420}; 8421 8422 8423static struct hda_verb alc885_mba21_init_verbs[] = { 8424 /*Internal and HP Speaker Mixer*/ 8425 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8426 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8427 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8428 /*Internal Speaker Pin (0x0c)*/ 8429 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) }, 8430 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8431 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00}, 8432 /* HP Pin: output 0 (0x0e) */ 8433 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4}, 8434 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8435 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 8436 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)}, 8437 /* Line in (is hp when jack connected)*/ 8438 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50}, 8439 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 8440 8441 { } 8442 }; 8443 8444 8445/* Macbook Pro rev3 */ 8446static struct hda_verb alc885_mbp3_init_verbs[] = { 8447 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 8448 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8449 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8450 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8451 /* Rear mixer */ 8452 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8453 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8454 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8455 /* HP mixer */ 8456 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8457 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8458 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8459 /* Front Pin: output 0 (0x0c) */ 8460 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8461 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8462 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 8463 /* HP Pin: output 0 (0x0e) */ 8464 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4}, 8465 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8466 {0x15, AC_VERB_SET_CONNECT_SEL, 0x02}, 8467 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 8468 /* Mic (rear) pin: input vref at 80% */ 8469 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 8470 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 8471 /* Front Mic pin: input vref at 80% */ 8472 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 8473 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 8474 /* Line In pin: use output 1 when in LineOut mode */ 8475 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 8476 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 8477 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, 8478 8479 /* FIXME: use matrix-type input source selection */ 8480 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 8481 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 8482 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8483 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 8484 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 8485 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 8486 /* Input mixer2 */ 8487 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8488 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 8489 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 8490 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 8491 /* Input mixer3 */ 8492 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8493 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 8494 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 8495 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 8496 /* ADC1: mute amp left and right */ 8497 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8498 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 8499 /* ADC2: mute amp left and right */ 8500 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8501 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 8502 /* ADC3: mute amp left and right */ 8503 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8504 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 8505 8506 { } 8507}; 8508 8509/* iMac 9,1 */ 8510static struct hda_verb alc885_imac91_init_verbs[] = { 8511 /* Internal Speaker Pin (0x0c) */ 8512 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) }, 8513 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8514 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00}, 8515 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) }, 8516 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8517 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00}, 8518 /* HP Pin: Rear */ 8519 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8520 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8521 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 8522 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)}, 8523 /* Line in Rear */ 8524 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50}, 8525 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 8526 /* Front Mic pin: input vref at 80% */ 8527 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 8528 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 8529 /* Rear mixer */ 8530 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8531 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8532 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8533 /* Line-Out mixer: unmute input/output amp left and right (volume = 0) */ 8534 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8535 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8536 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8537 /* 0x24 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */ 8538 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8539 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 8540 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 8541 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 8542 /* 0x23 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */ 8543 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8544 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 8545 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 8546 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 8547 /* 0x22 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */ 8548 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8549 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 8550 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 8551 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 8552 /* 0x07 [Audio Input] wcaps 0x10011b: Stereo Amp-In */ 8553 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8554 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 8555 /* 0x08 [Audio Input] wcaps 0x10011b: Stereo Amp-In */ 8556 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8557 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 8558 /* 0x09 [Audio Input] wcaps 0x10011b: Stereo Amp-In */ 8559 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8560 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 8561 { } 8562}; 8563 8564/* iMac 24 mixer. */ 8565static struct snd_kcontrol_new alc885_imac24_mixer[] = { 8566 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT), 8567 HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT), 8568 { } /* end */ 8569}; 8570 8571/* iMac 24 init verbs. */ 8572static struct hda_verb alc885_imac24_init_verbs[] = { 8573 /* Internal speakers: output 0 (0x0c) */ 8574 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8575 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8576 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00}, 8577 /* Internal speakers: output 0 (0x0c) */ 8578 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8579 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8580 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00}, 8581 /* Headphone: output 0 (0x0c) */ 8582 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8583 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8584 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 8585 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 8586 /* Front Mic: input vref at 80% */ 8587 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 8588 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 8589 { } 8590}; 8591 8592/* Toggle speaker-output according to the hp-jack state */ 8593static void alc885_imac24_setup(struct hda_codec *codec) 8594{ 8595 struct alc_spec *spec = codec->spec; 8596 8597 spec->autocfg.hp_pins[0] = 0x14; 8598 spec->autocfg.speaker_pins[0] = 0x18; 8599 spec->autocfg.speaker_pins[1] = 0x1a; 8600} 8601 8602#define alc885_mb5_setup alc885_imac24_setup 8603#define alc885_macmini3_setup alc885_imac24_setup 8604 8605/* Macbook Air 2,1 */ 8606static void alc885_mba21_setup(struct hda_codec *codec) 8607{ 8608 struct alc_spec *spec = codec->spec; 8609 8610 spec->autocfg.hp_pins[0] = 0x14; 8611 spec->autocfg.speaker_pins[0] = 0x18; 8612} 8613 8614 8615 8616static void alc885_mbp3_setup(struct hda_codec *codec) 8617{ 8618 struct alc_spec *spec = codec->spec; 8619 8620 spec->autocfg.hp_pins[0] = 0x15; 8621 spec->autocfg.speaker_pins[0] = 0x14; 8622} 8623 8624static void alc885_imac91_setup(struct hda_codec *codec) 8625{ 8626 struct alc_spec *spec = codec->spec; 8627 8628 spec->autocfg.hp_pins[0] = 0x14; 8629 spec->autocfg.speaker_pins[0] = 0x18; 8630 spec->autocfg.speaker_pins[1] = 0x1a; 8631} 8632 8633static struct hda_verb alc882_targa_verbs[] = { 8634 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8635 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8636 8637 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8638 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8639 8640 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 8641 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */ 8642 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 8643 8644 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 8645 { } /* end */ 8646}; 8647 8648/* toggle speaker-output according to the hp-jack state */ 8649static void alc882_targa_automute(struct hda_codec *codec) 8650{ 8651 struct alc_spec *spec = codec->spec; 8652 alc_automute_amp(codec); 8653 snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA, 8654 spec->jack_present ? 1 : 3); 8655} 8656 8657static void alc882_targa_setup(struct hda_codec *codec) 8658{ 8659 struct alc_spec *spec = codec->spec; 8660 8661 spec->autocfg.hp_pins[0] = 0x14; 8662 spec->autocfg.speaker_pins[0] = 0x1b; 8663} 8664 8665static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res) 8666{ 8667 if ((res >> 26) == ALC880_HP_EVENT) 8668 alc882_targa_automute(codec); 8669} 8670 8671static struct hda_verb alc882_asus_a7j_verbs[] = { 8672 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8673 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8674 8675 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8676 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8677 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8678 8679 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */ 8680 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 8681 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */ 8682 8683 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 8684 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */ 8685 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 8686 { } /* end */ 8687}; 8688 8689static struct hda_verb alc882_asus_a7m_verbs[] = { 8690 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8691 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8692 8693 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8694 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8695 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8696 8697 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */ 8698 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 8699 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */ 8700 8701 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 8702 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */ 8703 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 8704 { } /* end */ 8705}; 8706 8707static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted) 8708{ 8709 unsigned int gpiostate, gpiomask, gpiodir; 8710 8711 gpiostate = snd_hda_codec_read(codec, codec->afg, 0, 8712 AC_VERB_GET_GPIO_DATA, 0); 8713 8714 if (!muted) 8715 gpiostate |= (1 << pin); 8716 else 8717 gpiostate &= ~(1 << pin); 8718 8719 gpiomask = snd_hda_codec_read(codec, codec->afg, 0, 8720 AC_VERB_GET_GPIO_MASK, 0); 8721 gpiomask |= (1 << pin); 8722 8723 gpiodir = snd_hda_codec_read(codec, codec->afg, 0, 8724 AC_VERB_GET_GPIO_DIRECTION, 0); 8725 gpiodir |= (1 << pin); 8726 8727 8728 snd_hda_codec_write(codec, codec->afg, 0, 8729 AC_VERB_SET_GPIO_MASK, gpiomask); 8730 snd_hda_codec_write(codec, codec->afg, 0, 8731 AC_VERB_SET_GPIO_DIRECTION, gpiodir); 8732 8733 msleep(1); 8734 8735 snd_hda_codec_write(codec, codec->afg, 0, 8736 AC_VERB_SET_GPIO_DATA, gpiostate); 8737} 8738 8739/* set up GPIO at initialization */ 8740static void alc885_macpro_init_hook(struct hda_codec *codec) 8741{ 8742 alc882_gpio_mute(codec, 0, 0); 8743 alc882_gpio_mute(codec, 1, 0); 8744} 8745 8746/* set up GPIO and update auto-muting at initialization */ 8747static void alc885_imac24_init_hook(struct hda_codec *codec) 8748{ 8749 alc885_macpro_init_hook(codec); 8750 alc_automute_amp(codec); 8751} 8752 8753/* 8754 * generic initialization of ADC, input mixers and output mixers 8755 */ 8756static struct hda_verb alc883_auto_init_verbs[] = { 8757 /* 8758 * Unmute ADC0-2 and set the default input to mic-in 8759 */ 8760 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 8761 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8762 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 8763 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8764 8765 /* 8766 * Set up output mixers (0x0c - 0x0f) 8767 */ 8768 /* set vol=0 to output mixers */ 8769 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8770 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8771 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8772 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8773 /* set up input amps for analog loopback */ 8774 /* Amp Indices: DAC = 0, mixer = 1 */ 8775 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8776 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8777 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8778 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8779 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8780 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8781 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8782 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8783 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8784 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8785 8786 /* FIXME: use matrix-type input source selection */ 8787 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 8788 /* Input mixer2 */ 8789 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8790 /* Input mixer3 */ 8791 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8792 { } 8793}; 8794 8795/* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */ 8796static struct hda_verb alc889A_mb31_ch2_init[] = { 8797 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP as front */ 8798 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */ 8799 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* Line as input */ 8800 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Line off */ 8801 { } /* end */ 8802}; 8803 8804/* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */ 8805static struct hda_verb alc889A_mb31_ch4_init[] = { 8806 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP as front */ 8807 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */ 8808 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, /* Line as output */ 8809 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */ 8810 { } /* end */ 8811}; 8812 8813/* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */ 8814static struct hda_verb alc889A_mb31_ch5_init[] = { 8815 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, /* HP as rear */ 8816 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */ 8817 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* Line as input */ 8818 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Line off */ 8819 { } /* end */ 8820}; 8821 8822/* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */ 8823static struct hda_verb alc889A_mb31_ch6_init[] = { 8824 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, /* HP as front */ 8825 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Subwoofer off */ 8826 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, /* Line as output */ 8827 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */ 8828 { } /* end */ 8829}; 8830 8831static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = { 8832 { 2, alc889A_mb31_ch2_init }, 8833 { 4, alc889A_mb31_ch4_init }, 8834 { 5, alc889A_mb31_ch5_init }, 8835 { 6, alc889A_mb31_ch6_init }, 8836}; 8837 8838static struct hda_verb alc883_medion_eapd_verbs[] = { 8839 /* eanable EAPD on medion laptop */ 8840 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 8841 {0x20, AC_VERB_SET_PROC_COEF, 0x3070}, 8842 { } 8843}; 8844 8845#define alc883_base_mixer alc882_base_mixer 8846 8847static struct snd_kcontrol_new alc883_mitac_mixer[] = { 8848 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8849 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 8850 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 8851 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 8852 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 8853 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 8854 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 8855 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8856 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 8857 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8858 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 8859 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT), 8860 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 8861 { } /* end */ 8862}; 8863 8864static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = { 8865 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8866 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 8867 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 8868 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 8869 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8870 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 8871 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8872 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 8873 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT), 8874 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 8875 { } /* end */ 8876}; 8877 8878static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = { 8879 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8880 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 8881 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 8882 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 8883 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8884 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 8885 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8886 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 8887 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT), 8888 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 8889 { } /* end */ 8890}; 8891 8892static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = { 8893 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8894 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 8895 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 8896 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 8897 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 8898 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 8899 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 8900 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8901 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 8902 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8903 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 8904 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT), 8905 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 8906 { } /* end */ 8907}; 8908 8909static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = { 8910 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8911 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 8912 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 8913 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 8914 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 8915 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 8916 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 8917 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 8918 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 8919 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 8920 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 8921 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 8922 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 8923 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8924 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 8925 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8926 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 8927 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT), 8928 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 8929 { } /* end */ 8930}; 8931 8932static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = { 8933 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8934 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 8935 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 8936 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 8937 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, 8938 HDA_OUTPUT), 8939 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 8940 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 8941 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 8942 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 8943 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 8944 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 8945 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 8946 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 8947 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 8948 HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT), 8949 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 8950 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8951 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x18, 0, HDA_INPUT), 8952 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8953 { } /* end */ 8954}; 8955 8956static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = { 8957 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8958 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 8959 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 8960 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 8961 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, 8962 HDA_OUTPUT), 8963 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 8964 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 8965 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 8966 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 8967 HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT), 8968 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 8969 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 8970 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 8971 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT), 8972 HDA_CODEC_VOLUME("Mic Boost Volume", 0x1b, 0, HDA_INPUT), 8973 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT), 8974 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8975 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x18, 0, HDA_INPUT), 8976 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8977 { } /* end */ 8978}; 8979 8980static struct snd_kcontrol_new alc883_fivestack_mixer[] = { 8981 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8982 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 8983 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 8984 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 8985 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 8986 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 8987 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 8988 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 8989 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 8990 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 8991 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 8992 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 8993 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 8994 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8995 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 8996 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8997 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 8998 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT), 8999 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 9000 { } /* end */ 9001}; 9002 9003static struct snd_kcontrol_new alc883_targa_mixer[] = { 9004 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9005 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 9006 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 9007 HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 9008 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 9009 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 9010 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 9011 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 9012 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 9013 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 9014 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 9015 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 9016 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 9017 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 9018 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9019 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 9020 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9021 { } /* end */ 9022}; 9023 9024static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = { 9025 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9026 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 9027 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 9028 HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 9029 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 9030 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 9031 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9032 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 9033 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9034 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 9035 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT), 9036 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 9037 { } /* end */ 9038}; 9039 9040static struct snd_kcontrol_new alc883_targa_8ch_mixer[] = { 9041 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 9042 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 9043 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 9044 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT), 9045 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 9046 { } /* end */ 9047}; 9048 9049static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = { 9050 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9051 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 9052 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 9053 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 9054 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 9055 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 9056 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 9057 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 9058 { } /* end */ 9059}; 9060 9061static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = { 9062 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9063 HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT), 9064 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 9065 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 9066 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 9067 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9068 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9069 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 9070 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 9071 { } /* end */ 9072}; 9073 9074static struct snd_kcontrol_new alc883_medion_wim2160_mixer[] = { 9075 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9076 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 9077 HDA_CODEC_MUTE("Speaker Playback Switch", 0x15, 0x0, HDA_OUTPUT), 9078 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT), 9079 HDA_CODEC_VOLUME("Line Playback Volume", 0x08, 0x0, HDA_INPUT), 9080 HDA_CODEC_MUTE("Line Playback Switch", 0x08, 0x0, HDA_INPUT), 9081 { } /* end */ 9082}; 9083 9084static struct hda_verb alc883_medion_wim2160_verbs[] = { 9085 /* Unmute front mixer */ 9086 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9087 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9088 9089 /* Set speaker pin to front mixer */ 9090 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 9091 9092 /* Init headphone pin */ 9093 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9094 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 9095 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00}, 9096 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9097 9098 { } /* end */ 9099}; 9100 9101/* toggle speaker-output according to the hp-jack state */ 9102static void alc883_medion_wim2160_setup(struct hda_codec *codec) 9103{ 9104 struct alc_spec *spec = codec->spec; 9105 9106 spec->autocfg.hp_pins[0] = 0x1a; 9107 spec->autocfg.speaker_pins[0] = 0x15; 9108} 9109 9110static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = { 9111 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9112 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 9113 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 9114 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 9115 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 9116 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9117 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 9118 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9119 { } /* end */ 9120}; 9121 9122static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = { 9123 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9124 HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 9125 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 9126 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 9127 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 9128 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 9129 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9130 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 9131 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9132 { } /* end */ 9133}; 9134 9135static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = { 9136 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9137 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 9138 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT), 9139 HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT), 9140 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 9141 0x0d, 1, 0x0, HDA_OUTPUT), 9142 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT), 9143 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT), 9144 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT), 9145 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 9146 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 9147 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 9148 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 9149 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 9150 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 9151 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9152 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 9153 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9154 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 9155 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT), 9156 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 9157 { } /* end */ 9158}; 9159 9160static struct snd_kcontrol_new alc889A_mb31_mixer[] = { 9161 /* Output mixers */ 9162 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT), 9163 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT), 9164 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT), 9165 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT), 9166 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00, 9167 HDA_OUTPUT), 9168 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT), 9169 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT), 9170 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT), 9171 /* Output switches */ 9172 HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT), 9173 HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT), 9174 HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT), 9175 /* Boost mixers */ 9176 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0x00, HDA_INPUT), 9177 HDA_CODEC_VOLUME("Line Boost Volume", 0x1a, 0x00, HDA_INPUT), 9178 /* Input mixers */ 9179 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT), 9180 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT), 9181 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 9182 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 9183 { } /* end */ 9184}; 9185 9186static struct snd_kcontrol_new alc883_vaiott_mixer[] = { 9187 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9188 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 9189 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 9190 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 9191 HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT), 9192 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 9193 { } /* end */ 9194}; 9195 9196static struct hda_bind_ctls alc883_bind_cap_vol = { 9197 .ops = &snd_hda_bind_vol, 9198 .values = { 9199 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT), 9200 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT), 9201 0 9202 }, 9203}; 9204 9205static struct hda_bind_ctls alc883_bind_cap_switch = { 9206 .ops = &snd_hda_bind_sw, 9207 .values = { 9208 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT), 9209 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT), 9210 0 9211 }, 9212}; 9213 9214static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = { 9215 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9216 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 9217 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 9218 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 9219 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 9220 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9221 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 9222 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9223 { } /* end */ 9224}; 9225 9226static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = { 9227 HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol), 9228 HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch), 9229 { 9230 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 9231 /* .name = "Capture Source", */ 9232 .name = "Input Source", 9233 .count = 1, 9234 .info = alc_mux_enum_info, 9235 .get = alc_mux_enum_get, 9236 .put = alc_mux_enum_put, 9237 }, 9238 { } /* end */ 9239}; 9240 9241static struct snd_kcontrol_new alc883_chmode_mixer[] = { 9242 { 9243 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 9244 .name = "Channel Mode", 9245 .info = alc_ch_mode_info, 9246 .get = alc_ch_mode_get, 9247 .put = alc_ch_mode_put, 9248 }, 9249 { } /* end */ 9250}; 9251 9252/* toggle speaker-output according to the hp-jack state */ 9253static void alc883_mitac_setup(struct hda_codec *codec) 9254{ 9255 struct alc_spec *spec = codec->spec; 9256 9257 spec->autocfg.hp_pins[0] = 0x15; 9258 spec->autocfg.speaker_pins[0] = 0x14; 9259 spec->autocfg.speaker_pins[1] = 0x17; 9260} 9261 9262static struct hda_verb alc883_mitac_verbs[] = { 9263 /* HP */ 9264 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 9265 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9266 /* Subwoofer */ 9267 {0x17, AC_VERB_SET_CONNECT_SEL, 0x02}, 9268 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9269 9270 /* enable unsolicited event */ 9271 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9272 /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */ 9273 9274 { } /* end */ 9275}; 9276 9277static struct hda_verb alc883_clevo_m540r_verbs[] = { 9278 /* HP */ 9279 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 9280 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9281 /* Int speaker */ 9282 /*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/ 9283 9284 /* enable unsolicited event */ 9285 /* 9286 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9287 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, 9288 */ 9289 9290 { } /* end */ 9291}; 9292 9293static struct hda_verb alc883_clevo_m720_verbs[] = { 9294 /* HP */ 9295 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 9296 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9297 /* Int speaker */ 9298 {0x14, AC_VERB_SET_CONNECT_SEL, 0x01}, 9299 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9300 9301 /* enable unsolicited event */ 9302 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9303 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, 9304 9305 { } /* end */ 9306}; 9307 9308static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = { 9309 /* HP */ 9310 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 9311 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9312 /* Subwoofer */ 9313 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 9314 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9315 9316 /* enable unsolicited event */ 9317 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9318 9319 { } /* end */ 9320}; 9321 9322static struct hda_verb alc883_targa_verbs[] = { 9323 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9324 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9325 9326 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9327 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9328 9329/* Connect Line-Out side jack (SPDIF) to Side */ 9330 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9331 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 9332 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 9333/* Connect Mic jack to CLFE */ 9334 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9335 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 9336 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, 9337/* Connect Line-in jack to Surround */ 9338 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9339 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 9340 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, 9341/* Connect HP out jack to Front */ 9342 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9343 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 9344 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 9345 9346 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9347 9348 { } /* end */ 9349}; 9350 9351static struct hda_verb alc883_lenovo_101e_verbs[] = { 9352 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 9353 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN}, 9354 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN}, 9355 { } /* end */ 9356}; 9357 9358static struct hda_verb alc883_lenovo_nb0763_verbs[] = { 9359 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 9360 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9361 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9362 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9363 { } /* end */ 9364}; 9365 9366static struct hda_verb alc888_lenovo_ms7195_verbs[] = { 9367 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9368 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9369 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 9370 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN}, 9371 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9372 { } /* end */ 9373}; 9374 9375static struct hda_verb alc883_haier_w66_verbs[] = { 9376 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9377 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9378 9379 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9380 9381 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 9382 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9383 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9384 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9385 { } /* end */ 9386}; 9387 9388static struct hda_verb alc888_lenovo_sky_verbs[] = { 9389 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9390 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9391 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9392 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9393 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9394 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9395 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00}, 9396 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9397 { } /* end */ 9398}; 9399 9400static struct hda_verb alc888_6st_dell_verbs[] = { 9401 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9402 { } 9403}; 9404 9405static struct hda_verb alc883_vaiott_verbs[] = { 9406 /* HP */ 9407 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 9408 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9409 9410 /* enable unsolicited event */ 9411 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9412 9413 { } /* end */ 9414}; 9415 9416static void alc888_3st_hp_setup(struct hda_codec *codec) 9417{ 9418 struct alc_spec *spec = codec->spec; 9419 9420 spec->autocfg.hp_pins[0] = 0x1b; 9421 spec->autocfg.speaker_pins[0] = 0x14; 9422 spec->autocfg.speaker_pins[1] = 0x16; 9423 spec->autocfg.speaker_pins[2] = 0x18; 9424} 9425 9426static struct hda_verb alc888_3st_hp_verbs[] = { 9427 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front: output 0 (0x0c) */ 9428 {0x16, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Rear : output 1 (0x0d) */ 9429 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* CLFE : output 2 (0x0e) */ 9430 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9431 { } /* end */ 9432}; 9433 9434/* 9435 * 2ch mode 9436 */ 9437static struct hda_verb alc888_3st_hp_2ch_init[] = { 9438 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 9439 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 9440 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 9441 { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 9442 { } /* end */ 9443}; 9444 9445/* 9446 * 4ch mode 9447 */ 9448static struct hda_verb alc888_3st_hp_4ch_init[] = { 9449 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 9450 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 9451 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 9452 { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 9453 { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 }, 9454 { } /* end */ 9455}; 9456 9457/* 9458 * 6ch mode 9459 */ 9460static struct hda_verb alc888_3st_hp_6ch_init[] = { 9461 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 9462 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 9463 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 }, 9464 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 9465 { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 9466 { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 }, 9467 { } /* end */ 9468}; 9469 9470static struct hda_channel_mode alc888_3st_hp_modes[3] = { 9471 { 2, alc888_3st_hp_2ch_init }, 9472 { 4, alc888_3st_hp_4ch_init }, 9473 { 6, alc888_3st_hp_6ch_init }, 9474}; 9475 9476/* toggle front-jack and RCA according to the hp-jack state */ 9477static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec) 9478{ 9479 unsigned int present = snd_hda_jack_detect(codec, 0x1b); 9480 9481 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9482 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 9483 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 9484 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 9485} 9486 9487/* toggle RCA according to the front-jack state */ 9488static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec) 9489{ 9490 unsigned int present = snd_hda_jack_detect(codec, 0x14); 9491 9492 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 9493 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 9494} 9495 9496static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec, 9497 unsigned int res) 9498{ 9499 if ((res >> 26) == ALC880_HP_EVENT) 9500 alc888_lenovo_ms7195_front_automute(codec); 9501 if ((res >> 26) == ALC880_FRONT_EVENT) 9502 alc888_lenovo_ms7195_rca_automute(codec); 9503} 9504 9505/* toggle speaker-output according to the hp-jack state */ 9506static void alc883_lenovo_nb0763_setup(struct hda_codec *codec) 9507{ 9508 struct alc_spec *spec = codec->spec; 9509 9510 spec->autocfg.hp_pins[0] = 0x14; 9511 spec->autocfg.speaker_pins[0] = 0x15; 9512} 9513 9514/* toggle speaker-output according to the hp-jack state */ 9515#define alc883_targa_init_hook alc882_targa_init_hook 9516#define alc883_targa_unsol_event alc882_targa_unsol_event 9517 9518static void alc883_clevo_m720_setup(struct hda_codec *codec) 9519{ 9520 struct alc_spec *spec = codec->spec; 9521 9522 spec->autocfg.hp_pins[0] = 0x15; 9523 spec->autocfg.speaker_pins[0] = 0x14; 9524} 9525 9526static void alc883_clevo_m720_init_hook(struct hda_codec *codec) 9527{ 9528 alc_automute_amp(codec); 9529 alc88x_simple_mic_automute(codec); 9530} 9531 9532static void alc883_clevo_m720_unsol_event(struct hda_codec *codec, 9533 unsigned int res) 9534{ 9535 switch (res >> 26) { 9536 case ALC880_MIC_EVENT: 9537 alc88x_simple_mic_automute(codec); 9538 break; 9539 default: 9540 alc_automute_amp_unsol_event(codec, res); 9541 break; 9542 } 9543} 9544 9545/* toggle speaker-output according to the hp-jack state */ 9546static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec) 9547{ 9548 struct alc_spec *spec = codec->spec; 9549 9550 spec->autocfg.hp_pins[0] = 0x14; 9551 spec->autocfg.speaker_pins[0] = 0x15; 9552} 9553 9554static void alc883_haier_w66_setup(struct hda_codec *codec) 9555{ 9556 struct alc_spec *spec = codec->spec; 9557 9558 spec->autocfg.hp_pins[0] = 0x1b; 9559 spec->autocfg.speaker_pins[0] = 0x14; 9560} 9561 9562static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec) 9563{ 9564 int bits = snd_hda_jack_detect(codec, 0x14) ? HDA_AMP_MUTE : 0; 9565 9566 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 9567 HDA_AMP_MUTE, bits); 9568} 9569 9570static void alc883_lenovo_101e_all_automute(struct hda_codec *codec) 9571{ 9572 int bits = snd_hda_jack_detect(codec, 0x1b) ? HDA_AMP_MUTE : 0; 9573 9574 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 9575 HDA_AMP_MUTE, bits); 9576 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9577 HDA_AMP_MUTE, bits); 9578} 9579 9580static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec, 9581 unsigned int res) 9582{ 9583 if ((res >> 26) == ALC880_HP_EVENT) 9584 alc883_lenovo_101e_all_automute(codec); 9585 if ((res >> 26) == ALC880_FRONT_EVENT) 9586 alc883_lenovo_101e_ispeaker_automute(codec); 9587} 9588 9589/* toggle speaker-output according to the hp-jack state */ 9590static void alc883_acer_aspire_setup(struct hda_codec *codec) 9591{ 9592 struct alc_spec *spec = codec->spec; 9593 9594 spec->autocfg.hp_pins[0] = 0x14; 9595 spec->autocfg.speaker_pins[0] = 0x15; 9596 spec->autocfg.speaker_pins[1] = 0x16; 9597} 9598 9599static struct hda_verb alc883_acer_eapd_verbs[] = { 9600 /* HP Pin: output 0 (0x0c) */ 9601 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9602 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 9603 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 9604 /* Front Pin: output 0 (0x0c) */ 9605 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9606 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 9607 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9608 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, 9609 /* eanable EAPD on medion laptop */ 9610 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 9611 {0x20, AC_VERB_SET_PROC_COEF, 0x3050}, 9612 /* enable unsolicited event */ 9613 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9614 { } 9615}; 9616 9617static void alc888_6st_dell_setup(struct hda_codec *codec) 9618{ 9619 struct alc_spec *spec = codec->spec; 9620 9621 spec->autocfg.hp_pins[0] = 0x1b; 9622 spec->autocfg.speaker_pins[0] = 0x14; 9623 spec->autocfg.speaker_pins[1] = 0x15; 9624 spec->autocfg.speaker_pins[2] = 0x16; 9625 spec->autocfg.speaker_pins[3] = 0x17; 9626} 9627 9628static void alc888_lenovo_sky_setup(struct hda_codec *codec) 9629{ 9630 struct alc_spec *spec = codec->spec; 9631 9632 spec->autocfg.hp_pins[0] = 0x1b; 9633 spec->autocfg.speaker_pins[0] = 0x14; 9634 spec->autocfg.speaker_pins[1] = 0x15; 9635 spec->autocfg.speaker_pins[2] = 0x16; 9636 spec->autocfg.speaker_pins[3] = 0x17; 9637 spec->autocfg.speaker_pins[4] = 0x1a; 9638} 9639 9640static void alc883_vaiott_setup(struct hda_codec *codec) 9641{ 9642 struct alc_spec *spec = codec->spec; 9643 9644 spec->autocfg.hp_pins[0] = 0x15; 9645 spec->autocfg.speaker_pins[0] = 0x14; 9646 spec->autocfg.speaker_pins[1] = 0x17; 9647} 9648 9649static struct hda_verb alc888_asus_m90v_verbs[] = { 9650 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 9651 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 9652 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9653 /* enable unsolicited event */ 9654 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9655 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, 9656 { } /* end */ 9657}; 9658 9659static void alc883_mode2_setup(struct hda_codec *codec) 9660{ 9661 struct alc_spec *spec = codec->spec; 9662 9663 spec->autocfg.hp_pins[0] = 0x1b; 9664 spec->autocfg.speaker_pins[0] = 0x14; 9665 spec->autocfg.speaker_pins[1] = 0x15; 9666 spec->autocfg.speaker_pins[2] = 0x16; 9667 spec->ext_mic.pin = 0x18; 9668 spec->int_mic.pin = 0x19; 9669 spec->ext_mic.mux_idx = 0; 9670 spec->int_mic.mux_idx = 1; 9671 spec->auto_mic = 1; 9672} 9673 9674static struct hda_verb alc888_asus_eee1601_verbs[] = { 9675 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9676 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9677 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 9678 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9679 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 9680 {0x20, AC_VERB_SET_COEF_INDEX, 0x0b}, 9681 {0x20, AC_VERB_SET_PROC_COEF, 0x0838}, 9682 /* enable unsolicited event */ 9683 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9684 { } /* end */ 9685}; 9686 9687static void alc883_eee1601_inithook(struct hda_codec *codec) 9688{ 9689 struct alc_spec *spec = codec->spec; 9690 9691 spec->autocfg.hp_pins[0] = 0x14; 9692 spec->autocfg.speaker_pins[0] = 0x1b; 9693 alc_automute_pin(codec); 9694} 9695 9696static struct hda_verb alc889A_mb31_verbs[] = { 9697 /* Init rear pin (used as headphone output) */ 9698 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4}, /* Apple Headphones */ 9699 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Connect to front */ 9700 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9701 /* Init line pin (used as output in 4ch and 6ch mode) */ 9702 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02}, /* Connect to CLFE */ 9703 /* Init line 2 pin (used as headphone out by default) */ 9704 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* Use as input */ 9705 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */ 9706 { } /* end */ 9707}; 9708 9709/* Mute speakers according to the headphone jack state */ 9710static void alc889A_mb31_automute(struct hda_codec *codec) 9711{ 9712 unsigned int present; 9713 9714 /* Mute only in 2ch or 4ch mode */ 9715 if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0) 9716 == 0x00) { 9717 present = snd_hda_jack_detect(codec, 0x15); 9718 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9719 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 9720 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 9721 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 9722 } 9723} 9724 9725static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res) 9726{ 9727 if ((res >> 26) == ALC880_HP_EVENT) 9728 alc889A_mb31_automute(codec); 9729} 9730 9731 9732#ifdef CONFIG_SND_HDA_POWER_SAVE 9733#define alc882_loopbacks alc880_loopbacks 9734#endif 9735 9736/* pcm configuration: identical with ALC880 */ 9737#define alc882_pcm_analog_playback alc880_pcm_analog_playback 9738#define alc882_pcm_analog_capture alc880_pcm_analog_capture 9739#define alc882_pcm_digital_playback alc880_pcm_digital_playback 9740#define alc882_pcm_digital_capture alc880_pcm_digital_capture 9741 9742static hda_nid_t alc883_slave_dig_outs[] = { 9743 ALC1200_DIGOUT_NID, 0, 9744}; 9745 9746static hda_nid_t alc1200_slave_dig_outs[] = { 9747 ALC883_DIGOUT_NID, 0, 9748}; 9749 9750/* 9751 * configuration and preset 9752 */ 9753static const char * const alc882_models[ALC882_MODEL_LAST] = { 9754 [ALC882_3ST_DIG] = "3stack-dig", 9755 [ALC882_6ST_DIG] = "6stack-dig", 9756 [ALC882_ARIMA] = "arima", 9757 [ALC882_W2JC] = "w2jc", 9758 [ALC882_TARGA] = "targa", 9759 [ALC882_ASUS_A7J] = "asus-a7j", 9760 [ALC882_ASUS_A7M] = "asus-a7m", 9761 [ALC885_MACPRO] = "macpro", 9762 [ALC885_MB5] = "mb5", 9763 [ALC885_MACMINI3] = "macmini3", 9764 [ALC885_MBA21] = "mba21", 9765 [ALC885_MBP3] = "mbp3", 9766 [ALC885_IMAC24] = "imac24", 9767 [ALC885_IMAC91] = "imac91", 9768 [ALC883_3ST_2ch_DIG] = "3stack-2ch-dig", 9769 [ALC883_3ST_6ch_DIG] = "3stack-6ch-dig", 9770 [ALC883_3ST_6ch] = "3stack-6ch", 9771 [ALC883_6ST_DIG] = "alc883-6stack-dig", 9772 [ALC883_TARGA_DIG] = "targa-dig", 9773 [ALC883_TARGA_2ch_DIG] = "targa-2ch-dig", 9774 [ALC883_TARGA_8ch_DIG] = "targa-8ch-dig", 9775 [ALC883_ACER] = "acer", 9776 [ALC883_ACER_ASPIRE] = "acer-aspire", 9777 [ALC888_ACER_ASPIRE_4930G] = "acer-aspire-4930g", 9778 [ALC888_ACER_ASPIRE_6530G] = "acer-aspire-6530g", 9779 [ALC888_ACER_ASPIRE_8930G] = "acer-aspire-8930g", 9780 [ALC888_ACER_ASPIRE_7730G] = "acer-aspire-7730g", 9781 [ALC883_MEDION] = "medion", 9782 [ALC883_MEDION_WIM2160] = "medion-wim2160", 9783 [ALC883_LAPTOP_EAPD] = "laptop-eapd", 9784 [ALC883_LENOVO_101E_2ch] = "lenovo-101e", 9785 [ALC883_LENOVO_NB0763] = "lenovo-nb0763", 9786 [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig", 9787 [ALC888_LENOVO_SKY] = "lenovo-sky", 9788 [ALC883_HAIER_W66] = "haier-w66", 9789 [ALC888_3ST_HP] = "3stack-hp", 9790 [ALC888_6ST_DELL] = "6stack-dell", 9791 [ALC883_MITAC] = "mitac", 9792 [ALC883_CLEVO_M540R] = "clevo-m540r", 9793 [ALC883_CLEVO_M720] = "clevo-m720", 9794 [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515", 9795 [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530", 9796 [ALC883_3ST_6ch_INTEL] = "3stack-6ch-intel", 9797 [ALC889A_INTEL] = "intel-alc889a", 9798 [ALC889_INTEL] = "intel-x58", 9799 [ALC1200_ASUS_P5Q] = "asus-p5q", 9800 [ALC889A_MB31] = "mb31", 9801 [ALC883_SONY_VAIO_TT] = "sony-vaio-tt", 9802 [ALC882_AUTO] = "auto", 9803}; 9804 9805static struct snd_pci_quirk alc882_cfg_tbl[] = { 9806 SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG), 9807 9808 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE), 9809 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE), 9810 SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE), 9811 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE), 9812 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE), 9813 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE), 9814 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G", 9815 ALC888_ACER_ASPIRE_4930G), 9816 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G", 9817 ALC888_ACER_ASPIRE_4930G), 9818 SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G", 9819 ALC888_ACER_ASPIRE_8930G), 9820 SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G", 9821 ALC888_ACER_ASPIRE_8930G), 9822 SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO), 9823 SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO), 9824 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G", 9825 ALC888_ACER_ASPIRE_6530G), 9826 SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G", 9827 ALC888_ACER_ASPIRE_6530G), 9828 SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G", 9829 ALC888_ACER_ASPIRE_7730G), 9830 /* default Acer -- disabled as it causes more problems. 9831 * model=auto should work fine now 9832 */ 9833 /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */ 9834 9835 SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL), 9836 9837 SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG), 9838 SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP), 9839 SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP), 9840 SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG), 9841 SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP), 9842 SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP), 9843 9844 SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J), 9845 SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J), 9846 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M), 9847 SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V), 9848 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC), 9849 SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG), 9850 SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG), 9851 SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG), 9852 SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG), 9853 SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q), 9854 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601), 9855 9856 SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT), 9857 SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG), 9858 SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG), 9859 SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC), 9860 SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC), 9861 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD), 9862 SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL), 9863 SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch), 9864 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG), 9865 9866 SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG), 9867 SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG), 9868 SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG), 9869 SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8 */ 9870 SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC882_AUTO), 9871 SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG), 9872 SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG), 9873 SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG), 9874 SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG), 9875 SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG), 9876 SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG), 9877 SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG), 9878 SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG), 9879 SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG), 9880 SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG), 9881 SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG), 9882 SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG), 9883 SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG), 9884 SND_PCI_QUIRK(0x1462, 0x4570, "MSI Wind Top AE2220", ALC883_TARGA_DIG), 9885 SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG), 9886 SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG), 9887 SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG), 9888 SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG), 9889 SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG), 9890 SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG), 9891 SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG), 9892 SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG), 9893 SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG), 9894 SND_PCI_QUIRK(0x1462, 0x7437, "MSI NetOn AP1900", ALC883_TARGA_DIG), 9895 SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG), 9896 SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG), 9897 9898 SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG), 9899 SND_PCI_QUIRK(0x1558, 0x0571, "Clevo laptop M570U", ALC883_3ST_6ch_DIG), 9900 SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720), 9901 SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720), 9902 SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R), 9903 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD), 9904 SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch), 9905 /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */ 9906 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION), 9907 SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx", 9908 ALC883_FUJITSU_PI2515), 9909 SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx", 9910 ALC888_FUJITSU_XA3530), 9911 SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch), 9912 SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763), 9913 SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763), 9914 SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763), 9915 SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY), 9916 SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG), 9917 SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG), 9918 SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66), 9919 9920 SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL), 9921 SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL), 9922 SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC), 9923 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL), 9924 SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL), 9925 SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL), 9926 SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC882_6ST_DIG), 9927 9928 {} 9929}; 9930 9931/* codec SSID table for Intel Mac */ 9932static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = { 9933 SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3), 9934 SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3), 9935 SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3), 9936 SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO), 9937 SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24), 9938 SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24), 9939 SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3), 9940 SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889A_MB31), 9941 SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_ASUS_A7M), 9942 SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC885_MBP3), 9943 SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC885_MBA21), 9944 SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31), 9945 SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3), 9946 SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24), 9947 SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91), 9948 SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5), 9949 SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC885_MB5), 9950 /* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2, 9951 * so apparently no perfect solution yet 9952 */ 9953 SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5), 9954 SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5), 9955 SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC885_MACMINI3), 9956 {} /* terminator */ 9957}; 9958 9959static struct alc_config_preset alc882_presets[] = { 9960 [ALC882_3ST_DIG] = { 9961 .mixers = { alc882_base_mixer }, 9962 .init_verbs = { alc882_base_init_verbs, 9963 alc882_adc1_init_verbs }, 9964 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 9965 .dac_nids = alc882_dac_nids, 9966 .dig_out_nid = ALC882_DIGOUT_NID, 9967 .dig_in_nid = ALC882_DIGIN_NID, 9968 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes), 9969 .channel_mode = alc882_ch_modes, 9970 .need_dac_fix = 1, 9971 .input_mux = &alc882_capture_source, 9972 }, 9973 [ALC882_6ST_DIG] = { 9974 .mixers = { alc882_base_mixer, alc882_chmode_mixer }, 9975 .init_verbs = { alc882_base_init_verbs, 9976 alc882_adc1_init_verbs }, 9977 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 9978 .dac_nids = alc882_dac_nids, 9979 .dig_out_nid = ALC882_DIGOUT_NID, 9980 .dig_in_nid = ALC882_DIGIN_NID, 9981 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes), 9982 .channel_mode = alc882_sixstack_modes, 9983 .input_mux = &alc882_capture_source, 9984 }, 9985 [ALC882_ARIMA] = { 9986 .mixers = { alc882_base_mixer, alc882_chmode_mixer }, 9987 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs, 9988 alc882_eapd_verbs }, 9989 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 9990 .dac_nids = alc882_dac_nids, 9991 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes), 9992 .channel_mode = alc882_sixstack_modes, 9993 .input_mux = &alc882_capture_source, 9994 }, 9995 [ALC882_W2JC] = { 9996 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer }, 9997 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs, 9998 alc882_eapd_verbs, alc880_gpio1_init_verbs }, 9999 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 10000 .dac_nids = alc882_dac_nids, 10001 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 10002 .channel_mode = alc880_threestack_modes, 10003 .need_dac_fix = 1, 10004 .input_mux = &alc882_capture_source, 10005 .dig_out_nid = ALC882_DIGOUT_NID, 10006 }, 10007 [ALC885_MBA21] = { 10008 .mixers = { alc885_mba21_mixer }, 10009 .init_verbs = { alc885_mba21_init_verbs, alc880_gpio1_init_verbs }, 10010 .num_dacs = 2, 10011 .dac_nids = alc882_dac_nids, 10012 .channel_mode = alc885_mba21_ch_modes, 10013 .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes), 10014 .input_mux = &alc882_capture_source, 10015 .unsol_event = alc_automute_amp_unsol_event, 10016 .setup = alc885_mba21_setup, 10017 .init_hook = alc_automute_amp, 10018 }, 10019 [ALC885_MBP3] = { 10020 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer }, 10021 .init_verbs = { alc885_mbp3_init_verbs, 10022 alc880_gpio1_init_verbs }, 10023 .num_dacs = 2, 10024 .dac_nids = alc882_dac_nids, 10025 .hp_nid = 0x04, 10026 .channel_mode = alc885_mbp_4ch_modes, 10027 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes), 10028 .input_mux = &alc882_capture_source, 10029 .dig_out_nid = ALC882_DIGOUT_NID, 10030 .dig_in_nid = ALC882_DIGIN_NID, 10031 .unsol_event = alc_automute_amp_unsol_event, 10032 .setup = alc885_mbp3_setup, 10033 .init_hook = alc_automute_amp, 10034 }, 10035 [ALC885_MB5] = { 10036 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer }, 10037 .init_verbs = { alc885_mb5_init_verbs, 10038 alc880_gpio1_init_verbs }, 10039 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 10040 .dac_nids = alc882_dac_nids, 10041 .channel_mode = alc885_mb5_6ch_modes, 10042 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes), 10043 .input_mux = &mb5_capture_source, 10044 .dig_out_nid = ALC882_DIGOUT_NID, 10045 .dig_in_nid = ALC882_DIGIN_NID, 10046 .unsol_event = alc_automute_amp_unsol_event, 10047 .setup = alc885_mb5_setup, 10048 .init_hook = alc_automute_amp, 10049 }, 10050 [ALC885_MACMINI3] = { 10051 .mixers = { alc885_macmini3_mixer, alc882_chmode_mixer }, 10052 .init_verbs = { alc885_macmini3_init_verbs, 10053 alc880_gpio1_init_verbs }, 10054 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 10055 .dac_nids = alc882_dac_nids, 10056 .channel_mode = alc885_macmini3_6ch_modes, 10057 .num_channel_mode = ARRAY_SIZE(alc885_macmini3_6ch_modes), 10058 .input_mux = &macmini3_capture_source, 10059 .dig_out_nid = ALC882_DIGOUT_NID, 10060 .dig_in_nid = ALC882_DIGIN_NID, 10061 .unsol_event = alc_automute_amp_unsol_event, 10062 .setup = alc885_macmini3_setup, 10063 .init_hook = alc_automute_amp, 10064 }, 10065 [ALC885_MACPRO] = { 10066 .mixers = { alc882_macpro_mixer }, 10067 .init_verbs = { alc882_macpro_init_verbs }, 10068 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 10069 .dac_nids = alc882_dac_nids, 10070 .dig_out_nid = ALC882_DIGOUT_NID, 10071 .dig_in_nid = ALC882_DIGIN_NID, 10072 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes), 10073 .channel_mode = alc882_ch_modes, 10074 .input_mux = &alc882_capture_source, 10075 .init_hook = alc885_macpro_init_hook, 10076 }, 10077 [ALC885_IMAC24] = { 10078 .mixers = { alc885_imac24_mixer }, 10079 .init_verbs = { alc885_imac24_init_verbs }, 10080 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 10081 .dac_nids = alc882_dac_nids, 10082 .dig_out_nid = ALC882_DIGOUT_NID, 10083 .dig_in_nid = ALC882_DIGIN_NID, 10084 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes), 10085 .channel_mode = alc882_ch_modes, 10086 .input_mux = &alc882_capture_source, 10087 .unsol_event = alc_automute_amp_unsol_event, 10088 .setup = alc885_imac24_setup, 10089 .init_hook = alc885_imac24_init_hook, 10090 }, 10091 [ALC885_IMAC91] = { 10092 .mixers = {alc885_imac91_mixer}, 10093 .init_verbs = { alc885_imac91_init_verbs, 10094 alc880_gpio1_init_verbs }, 10095 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 10096 .dac_nids = alc882_dac_nids, 10097 .channel_mode = alc885_mba21_ch_modes, 10098 .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes), 10099 .input_mux = &alc889A_imac91_capture_source, 10100 .dig_out_nid = ALC882_DIGOUT_NID, 10101 .dig_in_nid = ALC882_DIGIN_NID, 10102 .unsol_event = alc_automute_amp_unsol_event, 10103 .setup = alc885_imac91_setup, 10104 .init_hook = alc_automute_amp, 10105 }, 10106 [ALC882_TARGA] = { 10107 .mixers = { alc882_targa_mixer, alc882_chmode_mixer }, 10108 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs, 10109 alc880_gpio3_init_verbs, alc882_targa_verbs}, 10110 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 10111 .dac_nids = alc882_dac_nids, 10112 .dig_out_nid = ALC882_DIGOUT_NID, 10113 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids), 10114 .adc_nids = alc882_adc_nids, 10115 .capsrc_nids = alc882_capsrc_nids, 10116 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes), 10117 .channel_mode = alc882_3ST_6ch_modes, 10118 .need_dac_fix = 1, 10119 .input_mux = &alc882_capture_source, 10120 .unsol_event = alc882_targa_unsol_event, 10121 .setup = alc882_targa_setup, 10122 .init_hook = alc882_targa_automute, 10123 }, 10124 [ALC882_ASUS_A7J] = { 10125 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer }, 10126 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs, 10127 alc882_asus_a7j_verbs}, 10128 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 10129 .dac_nids = alc882_dac_nids, 10130 .dig_out_nid = ALC882_DIGOUT_NID, 10131 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids), 10132 .adc_nids = alc882_adc_nids, 10133 .capsrc_nids = alc882_capsrc_nids, 10134 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes), 10135 .channel_mode = alc882_3ST_6ch_modes, 10136 .need_dac_fix = 1, 10137 .input_mux = &alc882_capture_source, 10138 }, 10139 [ALC882_ASUS_A7M] = { 10140 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer }, 10141 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs, 10142 alc882_eapd_verbs, alc880_gpio1_init_verbs, 10143 alc882_asus_a7m_verbs }, 10144 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 10145 .dac_nids = alc882_dac_nids, 10146 .dig_out_nid = ALC882_DIGOUT_NID, 10147 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 10148 .channel_mode = alc880_threestack_modes, 10149 .need_dac_fix = 1, 10150 .input_mux = &alc882_capture_source, 10151 }, 10152 [ALC883_3ST_2ch_DIG] = { 10153 .mixers = { alc883_3ST_2ch_mixer }, 10154 .init_verbs = { alc883_init_verbs }, 10155 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10156 .dac_nids = alc883_dac_nids, 10157 .dig_out_nid = ALC883_DIGOUT_NID, 10158 .dig_in_nid = ALC883_DIGIN_NID, 10159 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 10160 .channel_mode = alc883_3ST_2ch_modes, 10161 .input_mux = &alc883_capture_source, 10162 }, 10163 [ALC883_3ST_6ch_DIG] = { 10164 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 10165 .init_verbs = { alc883_init_verbs }, 10166 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10167 .dac_nids = alc883_dac_nids, 10168 .dig_out_nid = ALC883_DIGOUT_NID, 10169 .dig_in_nid = ALC883_DIGIN_NID, 10170 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 10171 .channel_mode = alc883_3ST_6ch_modes, 10172 .need_dac_fix = 1, 10173 .input_mux = &alc883_capture_source, 10174 }, 10175 [ALC883_3ST_6ch] = { 10176 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 10177 .init_verbs = { alc883_init_verbs }, 10178 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10179 .dac_nids = alc883_dac_nids, 10180 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 10181 .channel_mode = alc883_3ST_6ch_modes, 10182 .need_dac_fix = 1, 10183 .input_mux = &alc883_capture_source, 10184 }, 10185 [ALC883_3ST_6ch_INTEL] = { 10186 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer }, 10187 .init_verbs = { alc883_init_verbs }, 10188 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10189 .dac_nids = alc883_dac_nids, 10190 .dig_out_nid = ALC883_DIGOUT_NID, 10191 .dig_in_nid = ALC883_DIGIN_NID, 10192 .slave_dig_outs = alc883_slave_dig_outs, 10193 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes), 10194 .channel_mode = alc883_3ST_6ch_intel_modes, 10195 .need_dac_fix = 1, 10196 .input_mux = &alc883_3stack_6ch_intel, 10197 }, 10198 [ALC889A_INTEL] = { 10199 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer }, 10200 .init_verbs = { alc885_init_verbs, alc885_init_input_verbs, 10201 alc_hp15_unsol_verbs }, 10202 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10203 .dac_nids = alc883_dac_nids, 10204 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids), 10205 .adc_nids = alc889_adc_nids, 10206 .dig_out_nid = ALC883_DIGOUT_NID, 10207 .dig_in_nid = ALC883_DIGIN_NID, 10208 .slave_dig_outs = alc883_slave_dig_outs, 10209 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes), 10210 .channel_mode = alc889_8ch_intel_modes, 10211 .capsrc_nids = alc889_capsrc_nids, 10212 .input_mux = &alc889_capture_source, 10213 .setup = alc889_automute_setup, 10214 .init_hook = alc_automute_amp, 10215 .unsol_event = alc_automute_amp_unsol_event, 10216 .need_dac_fix = 1, 10217 }, 10218 [ALC889_INTEL] = { 10219 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer }, 10220 .init_verbs = { alc885_init_verbs, alc889_init_input_verbs, 10221 alc889_eapd_verbs, alc_hp15_unsol_verbs}, 10222 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10223 .dac_nids = alc883_dac_nids, 10224 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids), 10225 .adc_nids = alc889_adc_nids, 10226 .dig_out_nid = ALC883_DIGOUT_NID, 10227 .dig_in_nid = ALC883_DIGIN_NID, 10228 .slave_dig_outs = alc883_slave_dig_outs, 10229 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes), 10230 .channel_mode = alc889_8ch_intel_modes, 10231 .capsrc_nids = alc889_capsrc_nids, 10232 .input_mux = &alc889_capture_source, 10233 .setup = alc889_automute_setup, 10234 .init_hook = alc889_intel_init_hook, 10235 .unsol_event = alc_automute_amp_unsol_event, 10236 .need_dac_fix = 1, 10237 }, 10238 [ALC883_6ST_DIG] = { 10239 .mixers = { alc883_base_mixer, alc883_chmode_mixer }, 10240 .init_verbs = { alc883_init_verbs }, 10241 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10242 .dac_nids = alc883_dac_nids, 10243 .dig_out_nid = ALC883_DIGOUT_NID, 10244 .dig_in_nid = ALC883_DIGIN_NID, 10245 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes), 10246 .channel_mode = alc883_sixstack_modes, 10247 .input_mux = &alc883_capture_source, 10248 }, 10249 [ALC883_TARGA_DIG] = { 10250 .mixers = { alc883_targa_mixer, alc883_chmode_mixer }, 10251 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs, 10252 alc883_targa_verbs}, 10253 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10254 .dac_nids = alc883_dac_nids, 10255 .dig_out_nid = ALC883_DIGOUT_NID, 10256 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 10257 .channel_mode = alc883_3ST_6ch_modes, 10258 .need_dac_fix = 1, 10259 .input_mux = &alc883_capture_source, 10260 .unsol_event = alc883_targa_unsol_event, 10261 .setup = alc882_targa_setup, 10262 .init_hook = alc882_targa_automute, 10263 }, 10264 [ALC883_TARGA_2ch_DIG] = { 10265 .mixers = { alc883_targa_2ch_mixer}, 10266 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs, 10267 alc883_targa_verbs}, 10268 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10269 .dac_nids = alc883_dac_nids, 10270 .adc_nids = alc883_adc_nids_alt, 10271 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt), 10272 .capsrc_nids = alc883_capsrc_nids, 10273 .dig_out_nid = ALC883_DIGOUT_NID, 10274 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 10275 .channel_mode = alc883_3ST_2ch_modes, 10276 .input_mux = &alc883_capture_source, 10277 .unsol_event = alc883_targa_unsol_event, 10278 .setup = alc882_targa_setup, 10279 .init_hook = alc882_targa_automute, 10280 }, 10281 [ALC883_TARGA_8ch_DIG] = { 10282 .mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer, 10283 alc883_chmode_mixer }, 10284 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs, 10285 alc883_targa_verbs }, 10286 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10287 .dac_nids = alc883_dac_nids, 10288 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev), 10289 .adc_nids = alc883_adc_nids_rev, 10290 .capsrc_nids = alc883_capsrc_nids_rev, 10291 .dig_out_nid = ALC883_DIGOUT_NID, 10292 .dig_in_nid = ALC883_DIGIN_NID, 10293 .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes), 10294 .channel_mode = alc883_4ST_8ch_modes, 10295 .need_dac_fix = 1, 10296 .input_mux = &alc883_capture_source, 10297 .unsol_event = alc883_targa_unsol_event, 10298 .setup = alc882_targa_setup, 10299 .init_hook = alc882_targa_automute, 10300 }, 10301 [ALC883_ACER] = { 10302 .mixers = { alc883_base_mixer }, 10303 /* On TravelMate laptops, GPIO 0 enables the internal speaker 10304 * and the headphone jack. Turn this on and rely on the 10305 * standard mute methods whenever the user wants to turn 10306 * these outputs off. 10307 */ 10308 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs }, 10309 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10310 .dac_nids = alc883_dac_nids, 10311 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 10312 .channel_mode = alc883_3ST_2ch_modes, 10313 .input_mux = &alc883_capture_source, 10314 }, 10315 [ALC883_ACER_ASPIRE] = { 10316 .mixers = { alc883_acer_aspire_mixer }, 10317 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs }, 10318 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10319 .dac_nids = alc883_dac_nids, 10320 .dig_out_nid = ALC883_DIGOUT_NID, 10321 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 10322 .channel_mode = alc883_3ST_2ch_modes, 10323 .input_mux = &alc883_capture_source, 10324 .unsol_event = alc_automute_amp_unsol_event, 10325 .setup = alc883_acer_aspire_setup, 10326 .init_hook = alc_automute_amp, 10327 }, 10328 [ALC888_ACER_ASPIRE_4930G] = { 10329 .mixers = { alc888_acer_aspire_4930g_mixer, 10330 alc883_chmode_mixer }, 10331 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs, 10332 alc888_acer_aspire_4930g_verbs }, 10333 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10334 .dac_nids = alc883_dac_nids, 10335 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev), 10336 .adc_nids = alc883_adc_nids_rev, 10337 .capsrc_nids = alc883_capsrc_nids_rev, 10338 .dig_out_nid = ALC883_DIGOUT_NID, 10339 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 10340 .channel_mode = alc883_3ST_6ch_modes, 10341 .need_dac_fix = 1, 10342 .const_channel_count = 6, 10343 .num_mux_defs = 10344 ARRAY_SIZE(alc888_2_capture_sources), 10345 .input_mux = alc888_2_capture_sources, 10346 .unsol_event = alc_automute_amp_unsol_event, 10347 .setup = alc888_acer_aspire_4930g_setup, 10348 .init_hook = alc_automute_amp, 10349 }, 10350 [ALC888_ACER_ASPIRE_6530G] = { 10351 .mixers = { alc888_acer_aspire_6530_mixer }, 10352 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs, 10353 alc888_acer_aspire_6530g_verbs }, 10354 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10355 .dac_nids = alc883_dac_nids, 10356 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev), 10357 .adc_nids = alc883_adc_nids_rev, 10358 .capsrc_nids = alc883_capsrc_nids_rev, 10359 .dig_out_nid = ALC883_DIGOUT_NID, 10360 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 10361 .channel_mode = alc883_3ST_2ch_modes, 10362 .num_mux_defs = 10363 ARRAY_SIZE(alc888_2_capture_sources), 10364 .input_mux = alc888_acer_aspire_6530_sources, 10365 .unsol_event = alc_automute_amp_unsol_event, 10366 .setup = alc888_acer_aspire_6530g_setup, 10367 .init_hook = alc_automute_amp, 10368 }, 10369 [ALC888_ACER_ASPIRE_8930G] = { 10370 .mixers = { alc889_acer_aspire_8930g_mixer, 10371 alc883_chmode_mixer }, 10372 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs, 10373 alc889_acer_aspire_8930g_verbs, 10374 alc889_eapd_verbs}, 10375 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10376 .dac_nids = alc883_dac_nids, 10377 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids), 10378 .adc_nids = alc889_adc_nids, 10379 .capsrc_nids = alc889_capsrc_nids, 10380 .dig_out_nid = ALC883_DIGOUT_NID, 10381 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 10382 .channel_mode = alc883_3ST_6ch_modes, 10383 .need_dac_fix = 1, 10384 .const_channel_count = 6, 10385 .num_mux_defs = 10386 ARRAY_SIZE(alc889_capture_sources), 10387 .input_mux = alc889_capture_sources, 10388 .unsol_event = alc_automute_amp_unsol_event, 10389 .setup = alc889_acer_aspire_8930g_setup, 10390 .init_hook = alc_automute_amp, 10391#ifdef CONFIG_SND_HDA_POWER_SAVE 10392 .power_hook = alc_power_eapd, 10393#endif 10394 }, 10395 [ALC888_ACER_ASPIRE_7730G] = { 10396 .mixers = { alc883_3ST_6ch_mixer, 10397 alc883_chmode_mixer }, 10398 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs, 10399 alc888_acer_aspire_7730G_verbs }, 10400 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10401 .dac_nids = alc883_dac_nids, 10402 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev), 10403 .adc_nids = alc883_adc_nids_rev, 10404 .capsrc_nids = alc883_capsrc_nids_rev, 10405 .dig_out_nid = ALC883_DIGOUT_NID, 10406 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 10407 .channel_mode = alc883_3ST_6ch_modes, 10408 .need_dac_fix = 1, 10409 .const_channel_count = 6, 10410 .input_mux = &alc883_capture_source, 10411 .unsol_event = alc_automute_amp_unsol_event, 10412 .setup = alc888_acer_aspire_7730g_setup, 10413 .init_hook = alc_automute_amp, 10414 }, 10415 [ALC883_MEDION] = { 10416 .mixers = { alc883_fivestack_mixer, 10417 alc883_chmode_mixer }, 10418 .init_verbs = { alc883_init_verbs, 10419 alc883_medion_eapd_verbs }, 10420 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10421 .dac_nids = alc883_dac_nids, 10422 .adc_nids = alc883_adc_nids_alt, 10423 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt), 10424 .capsrc_nids = alc883_capsrc_nids, 10425 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes), 10426 .channel_mode = alc883_sixstack_modes, 10427 .input_mux = &alc883_capture_source, 10428 }, 10429 [ALC883_MEDION_WIM2160] = { 10430 .mixers = { alc883_medion_wim2160_mixer }, 10431 .init_verbs = { alc883_init_verbs, alc883_medion_wim2160_verbs }, 10432 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10433 .dac_nids = alc883_dac_nids, 10434 .dig_out_nid = ALC883_DIGOUT_NID, 10435 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids), 10436 .adc_nids = alc883_adc_nids, 10437 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 10438 .channel_mode = alc883_3ST_2ch_modes, 10439 .input_mux = &alc883_capture_source, 10440 .unsol_event = alc_automute_amp_unsol_event, 10441 .setup = alc883_medion_wim2160_setup, 10442 .init_hook = alc_automute_amp, 10443 }, 10444 [ALC883_LAPTOP_EAPD] = { 10445 .mixers = { alc883_base_mixer }, 10446 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs }, 10447 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10448 .dac_nids = alc883_dac_nids, 10449 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 10450 .channel_mode = alc883_3ST_2ch_modes, 10451 .input_mux = &alc883_capture_source, 10452 }, 10453 [ALC883_CLEVO_M540R] = { 10454 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 10455 .init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs }, 10456 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10457 .dac_nids = alc883_dac_nids, 10458 .dig_out_nid = ALC883_DIGOUT_NID, 10459 .dig_in_nid = ALC883_DIGIN_NID, 10460 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes), 10461 .channel_mode = alc883_3ST_6ch_clevo_modes, 10462 .need_dac_fix = 1, 10463 .input_mux = &alc883_capture_source, 10464 /* This machine has the hardware HP auto-muting, thus 10465 * we need no software mute via unsol event 10466 */ 10467 }, 10468 [ALC883_CLEVO_M720] = { 10469 .mixers = { alc883_clevo_m720_mixer }, 10470 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs }, 10471 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10472 .dac_nids = alc883_dac_nids, 10473 .dig_out_nid = ALC883_DIGOUT_NID, 10474 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 10475 .channel_mode = alc883_3ST_2ch_modes, 10476 .input_mux = &alc883_capture_source, 10477 .unsol_event = alc883_clevo_m720_unsol_event, 10478 .setup = alc883_clevo_m720_setup, 10479 .init_hook = alc883_clevo_m720_init_hook, 10480 }, 10481 [ALC883_LENOVO_101E_2ch] = { 10482 .mixers = { alc883_lenovo_101e_2ch_mixer}, 10483 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs}, 10484 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10485 .dac_nids = alc883_dac_nids, 10486 .adc_nids = alc883_adc_nids_alt, 10487 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt), 10488 .capsrc_nids = alc883_capsrc_nids, 10489 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 10490 .channel_mode = alc883_3ST_2ch_modes, 10491 .input_mux = &alc883_lenovo_101e_capture_source, 10492 .unsol_event = alc883_lenovo_101e_unsol_event, 10493 .init_hook = alc883_lenovo_101e_all_automute, 10494 }, 10495 [ALC883_LENOVO_NB0763] = { 10496 .mixers = { alc883_lenovo_nb0763_mixer }, 10497 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs}, 10498 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10499 .dac_nids = alc883_dac_nids, 10500 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 10501 .channel_mode = alc883_3ST_2ch_modes, 10502 .need_dac_fix = 1, 10503 .input_mux = &alc883_lenovo_nb0763_capture_source, 10504 .unsol_event = alc_automute_amp_unsol_event, 10505 .setup = alc883_lenovo_nb0763_setup, 10506 .init_hook = alc_automute_amp, 10507 }, 10508 [ALC888_LENOVO_MS7195_DIG] = { 10509 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 10510 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs}, 10511 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10512 .dac_nids = alc883_dac_nids, 10513 .dig_out_nid = ALC883_DIGOUT_NID, 10514 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 10515 .channel_mode = alc883_3ST_6ch_modes, 10516 .need_dac_fix = 1, 10517 .input_mux = &alc883_capture_source, 10518 .unsol_event = alc883_lenovo_ms7195_unsol_event, 10519 .init_hook = alc888_lenovo_ms7195_front_automute, 10520 }, 10521 [ALC883_HAIER_W66] = { 10522 .mixers = { alc883_targa_2ch_mixer}, 10523 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs}, 10524 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10525 .dac_nids = alc883_dac_nids, 10526 .dig_out_nid = ALC883_DIGOUT_NID, 10527 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 10528 .channel_mode = alc883_3ST_2ch_modes, 10529 .input_mux = &alc883_capture_source, 10530 .unsol_event = alc_automute_amp_unsol_event, 10531 .setup = alc883_haier_w66_setup, 10532 .init_hook = alc_automute_amp, 10533 }, 10534 [ALC888_3ST_HP] = { 10535 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 10536 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs }, 10537 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10538 .dac_nids = alc883_dac_nids, 10539 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes), 10540 .channel_mode = alc888_3st_hp_modes, 10541 .need_dac_fix = 1, 10542 .input_mux = &alc883_capture_source, 10543 .unsol_event = alc_automute_amp_unsol_event, 10544 .setup = alc888_3st_hp_setup, 10545 .init_hook = alc_automute_amp, 10546 }, 10547 [ALC888_6ST_DELL] = { 10548 .mixers = { alc883_base_mixer, alc883_chmode_mixer }, 10549 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs }, 10550 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10551 .dac_nids = alc883_dac_nids, 10552 .dig_out_nid = ALC883_DIGOUT_NID, 10553 .dig_in_nid = ALC883_DIGIN_NID, 10554 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes), 10555 .channel_mode = alc883_sixstack_modes, 10556 .input_mux = &alc883_capture_source, 10557 .unsol_event = alc_automute_amp_unsol_event, 10558 .setup = alc888_6st_dell_setup, 10559 .init_hook = alc_automute_amp, 10560 }, 10561 [ALC883_MITAC] = { 10562 .mixers = { alc883_mitac_mixer }, 10563 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs }, 10564 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10565 .dac_nids = alc883_dac_nids, 10566 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 10567 .channel_mode = alc883_3ST_2ch_modes, 10568 .input_mux = &alc883_capture_source, 10569 .unsol_event = alc_automute_amp_unsol_event, 10570 .setup = alc883_mitac_setup, 10571 .init_hook = alc_automute_amp, 10572 }, 10573 [ALC883_FUJITSU_PI2515] = { 10574 .mixers = { alc883_2ch_fujitsu_pi2515_mixer }, 10575 .init_verbs = { alc883_init_verbs, 10576 alc883_2ch_fujitsu_pi2515_verbs}, 10577 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10578 .dac_nids = alc883_dac_nids, 10579 .dig_out_nid = ALC883_DIGOUT_NID, 10580 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 10581 .channel_mode = alc883_3ST_2ch_modes, 10582 .input_mux = &alc883_fujitsu_pi2515_capture_source, 10583 .unsol_event = alc_automute_amp_unsol_event, 10584 .setup = alc883_2ch_fujitsu_pi2515_setup, 10585 .init_hook = alc_automute_amp, 10586 }, 10587 [ALC888_FUJITSU_XA3530] = { 10588 .mixers = { alc888_base_mixer, alc883_chmode_mixer }, 10589 .init_verbs = { alc883_init_verbs, 10590 alc888_fujitsu_xa3530_verbs }, 10591 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10592 .dac_nids = alc883_dac_nids, 10593 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev), 10594 .adc_nids = alc883_adc_nids_rev, 10595 .capsrc_nids = alc883_capsrc_nids_rev, 10596 .dig_out_nid = ALC883_DIGOUT_NID, 10597 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes), 10598 .channel_mode = alc888_4ST_8ch_intel_modes, 10599 .num_mux_defs = 10600 ARRAY_SIZE(alc888_2_capture_sources), 10601 .input_mux = alc888_2_capture_sources, 10602 .unsol_event = alc_automute_amp_unsol_event, 10603 .setup = alc888_fujitsu_xa3530_setup, 10604 .init_hook = alc_automute_amp, 10605 }, 10606 [ALC888_LENOVO_SKY] = { 10607 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer }, 10608 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs}, 10609 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10610 .dac_nids = alc883_dac_nids, 10611 .dig_out_nid = ALC883_DIGOUT_NID, 10612 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes), 10613 .channel_mode = alc883_sixstack_modes, 10614 .need_dac_fix = 1, 10615 .input_mux = &alc883_lenovo_sky_capture_source, 10616 .unsol_event = alc_automute_amp_unsol_event, 10617 .setup = alc888_lenovo_sky_setup, 10618 .init_hook = alc_automute_amp, 10619 }, 10620 [ALC888_ASUS_M90V] = { 10621 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 10622 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs }, 10623 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10624 .dac_nids = alc883_dac_nids, 10625 .dig_out_nid = ALC883_DIGOUT_NID, 10626 .dig_in_nid = ALC883_DIGIN_NID, 10627 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 10628 .channel_mode = alc883_3ST_6ch_modes, 10629 .need_dac_fix = 1, 10630 .input_mux = &alc883_fujitsu_pi2515_capture_source, 10631 .unsol_event = alc_sku_unsol_event, 10632 .setup = alc883_mode2_setup, 10633 .init_hook = alc_inithook, 10634 }, 10635 [ALC888_ASUS_EEE1601] = { 10636 .mixers = { alc883_asus_eee1601_mixer }, 10637 .cap_mixer = alc883_asus_eee1601_cap_mixer, 10638 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs }, 10639 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10640 .dac_nids = alc883_dac_nids, 10641 .dig_out_nid = ALC883_DIGOUT_NID, 10642 .dig_in_nid = ALC883_DIGIN_NID, 10643 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 10644 .channel_mode = alc883_3ST_2ch_modes, 10645 .need_dac_fix = 1, 10646 .input_mux = &alc883_asus_eee1601_capture_source, 10647 .unsol_event = alc_sku_unsol_event, 10648 .init_hook = alc883_eee1601_inithook, 10649 }, 10650 [ALC1200_ASUS_P5Q] = { 10651 .mixers = { alc883_base_mixer, alc883_chmode_mixer }, 10652 .init_verbs = { alc883_init_verbs }, 10653 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10654 .dac_nids = alc883_dac_nids, 10655 .dig_out_nid = ALC1200_DIGOUT_NID, 10656 .dig_in_nid = ALC883_DIGIN_NID, 10657 .slave_dig_outs = alc1200_slave_dig_outs, 10658 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes), 10659 .channel_mode = alc883_sixstack_modes, 10660 .input_mux = &alc883_capture_source, 10661 }, 10662 [ALC889A_MB31] = { 10663 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer}, 10664 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs, 10665 alc880_gpio1_init_verbs }, 10666 .adc_nids = alc883_adc_nids, 10667 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids), 10668 .capsrc_nids = alc883_capsrc_nids, 10669 .dac_nids = alc883_dac_nids, 10670 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10671 .channel_mode = alc889A_mb31_6ch_modes, 10672 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes), 10673 .input_mux = &alc889A_mb31_capture_source, 10674 .dig_out_nid = ALC883_DIGOUT_NID, 10675 .unsol_event = alc889A_mb31_unsol_event, 10676 .init_hook = alc889A_mb31_automute, 10677 }, 10678 [ALC883_SONY_VAIO_TT] = { 10679 .mixers = { alc883_vaiott_mixer }, 10680 .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs }, 10681 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 10682 .dac_nids = alc883_dac_nids, 10683 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 10684 .channel_mode = alc883_3ST_2ch_modes, 10685 .input_mux = &alc883_capture_source, 10686 .unsol_event = alc_automute_amp_unsol_event, 10687 .setup = alc883_vaiott_setup, 10688 .init_hook = alc_automute_amp, 10689 }, 10690}; 10691 10692 10693/* 10694 * Pin config fixes 10695 */ 10696enum { 10697 PINFIX_ABIT_AW9D_MAX, 10698 PINFIX_LENOVO_Y530, 10699 PINFIX_PB_M5210, 10700 PINFIX_ACER_ASPIRE_7736, 10701}; 10702 10703static const struct alc_fixup alc882_fixups[] = { 10704 [PINFIX_ABIT_AW9D_MAX] = { 10705 .type = ALC_FIXUP_PINS, 10706 .v.pins = (const struct alc_pincfg[]) { 10707 { 0x15, 0x01080104 }, /* side */ 10708 { 0x16, 0x01011012 }, /* rear */ 10709 { 0x17, 0x01016011 }, /* clfe */ 10710 { } 10711 } 10712 }, 10713 [PINFIX_LENOVO_Y530] = { 10714 .type = ALC_FIXUP_PINS, 10715 .v.pins = (const struct alc_pincfg[]) { 10716 { 0x15, 0x99130112 }, /* rear int speakers */ 10717 { 0x16, 0x99130111 }, /* subwoofer */ 10718 { } 10719 } 10720 }, 10721 [PINFIX_PB_M5210] = { 10722 .type = ALC_FIXUP_VERBS, 10723 .v.verbs = (const struct hda_verb[]) { 10724 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 }, 10725 {} 10726 } 10727 }, 10728 [PINFIX_ACER_ASPIRE_7736] = { 10729 .type = ALC_FIXUP_SKU, 10730 .v.sku = ALC_FIXUP_SKU_IGNORE, 10731 }, 10732}; 10733 10734static struct snd_pci_quirk alc882_fixup_tbl[] = { 10735 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210), 10736 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", PINFIX_LENOVO_Y530), 10737 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX), 10738 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", PINFIX_ACER_ASPIRE_7736), 10739 {} 10740}; 10741 10742/* 10743 * BIOS auto configuration 10744 */ 10745static int alc882_auto_create_input_ctls(struct hda_codec *codec, 10746 const struct auto_pin_cfg *cfg) 10747{ 10748 return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22); 10749} 10750 10751static void alc882_auto_set_output_and_unmute(struct hda_codec *codec, 10752 hda_nid_t nid, int pin_type, 10753 hda_nid_t dac) 10754{ 10755 int idx; 10756 10757 /* set as output */ 10758 alc_set_pin_output(codec, nid, pin_type); 10759 10760 if (dac == 0x25) 10761 idx = 4; 10762 else if (dac >= 0x02 && dac <= 0x05) 10763 idx = dac - 2; 10764 else 10765 return; 10766 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx); 10767} 10768 10769static void alc882_auto_init_multi_out(struct hda_codec *codec) 10770{ 10771 struct alc_spec *spec = codec->spec; 10772 int i; 10773 10774 for (i = 0; i <= HDA_SIDE; i++) { 10775 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 10776 int pin_type = get_pin_type(spec->autocfg.line_out_type); 10777 if (nid) 10778 alc882_auto_set_output_and_unmute(codec, nid, pin_type, 10779 spec->multiout.dac_nids[i]); 10780 } 10781} 10782 10783static void alc882_auto_init_hp_out(struct hda_codec *codec) 10784{ 10785 struct alc_spec *spec = codec->spec; 10786 hda_nid_t pin, dac; 10787 int i; 10788 10789 if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT) { 10790 for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) { 10791 pin = spec->autocfg.hp_pins[i]; 10792 if (!pin) 10793 break; 10794 dac = spec->multiout.hp_nid; 10795 if (!dac) 10796 dac = spec->multiout.dac_nids[0]; /* to front */ 10797 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, dac); 10798 } 10799 } 10800 10801 if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT) { 10802 for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) { 10803 pin = spec->autocfg.speaker_pins[i]; 10804 if (!pin) 10805 break; 10806 dac = spec->multiout.extra_out_nid[0]; 10807 if (!dac) 10808 dac = spec->multiout.dac_nids[0]; /* to front */ 10809 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac); 10810 } 10811 } 10812} 10813 10814static void alc882_auto_init_analog_input(struct hda_codec *codec) 10815{ 10816 struct alc_spec *spec = codec->spec; 10817 struct auto_pin_cfg *cfg = &spec->autocfg; 10818 int i; 10819 10820 for (i = 0; i < cfg->num_inputs; i++) { 10821 hda_nid_t nid = cfg->inputs[i].pin; 10822 alc_set_input_pin(codec, nid, cfg->inputs[i].type); 10823 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) 10824 snd_hda_codec_write(codec, nid, 0, 10825 AC_VERB_SET_AMP_GAIN_MUTE, 10826 AMP_OUT_MUTE); 10827 } 10828} 10829 10830static void alc882_auto_init_input_src(struct hda_codec *codec) 10831{ 10832 struct alc_spec *spec = codec->spec; 10833 int c; 10834 10835 for (c = 0; c < spec->num_adc_nids; c++) { 10836 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS]; 10837 hda_nid_t nid = spec->capsrc_nids[c]; 10838 unsigned int mux_idx; 10839 const struct hda_input_mux *imux; 10840 int conns, mute, idx, item; 10841 10842 conns = snd_hda_get_connections(codec, nid, conn_list, 10843 ARRAY_SIZE(conn_list)); 10844 if (conns < 0) 10845 continue; 10846 mux_idx = c >= spec->num_mux_defs ? 0 : c; 10847 imux = &spec->input_mux[mux_idx]; 10848 if (!imux->num_items && mux_idx > 0) 10849 imux = &spec->input_mux[0]; 10850 for (idx = 0; idx < conns; idx++) { 10851 /* if the current connection is the selected one, 10852 * unmute it as default - otherwise mute it 10853 */ 10854 mute = AMP_IN_MUTE(idx); 10855 for (item = 0; item < imux->num_items; item++) { 10856 if (imux->items[item].index == idx) { 10857 if (spec->cur_mux[c] == item) 10858 mute = AMP_IN_UNMUTE(idx); 10859 break; 10860 } 10861 } 10862 /* check if we have a selector or mixer 10863 * we could check for the widget type instead, but 10864 * just check for Amp-In presence (in case of mixer 10865 * without amp-in there is something wrong, this 10866 * function shouldn't be used or capsrc nid is wrong) 10867 */ 10868 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) 10869 snd_hda_codec_write(codec, nid, 0, 10870 AC_VERB_SET_AMP_GAIN_MUTE, 10871 mute); 10872 else if (mute != AMP_IN_MUTE(idx)) 10873 snd_hda_codec_write(codec, nid, 0, 10874 AC_VERB_SET_CONNECT_SEL, 10875 idx); 10876 } 10877 } 10878} 10879 10880/* add mic boosts if needed */ 10881static int alc_auto_add_mic_boost(struct hda_codec *codec) 10882{ 10883 struct alc_spec *spec = codec->spec; 10884 struct auto_pin_cfg *cfg = &spec->autocfg; 10885 int i, err; 10886 int type_idx = 0; 10887 hda_nid_t nid; 10888 const char *prev_label = NULL; 10889 10890 for (i = 0; i < cfg->num_inputs; i++) { 10891 if (cfg->inputs[i].type > AUTO_PIN_MIC) 10892 break; 10893 nid = cfg->inputs[i].pin; 10894 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) { 10895 const char *label; 10896 char boost_label[32]; 10897 10898 label = hda_get_autocfg_input_label(codec, cfg, i); 10899 if (prev_label && !strcmp(label, prev_label)) 10900 type_idx++; 10901 else 10902 type_idx = 0; 10903 prev_label = label; 10904 10905 snprintf(boost_label, sizeof(boost_label), 10906 "%s Boost Volume", label); 10907 err = add_control(spec, ALC_CTL_WIDGET_VOL, 10908 boost_label, type_idx, 10909 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT)); 10910 if (err < 0) 10911 return err; 10912 } 10913 } 10914 return 0; 10915} 10916 10917/* almost identical with ALC880 parser... */ 10918static int alc882_parse_auto_config(struct hda_codec *codec) 10919{ 10920 struct alc_spec *spec = codec->spec; 10921 static hda_nid_t alc882_ignore[] = { 0x1d, 0 }; 10922 int err; 10923 10924 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 10925 alc882_ignore); 10926 if (err < 0) 10927 return err; 10928 if (!spec->autocfg.line_outs) 10929 return 0; /* can't find valid BIOS pin config */ 10930 10931 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg); 10932 if (err < 0) 10933 return err; 10934 err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg); 10935 if (err < 0) 10936 return err; 10937 err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0], 10938 "Headphone"); 10939 if (err < 0) 10940 return err; 10941 err = alc880_auto_create_extra_out(spec, 10942 spec->autocfg.speaker_pins[0], 10943 "Speaker"); 10944 if (err < 0) 10945 return err; 10946 err = alc882_auto_create_input_ctls(codec, &spec->autocfg); 10947 if (err < 0) 10948 return err; 10949 10950 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 10951 10952 alc_auto_parse_digital(codec); 10953 10954 if (spec->kctls.list) 10955 add_mixer(spec, spec->kctls.list); 10956 10957 add_verb(spec, alc883_auto_init_verbs); 10958 /* if ADC 0x07 is available, initialize it, too */ 10959 if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN) 10960 add_verb(spec, alc882_adc1_init_verbs); 10961 10962 spec->num_mux_defs = 1; 10963 spec->input_mux = &spec->private_imux[0]; 10964 10965 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0); 10966 10967 err = alc_auto_add_mic_boost(codec); 10968 if (err < 0) 10969 return err; 10970 10971 return 1; /* config found */ 10972} 10973 10974/* additional initialization for auto-configuration model */ 10975static void alc882_auto_init(struct hda_codec *codec) 10976{ 10977 struct alc_spec *spec = codec->spec; 10978 alc882_auto_init_multi_out(codec); 10979 alc882_auto_init_hp_out(codec); 10980 alc882_auto_init_analog_input(codec); 10981 alc882_auto_init_input_src(codec); 10982 alc_auto_init_digital(codec); 10983 if (spec->unsol_event) 10984 alc_inithook(codec); 10985} 10986 10987static int patch_alc882(struct hda_codec *codec) 10988{ 10989 struct alc_spec *spec; 10990 int err, board_config; 10991 10992 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 10993 if (spec == NULL) 10994 return -ENOMEM; 10995 10996 codec->spec = spec; 10997 10998 switch (codec->vendor_id) { 10999 case 0x10ec0882: 11000 case 0x10ec0885: 11001 break; 11002 default: 11003 /* ALC883 and variants */ 11004 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 11005 break; 11006 } 11007 11008 board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST, 11009 alc882_models, 11010 alc882_cfg_tbl); 11011 11012 if (board_config < 0 || board_config >= ALC882_MODEL_LAST) 11013 board_config = snd_hda_check_board_codec_sid_config(codec, 11014 ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl); 11015 11016 if (board_config < 0 || board_config >= ALC882_MODEL_LAST) { 11017 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 11018 codec->chip_name); 11019 board_config = ALC882_AUTO; 11020 } 11021 11022 if (board_config == ALC882_AUTO) { 11023 alc_pick_fixup(codec, NULL, alc882_fixup_tbl, alc882_fixups); 11024 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE); 11025 } 11026 11027 alc_auto_parse_customize_define(codec); 11028 11029 if (board_config == ALC882_AUTO) { 11030 /* automatic parse from the BIOS config */ 11031 err = alc882_parse_auto_config(codec); 11032 if (err < 0) { 11033 alc_free(codec); 11034 return err; 11035 } else if (!err) { 11036 printk(KERN_INFO 11037 "hda_codec: Cannot set up configuration " 11038 "from BIOS. Using base mode...\n"); 11039 board_config = ALC882_3ST_DIG; 11040 } 11041 } 11042 11043 if (has_cdefine_beep(codec)) { 11044 err = snd_hda_attach_beep_device(codec, 0x1); 11045 if (err < 0) { 11046 alc_free(codec); 11047 return err; 11048 } 11049 } 11050 11051 if (board_config != ALC882_AUTO) 11052 setup_preset(codec, &alc882_presets[board_config]); 11053 11054 spec->stream_analog_playback = &alc882_pcm_analog_playback; 11055 spec->stream_analog_capture = &alc882_pcm_analog_capture; 11056 /* FIXME: setup DAC5 */ 11057 /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/ 11058 spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture; 11059 11060 spec->stream_digital_playback = &alc882_pcm_digital_playback; 11061 spec->stream_digital_capture = &alc882_pcm_digital_capture; 11062 11063 if (!spec->adc_nids && spec->input_mux) { 11064 int i, j; 11065 spec->num_adc_nids = 0; 11066 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) { 11067 const struct hda_input_mux *imux = spec->input_mux; 11068 hda_nid_t cap; 11069 hda_nid_t items[16]; 11070 hda_nid_t nid = alc882_adc_nids[i]; 11071 unsigned int wcap = get_wcaps(codec, nid); 11072 /* get type */ 11073 wcap = get_wcaps_type(wcap); 11074 if (wcap != AC_WID_AUD_IN) 11075 continue; 11076 spec->private_adc_nids[spec->num_adc_nids] = nid; 11077 err = snd_hda_get_connections(codec, nid, &cap, 1); 11078 if (err < 0) 11079 continue; 11080 err = snd_hda_get_connections(codec, cap, items, 11081 ARRAY_SIZE(items)); 11082 if (err < 0) 11083 continue; 11084 for (j = 0; j < imux->num_items; j++) 11085 if (imux->items[j].index >= err) 11086 break; 11087 if (j < imux->num_items) 11088 continue; 11089 spec->private_capsrc_nids[spec->num_adc_nids] = cap; 11090 spec->num_adc_nids++; 11091 } 11092 spec->adc_nids = spec->private_adc_nids; 11093 spec->capsrc_nids = spec->private_capsrc_nids; 11094 } 11095 11096 set_capture_mixer(codec); 11097 11098 if (has_cdefine_beep(codec)) 11099 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 11100 11101 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE); 11102 11103 spec->vmaster_nid = 0x0c; 11104 11105 codec->patch_ops = alc_patch_ops; 11106 if (board_config == ALC882_AUTO) 11107 spec->init_hook = alc882_auto_init; 11108 11109 alc_init_jacks(codec); 11110#ifdef CONFIG_SND_HDA_POWER_SAVE 11111 if (!spec->loopback.amplist) 11112 spec->loopback.amplist = alc882_loopbacks; 11113#endif 11114 11115 return 0; 11116} 11117 11118 11119/* 11120 * ALC262 support 11121 */ 11122 11123#define ALC262_DIGOUT_NID ALC880_DIGOUT_NID 11124#define ALC262_DIGIN_NID ALC880_DIGIN_NID 11125 11126#define alc262_dac_nids alc260_dac_nids 11127#define alc262_adc_nids alc882_adc_nids 11128#define alc262_adc_nids_alt alc882_adc_nids_alt 11129#define alc262_capsrc_nids alc882_capsrc_nids 11130#define alc262_capsrc_nids_alt alc882_capsrc_nids_alt 11131 11132#define alc262_modes alc260_modes 11133#define alc262_capture_source alc882_capture_source 11134 11135static hda_nid_t alc262_dmic_adc_nids[1] = { 11136 /* ADC0 */ 11137 0x09 11138}; 11139 11140static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 }; 11141 11142static struct snd_kcontrol_new alc262_base_mixer[] = { 11143 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 11144 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 11145 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 11146 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 11147 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 11148 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 11149 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 11150 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 11151 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 11152 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 11153 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 11154 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT), 11155 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT), 11156 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 11157 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 11158 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT), 11159 { } /* end */ 11160}; 11161 11162/* update HP, line and mono-out pins according to the master switch */ 11163static void alc262_hp_master_update(struct hda_codec *codec) 11164{ 11165 struct alc_spec *spec = codec->spec; 11166 int val = spec->master_sw; 11167 11168 /* HP & line-out */ 11169 snd_hda_codec_write_cache(codec, 0x1b, 0, 11170 AC_VERB_SET_PIN_WIDGET_CONTROL, 11171 val ? PIN_HP : 0); 11172 snd_hda_codec_write_cache(codec, 0x15, 0, 11173 AC_VERB_SET_PIN_WIDGET_CONTROL, 11174 val ? PIN_HP : 0); 11175 /* mono (speaker) depending on the HP jack sense */ 11176 val = val && !spec->jack_present; 11177 snd_hda_codec_write_cache(codec, 0x16, 0, 11178 AC_VERB_SET_PIN_WIDGET_CONTROL, 11179 val ? PIN_OUT : 0); 11180} 11181 11182static void alc262_hp_bpc_automute(struct hda_codec *codec) 11183{ 11184 struct alc_spec *spec = codec->spec; 11185 11186 spec->jack_present = snd_hda_jack_detect(codec, 0x1b); 11187 alc262_hp_master_update(codec); 11188} 11189 11190static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res) 11191{ 11192 if ((res >> 26) != ALC880_HP_EVENT) 11193 return; 11194 alc262_hp_bpc_automute(codec); 11195} 11196 11197static void alc262_hp_wildwest_automute(struct hda_codec *codec) 11198{ 11199 struct alc_spec *spec = codec->spec; 11200 11201 spec->jack_present = snd_hda_jack_detect(codec, 0x15); 11202 alc262_hp_master_update(codec); 11203} 11204 11205static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec, 11206 unsigned int res) 11207{ 11208 if ((res >> 26) != ALC880_HP_EVENT) 11209 return; 11210 alc262_hp_wildwest_automute(codec); 11211} 11212 11213#define alc262_hp_master_sw_get alc260_hp_master_sw_get 11214 11215static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol, 11216 struct snd_ctl_elem_value *ucontrol) 11217{ 11218 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 11219 struct alc_spec *spec = codec->spec; 11220 int val = !!*ucontrol->value.integer.value; 11221 11222 if (val == spec->master_sw) 11223 return 0; 11224 spec->master_sw = val; 11225 alc262_hp_master_update(codec); 11226 return 1; 11227} 11228 11229#define ALC262_HP_MASTER_SWITCH \ 11230 { \ 11231 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 11232 .name = "Master Playback Switch", \ 11233 .info = snd_ctl_boolean_mono_info, \ 11234 .get = alc262_hp_master_sw_get, \ 11235 .put = alc262_hp_master_sw_put, \ 11236 }, \ 11237 { \ 11238 .iface = NID_MAPPING, \ 11239 .name = "Master Playback Switch", \ 11240 .private_value = 0x15 | (0x16 << 8) | (0x1b << 16), \ 11241 } 11242 11243 11244static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = { 11245 ALC262_HP_MASTER_SWITCH, 11246 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 11247 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT), 11248 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 11249 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0, 11250 HDA_OUTPUT), 11251 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0, 11252 HDA_OUTPUT), 11253 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 11254 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 11255 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 11256 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 11257 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 11258 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT), 11259 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 11260 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 11261 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 11262 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 11263 HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT), 11264 HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT), 11265 { } /* end */ 11266}; 11267 11268static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = { 11269 ALC262_HP_MASTER_SWITCH, 11270 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 11271 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 11272 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 11273 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 11274 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0, 11275 HDA_OUTPUT), 11276 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0, 11277 HDA_OUTPUT), 11278 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT), 11279 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT), 11280 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x1a, 0, HDA_INPUT), 11281 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT), 11282 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT), 11283 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 11284 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 11285 { } /* end */ 11286}; 11287 11288static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = { 11289 HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 11290 HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 11291 HDA_CODEC_VOLUME("Rear Mic Boost Volume", 0x18, 0, HDA_INPUT), 11292 { } /* end */ 11293}; 11294 11295/* mute/unmute internal speaker according to the hp jack and mute state */ 11296static void alc262_hp_t5735_setup(struct hda_codec *codec) 11297{ 11298 struct alc_spec *spec = codec->spec; 11299 11300 spec->autocfg.hp_pins[0] = 0x15; 11301 spec->autocfg.speaker_pins[0] = 0x14; 11302} 11303 11304static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = { 11305 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 11306 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 11307 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 11308 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 11309 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 11310 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 11311 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 11312 { } /* end */ 11313}; 11314 11315static struct hda_verb alc262_hp_t5735_verbs[] = { 11316 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 11317 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 11318 11319 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 11320 { } 11321}; 11322 11323static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = { 11324 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 11325 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 11326 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT), 11327 HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT), 11328 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT), 11329 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT), 11330 { } /* end */ 11331}; 11332 11333static struct hda_verb alc262_hp_rp5700_verbs[] = { 11334 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11335 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11336 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 11337 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 11338 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 11339 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 11340 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 11341 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 11342 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))}, 11343 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))}, 11344 {} 11345}; 11346 11347static struct hda_input_mux alc262_hp_rp5700_capture_source = { 11348 .num_items = 1, 11349 .items = { 11350 { "Line", 0x1 }, 11351 }, 11352}; 11353 11354/* bind hp and internal speaker mute (with plug check) as master switch */ 11355static void alc262_hippo_master_update(struct hda_codec *codec) 11356{ 11357 struct alc_spec *spec = codec->spec; 11358 hda_nid_t hp_nid = spec->autocfg.hp_pins[0]; 11359 hda_nid_t line_nid = spec->autocfg.line_out_pins[0]; 11360 hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0]; 11361 unsigned int mute; 11362 11363 /* HP */ 11364 mute = spec->master_sw ? 0 : HDA_AMP_MUTE; 11365 snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0, 11366 HDA_AMP_MUTE, mute); 11367 /* mute internal speaker per jack sense */ 11368 if (spec->jack_present) 11369 mute = HDA_AMP_MUTE; 11370 if (line_nid) 11371 snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0, 11372 HDA_AMP_MUTE, mute); 11373 if (speaker_nid && speaker_nid != line_nid) 11374 snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0, 11375 HDA_AMP_MUTE, mute); 11376} 11377 11378#define alc262_hippo_master_sw_get alc262_hp_master_sw_get 11379 11380static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol, 11381 struct snd_ctl_elem_value *ucontrol) 11382{ 11383 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 11384 struct alc_spec *spec = codec->spec; 11385 int val = !!*ucontrol->value.integer.value; 11386 11387 if (val == spec->master_sw) 11388 return 0; 11389 spec->master_sw = val; 11390 alc262_hippo_master_update(codec); 11391 return 1; 11392} 11393 11394#define ALC262_HIPPO_MASTER_SWITCH \ 11395 { \ 11396 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 11397 .name = "Master Playback Switch", \ 11398 .info = snd_ctl_boolean_mono_info, \ 11399 .get = alc262_hippo_master_sw_get, \ 11400 .put = alc262_hippo_master_sw_put, \ 11401 }, \ 11402 { \ 11403 .iface = NID_MAPPING, \ 11404 .name = "Master Playback Switch", \ 11405 .subdevice = SUBDEV_HP(0) | (SUBDEV_LINE(0) << 8) | \ 11406 (SUBDEV_SPEAKER(0) << 16), \ 11407 } 11408 11409static struct snd_kcontrol_new alc262_hippo_mixer[] = { 11410 ALC262_HIPPO_MASTER_SWITCH, 11411 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 11412 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 11413 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 11414 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 11415 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 11416 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 11417 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 11418 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 11419 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 11420 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 11421 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT), 11422 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 11423 { } /* end */ 11424}; 11425 11426static struct snd_kcontrol_new alc262_hippo1_mixer[] = { 11427 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 11428 ALC262_HIPPO_MASTER_SWITCH, 11429 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 11430 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 11431 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 11432 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 11433 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 11434 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 11435 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 11436 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 11437 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 11438 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT), 11439 { } /* end */ 11440}; 11441 11442/* mute/unmute internal speaker according to the hp jack and mute state */ 11443static void alc262_hippo_automute(struct hda_codec *codec) 11444{ 11445 struct alc_spec *spec = codec->spec; 11446 hda_nid_t hp_nid = spec->autocfg.hp_pins[0]; 11447 11448 spec->jack_present = snd_hda_jack_detect(codec, hp_nid); 11449 alc262_hippo_master_update(codec); 11450} 11451 11452static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res) 11453{ 11454 if ((res >> 26) != ALC880_HP_EVENT) 11455 return; 11456 alc262_hippo_automute(codec); 11457} 11458 11459static void alc262_hippo_setup(struct hda_codec *codec) 11460{ 11461 struct alc_spec *spec = codec->spec; 11462 11463 spec->autocfg.hp_pins[0] = 0x15; 11464 spec->autocfg.speaker_pins[0] = 0x14; 11465} 11466 11467static void alc262_hippo1_setup(struct hda_codec *codec) 11468{ 11469 struct alc_spec *spec = codec->spec; 11470 11471 spec->autocfg.hp_pins[0] = 0x1b; 11472 spec->autocfg.speaker_pins[0] = 0x14; 11473} 11474 11475 11476static struct snd_kcontrol_new alc262_sony_mixer[] = { 11477 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 11478 ALC262_HIPPO_MASTER_SWITCH, 11479 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 11480 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 11481 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 11482 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 11483 { } /* end */ 11484}; 11485 11486static struct snd_kcontrol_new alc262_benq_t31_mixer[] = { 11487 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 11488 ALC262_HIPPO_MASTER_SWITCH, 11489 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 11490 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 11491 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 11492 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 11493 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 11494 { } /* end */ 11495}; 11496 11497static struct snd_kcontrol_new alc262_tyan_mixer[] = { 11498 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 11499 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT), 11500 HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT), 11501 HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT), 11502 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 11503 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 11504 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 11505 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 11506 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 11507 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 11508 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 11509 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT), 11510 { } /* end */ 11511}; 11512 11513static struct hda_verb alc262_tyan_verbs[] = { 11514 /* Headphone automute */ 11515 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 11516 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 11517 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 11518 11519 /* P11 AUX_IN, white 4-pin connector */ 11520 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 11521 {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1}, 11522 {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93}, 11523 {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19}, 11524 11525 {} 11526}; 11527 11528/* unsolicited event for HP jack sensing */ 11529static void alc262_tyan_setup(struct hda_codec *codec) 11530{ 11531 struct alc_spec *spec = codec->spec; 11532 11533 spec->autocfg.hp_pins[0] = 0x1b; 11534 spec->autocfg.speaker_pins[0] = 0x15; 11535} 11536 11537 11538#define alc262_capture_mixer alc882_capture_mixer 11539#define alc262_capture_alt_mixer alc882_capture_alt_mixer 11540 11541/* 11542 * generic initialization of ADC, input mixers and output mixers 11543 */ 11544static struct hda_verb alc262_init_verbs[] = { 11545 /* 11546 * Unmute ADC0-2 and set the default input to mic-in 11547 */ 11548 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 11549 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11550 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 11551 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11552 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 11553 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11554 11555 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 11556 * mixer widget 11557 * Note: PASD motherboards uses the Line In 2 as the input for 11558 * front panel mic (mic 2) 11559 */ 11560 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 11561 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 11562 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 11563 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 11564 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 11565 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 11566 11567 /* 11568 * Set up output mixers (0x0c - 0x0e) 11569 */ 11570 /* set vol=0 to output mixers */ 11571 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 11572 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 11573 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 11574 /* set up input amps for analog loopback */ 11575 /* Amp Indices: DAC = 0, mixer = 1 */ 11576 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11577 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11578 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11579 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11580 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11581 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11582 11583 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 11584 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 11585 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 11586 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 11587 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 11588 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 11589 11590 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 11591 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 11592 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 11593 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 11594 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 11595 11596 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 11597 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 11598 11599 /* FIXME: use matrix-type input source selection */ 11600 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 11601 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 11602 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 11603 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 11604 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 11605 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 11606 /* Input mixer2 */ 11607 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 11608 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 11609 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 11610 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 11611 /* Input mixer3 */ 11612 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 11613 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 11614 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 11615 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 11616 11617 { } 11618}; 11619 11620static struct hda_verb alc262_eapd_verbs[] = { 11621 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 11622 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 11623 { } 11624}; 11625 11626static struct hda_verb alc262_hippo1_unsol_verbs[] = { 11627 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 11628 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 11629 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 11630 11631 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 11632 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 11633 {} 11634}; 11635 11636static struct hda_verb alc262_sony_unsol_verbs[] = { 11637 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 11638 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 11639 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, // Front Mic 11640 11641 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 11642 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 11643 {} 11644}; 11645 11646static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = { 11647 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 11648 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 11649 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 11650 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 11651 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 11652 { } /* end */ 11653}; 11654 11655static struct hda_verb alc262_toshiba_s06_verbs[] = { 11656 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 11657 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 11658 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 11659 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 11660 {0x22, AC_VERB_SET_CONNECT_SEL, 0x09}, 11661 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 11662 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 11663 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 11664 {} 11665}; 11666 11667static void alc262_toshiba_s06_setup(struct hda_codec *codec) 11668{ 11669 struct alc_spec *spec = codec->spec; 11670 11671 spec->autocfg.hp_pins[0] = 0x15; 11672 spec->autocfg.speaker_pins[0] = 0x14; 11673 spec->ext_mic.pin = 0x18; 11674 spec->ext_mic.mux_idx = 0; 11675 spec->int_mic.pin = 0x12; 11676 spec->int_mic.mux_idx = 9; 11677 spec->auto_mic = 1; 11678} 11679 11680/* 11681 * nec model 11682 * 0x15 = headphone 11683 * 0x16 = internal speaker 11684 * 0x18 = external mic 11685 */ 11686 11687static struct snd_kcontrol_new alc262_nec_mixer[] = { 11688 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 11689 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT), 11690 11691 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 11692 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 11693 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 11694 11695 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 11696 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 11697 { } /* end */ 11698}; 11699 11700static struct hda_verb alc262_nec_verbs[] = { 11701 /* Unmute Speaker */ 11702 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11703 11704 /* Headphone */ 11705 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 11706 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 11707 11708 /* External mic to headphone */ 11709 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11710 /* External mic to speaker */ 11711 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11712 {} 11713}; 11714 11715/* 11716 * fujitsu model 11717 * 0x14 = headphone/spdif-out, 0x15 = internal speaker, 11718 * 0x1b = port replicator headphone out 11719 */ 11720 11721#define ALC_HP_EVENT 0x37 11722 11723static struct hda_verb alc262_fujitsu_unsol_verbs[] = { 11724 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT}, 11725 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 11726 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT}, 11727 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 11728 {} 11729}; 11730 11731static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = { 11732 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT}, 11733 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 11734 {} 11735}; 11736 11737static struct hda_verb alc262_lenovo_3000_init_verbs[] = { 11738 /* Front Mic pin: input vref at 50% */ 11739 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50}, 11740 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11741 {} 11742}; 11743 11744static struct hda_input_mux alc262_fujitsu_capture_source = { 11745 .num_items = 3, 11746 .items = { 11747 { "Mic", 0x0 }, 11748 { "Internal Mic", 0x1 }, 11749 { "CD", 0x4 }, 11750 }, 11751}; 11752 11753static struct hda_input_mux alc262_HP_capture_source = { 11754 .num_items = 5, 11755 .items = { 11756 { "Mic", 0x0 }, 11757 { "Front Mic", 0x1 }, 11758 { "Line", 0x2 }, 11759 { "CD", 0x4 }, 11760 { "AUX IN", 0x6 }, 11761 }, 11762}; 11763 11764static struct hda_input_mux alc262_HP_D7000_capture_source = { 11765 .num_items = 4, 11766 .items = { 11767 { "Mic", 0x0 }, 11768 { "Front Mic", 0x2 }, 11769 { "Line", 0x1 }, 11770 { "CD", 0x4 }, 11771 }, 11772}; 11773 11774/* mute/unmute internal speaker according to the hp jacks and mute state */ 11775static void alc262_fujitsu_automute(struct hda_codec *codec, int force) 11776{ 11777 struct alc_spec *spec = codec->spec; 11778 unsigned int mute; 11779 11780 if (force || !spec->sense_updated) { 11781 spec->jack_present = snd_hda_jack_detect(codec, 0x14) || 11782 snd_hda_jack_detect(codec, 0x1b); 11783 spec->sense_updated = 1; 11784 } 11785 /* unmute internal speaker only if both HPs are unplugged and 11786 * master switch is on 11787 */ 11788 if (spec->jack_present) 11789 mute = HDA_AMP_MUTE; 11790 else 11791 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0); 11792 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 11793 HDA_AMP_MUTE, mute); 11794} 11795 11796/* unsolicited event for HP jack sensing */ 11797static void alc262_fujitsu_unsol_event(struct hda_codec *codec, 11798 unsigned int res) 11799{ 11800 if ((res >> 26) != ALC_HP_EVENT) 11801 return; 11802 alc262_fujitsu_automute(codec, 1); 11803} 11804 11805static void alc262_fujitsu_init_hook(struct hda_codec *codec) 11806{ 11807 alc262_fujitsu_automute(codec, 1); 11808} 11809 11810/* bind volumes of both NID 0x0c and 0x0d */ 11811static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = { 11812 .ops = &snd_hda_bind_vol, 11813 .values = { 11814 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT), 11815 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT), 11816 0 11817 }, 11818}; 11819 11820/* mute/unmute internal speaker according to the hp jack and mute state */ 11821static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force) 11822{ 11823 struct alc_spec *spec = codec->spec; 11824 unsigned int mute; 11825 11826 if (force || !spec->sense_updated) { 11827 spec->jack_present = snd_hda_jack_detect(codec, 0x1b); 11828 spec->sense_updated = 1; 11829 } 11830 if (spec->jack_present) { 11831 /* mute internal speaker */ 11832 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 11833 HDA_AMP_MUTE, HDA_AMP_MUTE); 11834 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 11835 HDA_AMP_MUTE, HDA_AMP_MUTE); 11836 } else { 11837 /* unmute internal speaker if necessary */ 11838 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0); 11839 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 11840 HDA_AMP_MUTE, mute); 11841 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 11842 HDA_AMP_MUTE, mute); 11843 } 11844} 11845 11846/* unsolicited event for HP jack sensing */ 11847static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec, 11848 unsigned int res) 11849{ 11850 if ((res >> 26) != ALC_HP_EVENT) 11851 return; 11852 alc262_lenovo_3000_automute(codec, 1); 11853} 11854 11855static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid, 11856 int dir, int idx, long *valp) 11857{ 11858 int i, change = 0; 11859 11860 for (i = 0; i < 2; i++, valp++) 11861 change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx, 11862 HDA_AMP_MUTE, 11863 *valp ? 0 : HDA_AMP_MUTE); 11864 return change; 11865} 11866 11867/* bind hp and internal speaker mute (with plug check) */ 11868static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol, 11869 struct snd_ctl_elem_value *ucontrol) 11870{ 11871 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 11872 long *valp = ucontrol->value.integer.value; 11873 int change; 11874 11875 change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp); 11876 change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp); 11877 if (change) 11878 alc262_fujitsu_automute(codec, 0); 11879 return change; 11880} 11881 11882static struct snd_kcontrol_new alc262_fujitsu_mixer[] = { 11883 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol), 11884 { 11885 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11886 .name = "Master Playback Switch", 11887 .subdevice = HDA_SUBDEV_AMP_FLAG, 11888 .info = snd_hda_mixer_amp_switch_info, 11889 .get = snd_hda_mixer_amp_switch_get, 11890 .put = alc262_fujitsu_master_sw_put, 11891 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 11892 }, 11893 { 11894 .iface = NID_MAPPING, 11895 .name = "Master Playback Switch", 11896 .private_value = 0x1b, 11897 }, 11898 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 11899 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 11900 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 11901 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 11902 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 11903 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT), 11904 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 11905 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 11906 { } /* end */ 11907}; 11908 11909/* bind hp and internal speaker mute (with plug check) */ 11910static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol, 11911 struct snd_ctl_elem_value *ucontrol) 11912{ 11913 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 11914 long *valp = ucontrol->value.integer.value; 11915 int change; 11916 11917 change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp); 11918 if (change) 11919 alc262_lenovo_3000_automute(codec, 0); 11920 return change; 11921} 11922 11923static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = { 11924 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol), 11925 { 11926 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11927 .name = "Master Playback Switch", 11928 .subdevice = HDA_SUBDEV_AMP_FLAG, 11929 .info = snd_hda_mixer_amp_switch_info, 11930 .get = snd_hda_mixer_amp_switch_get, 11931 .put = alc262_lenovo_3000_master_sw_put, 11932 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT), 11933 }, 11934 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 11935 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 11936 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 11937 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 11938 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 11939 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT), 11940 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 11941 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 11942 { } /* end */ 11943}; 11944 11945static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = { 11946 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol), 11947 ALC262_HIPPO_MASTER_SWITCH, 11948 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 11949 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 11950 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 11951 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 11952 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 11953 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT), 11954 { } /* end */ 11955}; 11956 11957/* additional init verbs for Benq laptops */ 11958static struct hda_verb alc262_EAPD_verbs[] = { 11959 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 11960 {0x20, AC_VERB_SET_PROC_COEF, 0x3070}, 11961 {} 11962}; 11963 11964static struct hda_verb alc262_benq_t31_EAPD_verbs[] = { 11965 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 11966 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 11967 11968 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 11969 {0x20, AC_VERB_SET_PROC_COEF, 0x3050}, 11970 {} 11971}; 11972 11973/* Samsung Q1 Ultra Vista model setup */ 11974static struct snd_kcontrol_new alc262_ultra_mixer[] = { 11975 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 11976 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT), 11977 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 11978 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 11979 HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT), 11980 HDA_CODEC_VOLUME("Headphone Mic Boost Volume", 0x15, 0, HDA_INPUT), 11981 { } /* end */ 11982}; 11983 11984static struct hda_verb alc262_ultra_verbs[] = { 11985 /* output mixer */ 11986 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 11987 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 11988 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 11989 /* speaker */ 11990 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 11991 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11992 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11993 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 11994 /* HP */ 11995 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 11996 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11997 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11998 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 11999 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 12000 /* internal mic */ 12001 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 12002 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 12003 /* ADC, choose mic */ 12004 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 12005 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 12006 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12007 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 12008 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 12009 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 12010 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 12011 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 12012 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 12013 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)}, 12014 {} 12015}; 12016 12017/* mute/unmute internal speaker according to the hp jack and mute state */ 12018static void alc262_ultra_automute(struct hda_codec *codec) 12019{ 12020 struct alc_spec *spec = codec->spec; 12021 unsigned int mute; 12022 12023 mute = 0; 12024 /* auto-mute only when HP is used as HP */ 12025 if (!spec->cur_mux[0]) { 12026 spec->jack_present = snd_hda_jack_detect(codec, 0x15); 12027 if (spec->jack_present) 12028 mute = HDA_AMP_MUTE; 12029 } 12030 /* mute/unmute internal speaker */ 12031 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 12032 HDA_AMP_MUTE, mute); 12033 /* mute/unmute HP */ 12034 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 12035 HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE); 12036} 12037 12038/* unsolicited event for HP jack sensing */ 12039static void alc262_ultra_unsol_event(struct hda_codec *codec, 12040 unsigned int res) 12041{ 12042 if ((res >> 26) != ALC880_HP_EVENT) 12043 return; 12044 alc262_ultra_automute(codec); 12045} 12046 12047static struct hda_input_mux alc262_ultra_capture_source = { 12048 .num_items = 2, 12049 .items = { 12050 { "Mic", 0x1 }, 12051 { "Headphone", 0x7 }, 12052 }, 12053}; 12054 12055static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol, 12056 struct snd_ctl_elem_value *ucontrol) 12057{ 12058 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 12059 struct alc_spec *spec = codec->spec; 12060 int ret; 12061 12062 ret = alc_mux_enum_put(kcontrol, ucontrol); 12063 if (!ret) 12064 return 0; 12065 /* reprogram the HP pin as mic or HP according to the input source */ 12066 snd_hda_codec_write_cache(codec, 0x15, 0, 12067 AC_VERB_SET_PIN_WIDGET_CONTROL, 12068 spec->cur_mux[0] ? PIN_VREF80 : PIN_HP); 12069 alc262_ultra_automute(codec); /* mute/unmute HP */ 12070 return ret; 12071} 12072 12073static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = { 12074 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT), 12075 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT), 12076 { 12077 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 12078 .name = "Capture Source", 12079 .info = alc_mux_enum_info, 12080 .get = alc_mux_enum_get, 12081 .put = alc262_ultra_mux_enum_put, 12082 }, 12083 { 12084 .iface = NID_MAPPING, 12085 .name = "Capture Source", 12086 .private_value = 0x15, 12087 }, 12088 { } /* end */ 12089}; 12090 12091/* We use two mixers depending on the output pin; 0x16 is a mono output 12092 * and thus it's bound with a different mixer. 12093 * This function returns which mixer amp should be used. 12094 */ 12095static int alc262_check_volbit(hda_nid_t nid) 12096{ 12097 if (!nid) 12098 return 0; 12099 else if (nid == 0x16) 12100 return 2; 12101 else 12102 return 1; 12103} 12104 12105static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid, 12106 const char *pfx, int *vbits, int idx) 12107{ 12108 unsigned long val; 12109 int vbit; 12110 12111 vbit = alc262_check_volbit(nid); 12112 if (!vbit) 12113 return 0; 12114 if (*vbits & vbit) /* a volume control for this mixer already there */ 12115 return 0; 12116 *vbits |= vbit; 12117 if (vbit == 2) 12118 val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT); 12119 else 12120 val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT); 12121 return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx, val); 12122} 12123 12124static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid, 12125 const char *pfx, int idx) 12126{ 12127 unsigned long val; 12128 12129 if (!nid) 12130 return 0; 12131 if (nid == 0x16) 12132 val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT); 12133 else 12134 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 12135 return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx, val); 12136} 12137 12138/* add playback controls from the parsed DAC table */ 12139static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec, 12140 const struct auto_pin_cfg *cfg) 12141{ 12142 const char *pfx; 12143 int vbits; 12144 int i, err; 12145 12146 spec->multiout.num_dacs = 1; /* only use one dac */ 12147 spec->multiout.dac_nids = spec->private_dac_nids; 12148 spec->multiout.dac_nids[0] = 2; 12149 12150 pfx = alc_get_line_out_pfx(cfg, true); 12151 if (!pfx) 12152 pfx = "Front"; 12153 for (i = 0; i < 2; i++) { 12154 err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[i], pfx, i); 12155 if (err < 0) 12156 return err; 12157 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) { 12158 err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[i], 12159 "Speaker", i); 12160 if (err < 0) 12161 return err; 12162 } 12163 if (cfg->line_out_type != AUTO_PIN_HP_OUT) { 12164 err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[i], 12165 "Headphone", i); 12166 if (err < 0) 12167 return err; 12168 } 12169 } 12170 12171 vbits = alc262_check_volbit(cfg->line_out_pins[0]) | 12172 alc262_check_volbit(cfg->speaker_pins[0]) | 12173 alc262_check_volbit(cfg->hp_pins[0]); 12174 if (vbits == 1 || vbits == 2) 12175 pfx = "Master"; /* only one mixer is used */ 12176 vbits = 0; 12177 for (i = 0; i < 2; i++) { 12178 err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[i], pfx, 12179 &vbits, i); 12180 if (err < 0) 12181 return err; 12182 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) { 12183 err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[i], 12184 "Speaker", &vbits, i); 12185 if (err < 0) 12186 return err; 12187 } 12188 if (cfg->line_out_type != AUTO_PIN_HP_OUT) { 12189 err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[i], 12190 "Headphone", &vbits, i); 12191 if (err < 0) 12192 return err; 12193 } 12194 } 12195 return 0; 12196} 12197 12198#define alc262_auto_create_input_ctls \ 12199 alc882_auto_create_input_ctls 12200 12201/* 12202 * generic initialization of ADC, input mixers and output mixers 12203 */ 12204static struct hda_verb alc262_volume_init_verbs[] = { 12205 /* 12206 * Unmute ADC0-2 and set the default input to mic-in 12207 */ 12208 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 12209 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12210 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 12211 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12212 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 12213 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12214 12215 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 12216 * mixer widget 12217 * Note: PASD motherboards uses the Line In 2 as the input for 12218 * front panel mic (mic 2) 12219 */ 12220 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 12221 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 12222 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 12223 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 12224 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 12225 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 12226 12227 /* 12228 * Set up output mixers (0x0c - 0x0f) 12229 */ 12230 /* set vol=0 to output mixers */ 12231 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 12232 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 12233 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 12234 12235 /* set up input amps for analog loopback */ 12236 /* Amp Indices: DAC = 0, mixer = 1 */ 12237 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12238 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12239 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12240 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12241 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12242 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12243 12244 /* FIXME: use matrix-type input source selection */ 12245 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 12246 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 12247 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 12248 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 12249 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 12250 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 12251 /* Input mixer2 */ 12252 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 12253 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 12254 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 12255 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 12256 /* Input mixer3 */ 12257 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 12258 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 12259 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 12260 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 12261 12262 { } 12263}; 12264 12265static struct hda_verb alc262_HP_BPC_init_verbs[] = { 12266 /* 12267 * Unmute ADC0-2 and set the default input to mic-in 12268 */ 12269 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 12270 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12271 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 12272 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12273 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 12274 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12275 12276 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 12277 * mixer widget 12278 * Note: PASD motherboards uses the Line In 2 as the input for 12279 * front panel mic (mic 2) 12280 */ 12281 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 12282 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 12283 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 12284 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 12285 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 12286 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 12287 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 12288 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 12289 12290 /* 12291 * Set up output mixers (0x0c - 0x0e) 12292 */ 12293 /* set vol=0 to output mixers */ 12294 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 12295 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 12296 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 12297 12298 /* set up input amps for analog loopback */ 12299 /* Amp Indices: DAC = 0, mixer = 1 */ 12300 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12301 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12302 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12303 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12304 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12305 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12306 12307 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 12308 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 12309 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 12310 12311 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 12312 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 12313 12314 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 12315 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 12316 12317 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 12318 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 12319 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 12320 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 12321 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 12322 12323 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 12324 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 12325 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 12326 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 12327 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 12328 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 12329 12330 12331 /* FIXME: use matrix-type input source selection */ 12332 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */ 12333 /* Input mixer1: only unmute Mic */ 12334 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 12335 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))}, 12336 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 12337 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 12338 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 12339 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))}, 12340 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))}, 12341 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))}, 12342 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))}, 12343 /* Input mixer2 */ 12344 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 12345 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))}, 12346 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 12347 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 12348 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 12349 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))}, 12350 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))}, 12351 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))}, 12352 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))}, 12353 /* Input mixer3 */ 12354 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 12355 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))}, 12356 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 12357 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 12358 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 12359 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))}, 12360 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))}, 12361 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))}, 12362 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))}, 12363 12364 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 12365 12366 { } 12367}; 12368 12369static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = { 12370 /* 12371 * Unmute ADC0-2 and set the default input to mic-in 12372 */ 12373 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 12374 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12375 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 12376 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12377 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 12378 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12379 12380 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 12381 * mixer widget 12382 * Note: PASD motherboards uses the Line In 2 as the input for front 12383 * panel mic (mic 2) 12384 */ 12385 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 12386 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 12387 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 12388 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 12389 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 12390 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 12391 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 12392 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 12393 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 12394 /* 12395 * Set up output mixers (0x0c - 0x0e) 12396 */ 12397 /* set vol=0 to output mixers */ 12398 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 12399 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 12400 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 12401 12402 /* set up input amps for analog loopback */ 12403 /* Amp Indices: DAC = 0, mixer = 1 */ 12404 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12405 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12406 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12407 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12408 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12409 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12410 12411 12412 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP */ 12413 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Mono */ 12414 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* rear MIC */ 12415 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* Line in */ 12416 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Front MIC */ 12417 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Line out */ 12418 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD in */ 12419 12420 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 12421 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 12422 12423 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 12424 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 12425 12426 /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */ 12427 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 12428 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 12429 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, 12430 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 12431 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 12432 12433 /* FIXME: use matrix-type input source selection */ 12434 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 12435 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 12436 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/ 12437 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/ 12438 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/ 12439 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/ 12440 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/ 12441 /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */ 12442 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/ 12443 /* Input mixer2 */ 12444 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 12445 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 12446 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, 12447 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, 12448 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, 12449 /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */ 12450 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, 12451 /* Input mixer3 */ 12452 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 12453 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 12454 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, 12455 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, 12456 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, 12457 /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */ 12458 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, 12459 12460 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 12461 12462 { } 12463}; 12464 12465static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = { 12466 12467 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Front Speaker */ 12468 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 12469 {0x14, AC_VERB_SET_CONNECT_SEL, 0x01}, 12470 12471 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* MIC jack */ 12472 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Front MIC */ 12473 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) }, 12474 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) }, 12475 12476 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP jack */ 12477 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 12478 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 12479 {} 12480}; 12481 12482/* 12483 * Pin config fixes 12484 */ 12485enum { 12486 PINFIX_FSC_H270, 12487}; 12488 12489static const struct alc_fixup alc262_fixups[] = { 12490 [PINFIX_FSC_H270] = { 12491 .type = ALC_FIXUP_PINS, 12492 .v.pins = (const struct alc_pincfg[]) { 12493 { 0x14, 0x99130110 }, /* speaker */ 12494 { 0x15, 0x0221142f }, /* front HP */ 12495 { 0x1b, 0x0121141f }, /* rear HP */ 12496 { } 12497 } 12498 }, 12499}; 12500 12501static struct snd_pci_quirk alc262_fixup_tbl[] = { 12502 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270), 12503 {} 12504}; 12505 12506 12507#ifdef CONFIG_SND_HDA_POWER_SAVE 12508#define alc262_loopbacks alc880_loopbacks 12509#endif 12510 12511/* pcm configuration: identical with ALC880 */ 12512#define alc262_pcm_analog_playback alc880_pcm_analog_playback 12513#define alc262_pcm_analog_capture alc880_pcm_analog_capture 12514#define alc262_pcm_digital_playback alc880_pcm_digital_playback 12515#define alc262_pcm_digital_capture alc880_pcm_digital_capture 12516 12517/* 12518 * BIOS auto configuration 12519 */ 12520static int alc262_parse_auto_config(struct hda_codec *codec) 12521{ 12522 struct alc_spec *spec = codec->spec; 12523 int err; 12524 static hda_nid_t alc262_ignore[] = { 0x1d, 0 }; 12525 12526 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 12527 alc262_ignore); 12528 if (err < 0) 12529 return err; 12530 if (!spec->autocfg.line_outs) { 12531 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) { 12532 spec->multiout.max_channels = 2; 12533 spec->no_analog = 1; 12534 goto dig_only; 12535 } 12536 return 0; /* can't find valid BIOS pin config */ 12537 } 12538 err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg); 12539 if (err < 0) 12540 return err; 12541 err = alc262_auto_create_input_ctls(codec, &spec->autocfg); 12542 if (err < 0) 12543 return err; 12544 12545 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 12546 12547 dig_only: 12548 alc_auto_parse_digital(codec); 12549 12550 if (spec->kctls.list) 12551 add_mixer(spec, spec->kctls.list); 12552 12553 add_verb(spec, alc262_volume_init_verbs); 12554 spec->num_mux_defs = 1; 12555 spec->input_mux = &spec->private_imux[0]; 12556 12557 err = alc_auto_add_mic_boost(codec); 12558 if (err < 0) 12559 return err; 12560 12561 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0); 12562 12563 return 1; 12564} 12565 12566#define alc262_auto_init_multi_out alc882_auto_init_multi_out 12567#define alc262_auto_init_hp_out alc882_auto_init_hp_out 12568#define alc262_auto_init_analog_input alc882_auto_init_analog_input 12569#define alc262_auto_init_input_src alc882_auto_init_input_src 12570 12571 12572/* init callback for auto-configuration model -- overriding the default init */ 12573static void alc262_auto_init(struct hda_codec *codec) 12574{ 12575 struct alc_spec *spec = codec->spec; 12576 alc262_auto_init_multi_out(codec); 12577 alc262_auto_init_hp_out(codec); 12578 alc262_auto_init_analog_input(codec); 12579 alc262_auto_init_input_src(codec); 12580 alc_auto_init_digital(codec); 12581 if (spec->unsol_event) 12582 alc_inithook(codec); 12583} 12584 12585/* 12586 * configuration and preset 12587 */ 12588static const char * const alc262_models[ALC262_MODEL_LAST] = { 12589 [ALC262_BASIC] = "basic", 12590 [ALC262_HIPPO] = "hippo", 12591 [ALC262_HIPPO_1] = "hippo_1", 12592 [ALC262_FUJITSU] = "fujitsu", 12593 [ALC262_HP_BPC] = "hp-bpc", 12594 [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000", 12595 [ALC262_HP_TC_T5735] = "hp-tc-t5735", 12596 [ALC262_HP_RP5700] = "hp-rp5700", 12597 [ALC262_BENQ_ED8] = "benq", 12598 [ALC262_BENQ_T31] = "benq-t31", 12599 [ALC262_SONY_ASSAMD] = "sony-assamd", 12600 [ALC262_TOSHIBA_S06] = "toshiba-s06", 12601 [ALC262_TOSHIBA_RX1] = "toshiba-rx1", 12602 [ALC262_ULTRA] = "ultra", 12603 [ALC262_LENOVO_3000] = "lenovo-3000", 12604 [ALC262_NEC] = "nec", 12605 [ALC262_TYAN] = "tyan", 12606 [ALC262_AUTO] = "auto", 12607}; 12608 12609static struct snd_pci_quirk alc262_cfg_tbl[] = { 12610 SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO), 12611 SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC), 12612 SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series", 12613 ALC262_HP_BPC), 12614 SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series", 12615 ALC262_HP_BPC), 12616 SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1500, "HP z series", 12617 ALC262_HP_BPC), 12618 SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series", 12619 ALC262_HP_BPC), 12620 SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL), 12621 SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF), 12622 SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL), 12623 SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF), 12624 SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL), 12625 SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF), 12626 SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL), 12627 SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF), 12628 SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC), 12629 SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC), 12630 SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC), 12631 SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735", 12632 ALC262_HP_TC_T5735), 12633 SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700), 12634 SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD), 12635 SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO), 12636 SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD), 12637 SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */ 12638 SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06), 12639 SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO), 12640 SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO), 12641#if 0 /* disable the quirk since model=auto works better in recent versions */ 12642 SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO", 12643 ALC262_SONY_ASSAMD), 12644#endif 12645 SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1", 12646 ALC262_TOSHIBA_RX1), 12647 SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06), 12648 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU), 12649 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU), 12650 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN), 12651 SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1", 12652 ALC262_ULTRA), 12653 SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO), 12654 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000), 12655 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8), 12656 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31), 12657 SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1), 12658 {} 12659}; 12660 12661static struct alc_config_preset alc262_presets[] = { 12662 [ALC262_BASIC] = { 12663 .mixers = { alc262_base_mixer }, 12664 .init_verbs = { alc262_init_verbs }, 12665 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 12666 .dac_nids = alc262_dac_nids, 12667 .hp_nid = 0x03, 12668 .num_channel_mode = ARRAY_SIZE(alc262_modes), 12669 .channel_mode = alc262_modes, 12670 .input_mux = &alc262_capture_source, 12671 }, 12672 [ALC262_HIPPO] = { 12673 .mixers = { alc262_hippo_mixer }, 12674 .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs}, 12675 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 12676 .dac_nids = alc262_dac_nids, 12677 .hp_nid = 0x03, 12678 .dig_out_nid = ALC262_DIGOUT_NID, 12679 .num_channel_mode = ARRAY_SIZE(alc262_modes), 12680 .channel_mode = alc262_modes, 12681 .input_mux = &alc262_capture_source, 12682 .unsol_event = alc262_hippo_unsol_event, 12683 .setup = alc262_hippo_setup, 12684 .init_hook = alc262_hippo_automute, 12685 }, 12686 [ALC262_HIPPO_1] = { 12687 .mixers = { alc262_hippo1_mixer }, 12688 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs}, 12689 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 12690 .dac_nids = alc262_dac_nids, 12691 .hp_nid = 0x02, 12692 .dig_out_nid = ALC262_DIGOUT_NID, 12693 .num_channel_mode = ARRAY_SIZE(alc262_modes), 12694 .channel_mode = alc262_modes, 12695 .input_mux = &alc262_capture_source, 12696 .unsol_event = alc262_hippo_unsol_event, 12697 .setup = alc262_hippo1_setup, 12698 .init_hook = alc262_hippo_automute, 12699 }, 12700 [ALC262_FUJITSU] = { 12701 .mixers = { alc262_fujitsu_mixer }, 12702 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs, 12703 alc262_fujitsu_unsol_verbs }, 12704 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 12705 .dac_nids = alc262_dac_nids, 12706 .hp_nid = 0x03, 12707 .dig_out_nid = ALC262_DIGOUT_NID, 12708 .num_channel_mode = ARRAY_SIZE(alc262_modes), 12709 .channel_mode = alc262_modes, 12710 .input_mux = &alc262_fujitsu_capture_source, 12711 .unsol_event = alc262_fujitsu_unsol_event, 12712 .init_hook = alc262_fujitsu_init_hook, 12713 }, 12714 [ALC262_HP_BPC] = { 12715 .mixers = { alc262_HP_BPC_mixer }, 12716 .init_verbs = { alc262_HP_BPC_init_verbs }, 12717 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 12718 .dac_nids = alc262_dac_nids, 12719 .hp_nid = 0x03, 12720 .num_channel_mode = ARRAY_SIZE(alc262_modes), 12721 .channel_mode = alc262_modes, 12722 .input_mux = &alc262_HP_capture_source, 12723 .unsol_event = alc262_hp_bpc_unsol_event, 12724 .init_hook = alc262_hp_bpc_automute, 12725 }, 12726 [ALC262_HP_BPC_D7000_WF] = { 12727 .mixers = { alc262_HP_BPC_WildWest_mixer }, 12728 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs }, 12729 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 12730 .dac_nids = alc262_dac_nids, 12731 .hp_nid = 0x03, 12732 .num_channel_mode = ARRAY_SIZE(alc262_modes), 12733 .channel_mode = alc262_modes, 12734 .input_mux = &alc262_HP_D7000_capture_source, 12735 .unsol_event = alc262_hp_wildwest_unsol_event, 12736 .init_hook = alc262_hp_wildwest_automute, 12737 }, 12738 [ALC262_HP_BPC_D7000_WL] = { 12739 .mixers = { alc262_HP_BPC_WildWest_mixer, 12740 alc262_HP_BPC_WildWest_option_mixer }, 12741 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs }, 12742 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 12743 .dac_nids = alc262_dac_nids, 12744 .hp_nid = 0x03, 12745 .num_channel_mode = ARRAY_SIZE(alc262_modes), 12746 .channel_mode = alc262_modes, 12747 .input_mux = &alc262_HP_D7000_capture_source, 12748 .unsol_event = alc262_hp_wildwest_unsol_event, 12749 .init_hook = alc262_hp_wildwest_automute, 12750 }, 12751 [ALC262_HP_TC_T5735] = { 12752 .mixers = { alc262_hp_t5735_mixer }, 12753 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs }, 12754 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 12755 .dac_nids = alc262_dac_nids, 12756 .hp_nid = 0x03, 12757 .num_channel_mode = ARRAY_SIZE(alc262_modes), 12758 .channel_mode = alc262_modes, 12759 .input_mux = &alc262_capture_source, 12760 .unsol_event = alc_sku_unsol_event, 12761 .setup = alc262_hp_t5735_setup, 12762 .init_hook = alc_inithook, 12763 }, 12764 [ALC262_HP_RP5700] = { 12765 .mixers = { alc262_hp_rp5700_mixer }, 12766 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs }, 12767 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 12768 .dac_nids = alc262_dac_nids, 12769 .num_channel_mode = ARRAY_SIZE(alc262_modes), 12770 .channel_mode = alc262_modes, 12771 .input_mux = &alc262_hp_rp5700_capture_source, 12772 }, 12773 [ALC262_BENQ_ED8] = { 12774 .mixers = { alc262_base_mixer }, 12775 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs }, 12776 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 12777 .dac_nids = alc262_dac_nids, 12778 .hp_nid = 0x03, 12779 .num_channel_mode = ARRAY_SIZE(alc262_modes), 12780 .channel_mode = alc262_modes, 12781 .input_mux = &alc262_capture_source, 12782 }, 12783 [ALC262_SONY_ASSAMD] = { 12784 .mixers = { alc262_sony_mixer }, 12785 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs}, 12786 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 12787 .dac_nids = alc262_dac_nids, 12788 .hp_nid = 0x02, 12789 .num_channel_mode = ARRAY_SIZE(alc262_modes), 12790 .channel_mode = alc262_modes, 12791 .input_mux = &alc262_capture_source, 12792 .unsol_event = alc262_hippo_unsol_event, 12793 .setup = alc262_hippo_setup, 12794 .init_hook = alc262_hippo_automute, 12795 }, 12796 [ALC262_BENQ_T31] = { 12797 .mixers = { alc262_benq_t31_mixer }, 12798 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, 12799 alc_hp15_unsol_verbs }, 12800 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 12801 .dac_nids = alc262_dac_nids, 12802 .hp_nid = 0x03, 12803 .num_channel_mode = ARRAY_SIZE(alc262_modes), 12804 .channel_mode = alc262_modes, 12805 .input_mux = &alc262_capture_source, 12806 .unsol_event = alc262_hippo_unsol_event, 12807 .setup = alc262_hippo_setup, 12808 .init_hook = alc262_hippo_automute, 12809 }, 12810 [ALC262_ULTRA] = { 12811 .mixers = { alc262_ultra_mixer }, 12812 .cap_mixer = alc262_ultra_capture_mixer, 12813 .init_verbs = { alc262_ultra_verbs }, 12814 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 12815 .dac_nids = alc262_dac_nids, 12816 .num_channel_mode = ARRAY_SIZE(alc262_modes), 12817 .channel_mode = alc262_modes, 12818 .input_mux = &alc262_ultra_capture_source, 12819 .adc_nids = alc262_adc_nids, /* ADC0 */ 12820 .capsrc_nids = alc262_capsrc_nids, 12821 .num_adc_nids = 1, /* single ADC */ 12822 .unsol_event = alc262_ultra_unsol_event, 12823 .init_hook = alc262_ultra_automute, 12824 }, 12825 [ALC262_LENOVO_3000] = { 12826 .mixers = { alc262_lenovo_3000_mixer }, 12827 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs, 12828 alc262_lenovo_3000_unsol_verbs, 12829 alc262_lenovo_3000_init_verbs }, 12830 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 12831 .dac_nids = alc262_dac_nids, 12832 .hp_nid = 0x03, 12833 .dig_out_nid = ALC262_DIGOUT_NID, 12834 .num_channel_mode = ARRAY_SIZE(alc262_modes), 12835 .channel_mode = alc262_modes, 12836 .input_mux = &alc262_fujitsu_capture_source, 12837 .unsol_event = alc262_lenovo_3000_unsol_event, 12838 }, 12839 [ALC262_NEC] = { 12840 .mixers = { alc262_nec_mixer }, 12841 .init_verbs = { alc262_nec_verbs }, 12842 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 12843 .dac_nids = alc262_dac_nids, 12844 .hp_nid = 0x03, 12845 .num_channel_mode = ARRAY_SIZE(alc262_modes), 12846 .channel_mode = alc262_modes, 12847 .input_mux = &alc262_capture_source, 12848 }, 12849 [ALC262_TOSHIBA_S06] = { 12850 .mixers = { alc262_toshiba_s06_mixer }, 12851 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs, 12852 alc262_eapd_verbs }, 12853 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 12854 .capsrc_nids = alc262_dmic_capsrc_nids, 12855 .dac_nids = alc262_dac_nids, 12856 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */ 12857 .num_adc_nids = 1, /* single ADC */ 12858 .dig_out_nid = ALC262_DIGOUT_NID, 12859 .num_channel_mode = ARRAY_SIZE(alc262_modes), 12860 .channel_mode = alc262_modes, 12861 .unsol_event = alc_sku_unsol_event, 12862 .setup = alc262_toshiba_s06_setup, 12863 .init_hook = alc_inithook, 12864 }, 12865 [ALC262_TOSHIBA_RX1] = { 12866 .mixers = { alc262_toshiba_rx1_mixer }, 12867 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs }, 12868 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 12869 .dac_nids = alc262_dac_nids, 12870 .hp_nid = 0x03, 12871 .num_channel_mode = ARRAY_SIZE(alc262_modes), 12872 .channel_mode = alc262_modes, 12873 .input_mux = &alc262_capture_source, 12874 .unsol_event = alc262_hippo_unsol_event, 12875 .setup = alc262_hippo_setup, 12876 .init_hook = alc262_hippo_automute, 12877 }, 12878 [ALC262_TYAN] = { 12879 .mixers = { alc262_tyan_mixer }, 12880 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs}, 12881 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 12882 .dac_nids = alc262_dac_nids, 12883 .hp_nid = 0x02, 12884 .dig_out_nid = ALC262_DIGOUT_NID, 12885 .num_channel_mode = ARRAY_SIZE(alc262_modes), 12886 .channel_mode = alc262_modes, 12887 .input_mux = &alc262_capture_source, 12888 .unsol_event = alc_automute_amp_unsol_event, 12889 .setup = alc262_tyan_setup, 12890 .init_hook = alc_automute_amp, 12891 }, 12892}; 12893 12894static int patch_alc262(struct hda_codec *codec) 12895{ 12896 struct alc_spec *spec; 12897 int board_config; 12898 int err; 12899 12900 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 12901 if (spec == NULL) 12902 return -ENOMEM; 12903 12904 codec->spec = spec; 12905#if 0 12906 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is 12907 * under-run 12908 */ 12909 { 12910 int tmp; 12911 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7); 12912 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0); 12913 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7); 12914 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80); 12915 } 12916#endif 12917 alc_auto_parse_customize_define(codec); 12918 12919 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 12920 12921 board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST, 12922 alc262_models, 12923 alc262_cfg_tbl); 12924 12925 if (board_config < 0) { 12926 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 12927 codec->chip_name); 12928 board_config = ALC262_AUTO; 12929 } 12930 12931 if (board_config == ALC262_AUTO) { 12932 alc_pick_fixup(codec, NULL, alc262_fixup_tbl, alc262_fixups); 12933 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE); 12934 } 12935 12936 if (board_config == ALC262_AUTO) { 12937 /* automatic parse from the BIOS config */ 12938 err = alc262_parse_auto_config(codec); 12939 if (err < 0) { 12940 alc_free(codec); 12941 return err; 12942 } else if (!err) { 12943 printk(KERN_INFO 12944 "hda_codec: Cannot set up configuration " 12945 "from BIOS. Using base mode...\n"); 12946 board_config = ALC262_BASIC; 12947 } 12948 } 12949 12950 if (!spec->no_analog && has_cdefine_beep(codec)) { 12951 err = snd_hda_attach_beep_device(codec, 0x1); 12952 if (err < 0) { 12953 alc_free(codec); 12954 return err; 12955 } 12956 } 12957 12958 if (board_config != ALC262_AUTO) 12959 setup_preset(codec, &alc262_presets[board_config]); 12960 12961 spec->stream_analog_playback = &alc262_pcm_analog_playback; 12962 spec->stream_analog_capture = &alc262_pcm_analog_capture; 12963 12964 spec->stream_digital_playback = &alc262_pcm_digital_playback; 12965 spec->stream_digital_capture = &alc262_pcm_digital_capture; 12966 12967 if (!spec->adc_nids && spec->input_mux) { 12968 int i; 12969 /* check whether the digital-mic has to be supported */ 12970 for (i = 0; i < spec->input_mux->num_items; i++) { 12971 if (spec->input_mux->items[i].index >= 9) 12972 break; 12973 } 12974 if (i < spec->input_mux->num_items) { 12975 /* use only ADC0 */ 12976 spec->adc_nids = alc262_dmic_adc_nids; 12977 spec->num_adc_nids = 1; 12978 spec->capsrc_nids = alc262_dmic_capsrc_nids; 12979 } else { 12980 /* all analog inputs */ 12981 /* check whether NID 0x07 is valid */ 12982 unsigned int wcap = get_wcaps(codec, 0x07); 12983 12984 /* get type */ 12985 wcap = get_wcaps_type(wcap); 12986 if (wcap != AC_WID_AUD_IN) { 12987 spec->adc_nids = alc262_adc_nids_alt; 12988 spec->num_adc_nids = 12989 ARRAY_SIZE(alc262_adc_nids_alt); 12990 spec->capsrc_nids = alc262_capsrc_nids_alt; 12991 } else { 12992 spec->adc_nids = alc262_adc_nids; 12993 spec->num_adc_nids = 12994 ARRAY_SIZE(alc262_adc_nids); 12995 spec->capsrc_nids = alc262_capsrc_nids; 12996 } 12997 } 12998 } 12999 if (!spec->cap_mixer && !spec->no_analog) 13000 set_capture_mixer(codec); 13001 if (!spec->no_analog && has_cdefine_beep(codec)) 13002 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 13003 13004 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE); 13005 13006 spec->vmaster_nid = 0x0c; 13007 13008 codec->patch_ops = alc_patch_ops; 13009 if (board_config == ALC262_AUTO) 13010 spec->init_hook = alc262_auto_init; 13011 13012 alc_init_jacks(codec); 13013#ifdef CONFIG_SND_HDA_POWER_SAVE 13014 if (!spec->loopback.amplist) 13015 spec->loopback.amplist = alc262_loopbacks; 13016#endif 13017 13018 return 0; 13019} 13020 13021/* 13022 * ALC268 channel source setting (2 channel) 13023 */ 13024#define ALC268_DIGOUT_NID ALC880_DIGOUT_NID 13025#define alc268_modes alc260_modes 13026 13027static hda_nid_t alc268_dac_nids[2] = { 13028 /* front, hp */ 13029 0x02, 0x03 13030}; 13031 13032static hda_nid_t alc268_adc_nids[2] = { 13033 /* ADC0-1 */ 13034 0x08, 0x07 13035}; 13036 13037static hda_nid_t alc268_adc_nids_alt[1] = { 13038 /* ADC0 */ 13039 0x08 13040}; 13041 13042static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 }; 13043 13044static struct snd_kcontrol_new alc268_base_mixer[] = { 13045 /* output mixer control */ 13046 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT), 13047 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 13048 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT), 13049 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 13050 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 13051 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT), 13052 HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT), 13053 { } 13054}; 13055 13056static struct snd_kcontrol_new alc268_toshiba_mixer[] = { 13057 /* output mixer control */ 13058 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT), 13059 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT), 13060 ALC262_HIPPO_MASTER_SWITCH, 13061 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 13062 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT), 13063 HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT), 13064 { } 13065}; 13066 13067/* bind Beep switches of both NID 0x0f and 0x10 */ 13068static struct hda_bind_ctls alc268_bind_beep_sw = { 13069 .ops = &snd_hda_bind_sw, 13070 .values = { 13071 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT), 13072 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT), 13073 0 13074 }, 13075}; 13076 13077static struct snd_kcontrol_new alc268_beep_mixer[] = { 13078 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT), 13079 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw), 13080 { } 13081}; 13082 13083static struct hda_verb alc268_eapd_verbs[] = { 13084 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 13085 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 13086 { } 13087}; 13088 13089/* Toshiba specific */ 13090static struct hda_verb alc268_toshiba_verbs[] = { 13091 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 13092 { } /* end */ 13093}; 13094 13095/* Acer specific */ 13096/* bind volumes of both NID 0x02 and 0x03 */ 13097static struct hda_bind_ctls alc268_acer_bind_master_vol = { 13098 .ops = &snd_hda_bind_vol, 13099 .values = { 13100 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT), 13101 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT), 13102 0 13103 }, 13104}; 13105 13106/* mute/unmute internal speaker according to the hp jack and mute state */ 13107static void alc268_acer_automute(struct hda_codec *codec, int force) 13108{ 13109 struct alc_spec *spec = codec->spec; 13110 unsigned int mute; 13111 13112 if (force || !spec->sense_updated) { 13113 spec->jack_present = snd_hda_jack_detect(codec, 0x14); 13114 spec->sense_updated = 1; 13115 } 13116 if (spec->jack_present) 13117 mute = HDA_AMP_MUTE; /* mute internal speaker */ 13118 else /* unmute internal speaker if necessary */ 13119 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0); 13120 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 13121 HDA_AMP_MUTE, mute); 13122} 13123 13124 13125/* bind hp and internal speaker mute (with plug check) */ 13126static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol, 13127 struct snd_ctl_elem_value *ucontrol) 13128{ 13129 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 13130 long *valp = ucontrol->value.integer.value; 13131 int change; 13132 13133 change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp); 13134 if (change) 13135 alc268_acer_automute(codec, 0); 13136 return change; 13137} 13138 13139static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = { 13140 /* output mixer control */ 13141 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol), 13142 { 13143 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 13144 .name = "Master Playback Switch", 13145 .subdevice = HDA_SUBDEV_AMP_FLAG, 13146 .info = snd_hda_mixer_amp_switch_info, 13147 .get = snd_hda_mixer_amp_switch_get, 13148 .put = alc268_acer_master_sw_put, 13149 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 13150 }, 13151 HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT), 13152 { } 13153}; 13154 13155static struct snd_kcontrol_new alc268_acer_mixer[] = { 13156 /* output mixer control */ 13157 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol), 13158 { 13159 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 13160 .name = "Master Playback Switch", 13161 .subdevice = HDA_SUBDEV_AMP_FLAG, 13162 .info = snd_hda_mixer_amp_switch_info, 13163 .get = snd_hda_mixer_amp_switch_get, 13164 .put = alc268_acer_master_sw_put, 13165 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 13166 }, 13167 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 13168 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT), 13169 HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT), 13170 { } 13171}; 13172 13173static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = { 13174 /* output mixer control */ 13175 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol), 13176 { 13177 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 13178 .name = "Master Playback Switch", 13179 .subdevice = HDA_SUBDEV_AMP_FLAG, 13180 .info = snd_hda_mixer_amp_switch_info, 13181 .get = snd_hda_mixer_amp_switch_get, 13182 .put = alc268_acer_master_sw_put, 13183 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 13184 }, 13185 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 13186 HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT), 13187 { } 13188}; 13189 13190static struct hda_verb alc268_acer_aspire_one_verbs[] = { 13191 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 13192 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 13193 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 13194 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 13195 {0x23, AC_VERB_SET_CONNECT_SEL, 0x06}, 13196 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017}, 13197 { } 13198}; 13199 13200static struct hda_verb alc268_acer_verbs[] = { 13201 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */ 13202 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 13203 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 13204 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 13205 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 13206 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 13207 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 13208 { } 13209}; 13210 13211/* unsolicited event for HP jack sensing */ 13212#define alc268_toshiba_unsol_event alc262_hippo_unsol_event 13213#define alc268_toshiba_setup alc262_hippo_setup 13214#define alc268_toshiba_automute alc262_hippo_automute 13215 13216static void alc268_acer_unsol_event(struct hda_codec *codec, 13217 unsigned int res) 13218{ 13219 if ((res >> 26) != ALC880_HP_EVENT) 13220 return; 13221 alc268_acer_automute(codec, 1); 13222} 13223 13224static void alc268_acer_init_hook(struct hda_codec *codec) 13225{ 13226 alc268_acer_automute(codec, 1); 13227} 13228 13229/* toggle speaker-output according to the hp-jack state */ 13230static void alc268_aspire_one_speaker_automute(struct hda_codec *codec) 13231{ 13232 unsigned int present; 13233 unsigned char bits; 13234 13235 present = snd_hda_jack_detect(codec, 0x15); 13236 bits = present ? HDA_AMP_MUTE : 0; 13237 snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0, 13238 HDA_AMP_MUTE, bits); 13239 snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1, 13240 HDA_AMP_MUTE, bits); 13241} 13242 13243static void alc268_acer_lc_unsol_event(struct hda_codec *codec, 13244 unsigned int res) 13245{ 13246 switch (res >> 26) { 13247 case ALC880_HP_EVENT: 13248 alc268_aspire_one_speaker_automute(codec); 13249 break; 13250 case ALC880_MIC_EVENT: 13251 alc_mic_automute(codec); 13252 break; 13253 } 13254} 13255 13256static void alc268_acer_lc_setup(struct hda_codec *codec) 13257{ 13258 struct alc_spec *spec = codec->spec; 13259 spec->ext_mic.pin = 0x18; 13260 spec->ext_mic.mux_idx = 0; 13261 spec->int_mic.pin = 0x12; 13262 spec->int_mic.mux_idx = 6; 13263 spec->auto_mic = 1; 13264} 13265 13266static void alc268_acer_lc_init_hook(struct hda_codec *codec) 13267{ 13268 alc268_aspire_one_speaker_automute(codec); 13269 alc_mic_automute(codec); 13270} 13271 13272static struct snd_kcontrol_new alc268_dell_mixer[] = { 13273 /* output mixer control */ 13274 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 13275 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 13276 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 13277 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 13278 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 13279 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT), 13280 { } 13281}; 13282 13283static struct hda_verb alc268_dell_verbs[] = { 13284 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 13285 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 13286 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 13287 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, 13288 { } 13289}; 13290 13291/* mute/unmute internal speaker according to the hp jack and mute state */ 13292static void alc268_dell_setup(struct hda_codec *codec) 13293{ 13294 struct alc_spec *spec = codec->spec; 13295 13296 spec->autocfg.hp_pins[0] = 0x15; 13297 spec->autocfg.speaker_pins[0] = 0x14; 13298 spec->ext_mic.pin = 0x18; 13299 spec->ext_mic.mux_idx = 0; 13300 spec->int_mic.pin = 0x19; 13301 spec->int_mic.mux_idx = 1; 13302 spec->auto_mic = 1; 13303} 13304 13305static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = { 13306 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT), 13307 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 13308 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT), 13309 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 13310 HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT), 13311 HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT), 13312 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 13313 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT), 13314 { } 13315}; 13316 13317static struct hda_verb alc267_quanta_il1_verbs[] = { 13318 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 13319 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, 13320 { } 13321}; 13322 13323static void alc267_quanta_il1_setup(struct hda_codec *codec) 13324{ 13325 struct alc_spec *spec = codec->spec; 13326 spec->autocfg.hp_pins[0] = 0x15; 13327 spec->autocfg.speaker_pins[0] = 0x14; 13328 spec->ext_mic.pin = 0x18; 13329 spec->ext_mic.mux_idx = 0; 13330 spec->int_mic.pin = 0x19; 13331 spec->int_mic.mux_idx = 1; 13332 spec->auto_mic = 1; 13333} 13334 13335/* 13336 * generic initialization of ADC, input mixers and output mixers 13337 */ 13338static struct hda_verb alc268_base_init_verbs[] = { 13339 /* Unmute DAC0-1 and set vol = 0 */ 13340 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 13341 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 13342 13343 /* 13344 * Set up output mixers (0x0c - 0x0e) 13345 */ 13346 /* set vol=0 to output mixers */ 13347 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13348 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00}, 13349 13350 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13351 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13352 13353 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 13354 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 13355 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 13356 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 13357 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 13358 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 13359 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 13360 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 13361 13362 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13363 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13364 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13365 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13366 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13367 13368 /* set PCBEEP vol = 0, mute connections */ 13369 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13370 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 13371 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 13372 13373 /* Unmute Selector 23h,24h and set the default input to mic-in */ 13374 13375 {0x23, AC_VERB_SET_CONNECT_SEL, 0x00}, 13376 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13377 {0x24, AC_VERB_SET_CONNECT_SEL, 0x00}, 13378 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13379 13380 { } 13381}; 13382 13383/* 13384 * generic initialization of ADC, input mixers and output mixers 13385 */ 13386static struct hda_verb alc268_volume_init_verbs[] = { 13387 /* set output DAC */ 13388 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 13389 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 13390 13391 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 13392 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 13393 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 13394 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 13395 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 13396 13397 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13398 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13399 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13400 13401 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13402 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13403 13404 /* set PCBEEP vol = 0, mute connections */ 13405 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13406 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 13407 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 13408 13409 { } 13410}; 13411 13412static struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = { 13413 HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT), 13414 HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT), 13415 { } /* end */ 13416}; 13417 13418static struct snd_kcontrol_new alc268_capture_alt_mixer[] = { 13419 HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT), 13420 HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT), 13421 _DEFINE_CAPSRC(1), 13422 { } /* end */ 13423}; 13424 13425static struct snd_kcontrol_new alc268_capture_mixer[] = { 13426 HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT), 13427 HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT), 13428 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT), 13429 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT), 13430 _DEFINE_CAPSRC(2), 13431 { } /* end */ 13432}; 13433 13434static struct hda_input_mux alc268_capture_source = { 13435 .num_items = 4, 13436 .items = { 13437 { "Mic", 0x0 }, 13438 { "Front Mic", 0x1 }, 13439 { "Line", 0x2 }, 13440 { "CD", 0x3 }, 13441 }, 13442}; 13443 13444static struct hda_input_mux alc268_acer_capture_source = { 13445 .num_items = 3, 13446 .items = { 13447 { "Mic", 0x0 }, 13448 { "Internal Mic", 0x1 }, 13449 { "Line", 0x2 }, 13450 }, 13451}; 13452 13453static struct hda_input_mux alc268_acer_dmic_capture_source = { 13454 .num_items = 3, 13455 .items = { 13456 { "Mic", 0x0 }, 13457 { "Internal Mic", 0x6 }, 13458 { "Line", 0x2 }, 13459 }, 13460}; 13461 13462#ifdef CONFIG_SND_DEBUG 13463static struct snd_kcontrol_new alc268_test_mixer[] = { 13464 /* Volume widgets */ 13465 HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT), 13466 HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT), 13467 HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT), 13468 HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT), 13469 HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT), 13470 HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT), 13471 HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT), 13472 HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT), 13473 HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT), 13474 HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT), 13475 HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT), 13476 HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT), 13477 HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT), 13478 /* The below appears problematic on some hardwares */ 13479 /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/ 13480 HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT), 13481 HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT), 13482 HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT), 13483 HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT), 13484 13485 /* Modes for retasking pin widgets */ 13486 ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT), 13487 ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT), 13488 ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT), 13489 ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT), 13490 13491 /* Controls for GPIO pins, assuming they are configured as outputs */ 13492 ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01), 13493 ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02), 13494 ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04), 13495 ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08), 13496 13497 /* Switches to allow the digital SPDIF output pin to be enabled. 13498 * The ALC268 does not have an SPDIF input. 13499 */ 13500 ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01), 13501 13502 /* A switch allowing EAPD to be enabled. Some laptops seem to use 13503 * this output to turn on an external amplifier. 13504 */ 13505 ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02), 13506 ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02), 13507 13508 { } /* end */ 13509}; 13510#endif 13511 13512/* create input playback/capture controls for the given pin */ 13513static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid, 13514 const char *ctlname, int idx) 13515{ 13516 hda_nid_t dac; 13517 int err; 13518 13519 switch (nid) { 13520 case 0x14: 13521 case 0x16: 13522 dac = 0x02; 13523 break; 13524 case 0x15: 13525 case 0x1a: /* ALC259/269 only */ 13526 case 0x1b: /* ALC259/269 only */ 13527 case 0x21: /* ALC269vb has this pin, too */ 13528 dac = 0x03; 13529 break; 13530 default: 13531 snd_printd(KERN_WARNING "hda_codec: " 13532 "ignoring pin 0x%x as unknown\n", nid); 13533 return 0; 13534 } 13535 if (spec->multiout.dac_nids[0] != dac && 13536 spec->multiout.dac_nids[1] != dac) { 13537 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, 13538 HDA_COMPOSE_AMP_VAL(dac, 3, idx, 13539 HDA_OUTPUT)); 13540 if (err < 0) 13541 return err; 13542 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac; 13543 } 13544 13545 if (nid != 0x16) 13546 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, 13547 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT)); 13548 else /* mono */ 13549 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, 13550 HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT)); 13551 if (err < 0) 13552 return err; 13553 return 0; 13554} 13555 13556/* add playback controls from the parsed DAC table */ 13557static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec, 13558 const struct auto_pin_cfg *cfg) 13559{ 13560 hda_nid_t nid; 13561 int err; 13562 13563 spec->multiout.dac_nids = spec->private_dac_nids; 13564 13565 nid = cfg->line_out_pins[0]; 13566 if (nid) { 13567 const char *name; 13568 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) 13569 name = "Speaker"; 13570 else 13571 name = "Front"; 13572 err = alc268_new_analog_output(spec, nid, name, 0); 13573 if (err < 0) 13574 return err; 13575 } 13576 13577 nid = cfg->speaker_pins[0]; 13578 if (nid == 0x1d) { 13579 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker", 13580 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT)); 13581 if (err < 0) 13582 return err; 13583 } else if (nid) { 13584 err = alc268_new_analog_output(spec, nid, "Speaker", 0); 13585 if (err < 0) 13586 return err; 13587 } 13588 nid = cfg->hp_pins[0]; 13589 if (nid) { 13590 err = alc268_new_analog_output(spec, nid, "Headphone", 0); 13591 if (err < 0) 13592 return err; 13593 } 13594 13595 nid = cfg->line_out_pins[1] | cfg->line_out_pins[2]; 13596 if (nid == 0x16) { 13597 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono", 13598 HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT)); 13599 if (err < 0) 13600 return err; 13601 } 13602 return 0; 13603} 13604 13605/* create playback/capture controls for input pins */ 13606static int alc268_auto_create_input_ctls(struct hda_codec *codec, 13607 const struct auto_pin_cfg *cfg) 13608{ 13609 return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24); 13610} 13611 13612static void alc268_auto_set_output_and_unmute(struct hda_codec *codec, 13613 hda_nid_t nid, int pin_type) 13614{ 13615 int idx; 13616 13617 alc_set_pin_output(codec, nid, pin_type); 13618 if (nid == 0x14 || nid == 0x16) 13619 idx = 0; 13620 else 13621 idx = 1; 13622 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx); 13623} 13624 13625static void alc268_auto_init_multi_out(struct hda_codec *codec) 13626{ 13627 struct alc_spec *spec = codec->spec; 13628 int i; 13629 13630 for (i = 0; i < spec->autocfg.line_outs; i++) { 13631 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 13632 int pin_type = get_pin_type(spec->autocfg.line_out_type); 13633 alc268_auto_set_output_and_unmute(codec, nid, pin_type); 13634 } 13635} 13636 13637static void alc268_auto_init_hp_out(struct hda_codec *codec) 13638{ 13639 struct alc_spec *spec = codec->spec; 13640 hda_nid_t pin; 13641 int i; 13642 13643 for (i = 0; i < spec->autocfg.hp_outs; i++) { 13644 pin = spec->autocfg.hp_pins[i]; 13645 alc268_auto_set_output_and_unmute(codec, pin, PIN_HP); 13646 } 13647 for (i = 0; i < spec->autocfg.speaker_outs; i++) { 13648 pin = spec->autocfg.speaker_pins[i]; 13649 alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT); 13650 } 13651 if (spec->autocfg.mono_out_pin) 13652 snd_hda_codec_write(codec, spec->autocfg.mono_out_pin, 0, 13653 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 13654} 13655 13656static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec) 13657{ 13658 struct alc_spec *spec = codec->spec; 13659 hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0]; 13660 hda_nid_t hp_nid = spec->autocfg.hp_pins[0]; 13661 hda_nid_t line_nid = spec->autocfg.line_out_pins[0]; 13662 unsigned int dac_vol1, dac_vol2; 13663 13664 if (line_nid == 0x1d || speaker_nid == 0x1d) { 13665 snd_hda_codec_write(codec, speaker_nid, 0, 13666 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 13667 /* mute mixer inputs from 0x1d */ 13668 snd_hda_codec_write(codec, 0x0f, 0, 13669 AC_VERB_SET_AMP_GAIN_MUTE, 13670 AMP_IN_UNMUTE(1)); 13671 snd_hda_codec_write(codec, 0x10, 0, 13672 AC_VERB_SET_AMP_GAIN_MUTE, 13673 AMP_IN_UNMUTE(1)); 13674 } else { 13675 /* unmute mixer inputs from 0x1d */ 13676 snd_hda_codec_write(codec, 0x0f, 0, 13677 AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)); 13678 snd_hda_codec_write(codec, 0x10, 0, 13679 AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)); 13680 } 13681 13682 dac_vol1 = dac_vol2 = 0xb000 | 0x40; /* set max volume */ 13683 if (line_nid == 0x14) 13684 dac_vol2 = AMP_OUT_ZERO; 13685 else if (line_nid == 0x15) 13686 dac_vol1 = AMP_OUT_ZERO; 13687 if (hp_nid == 0x14) 13688 dac_vol2 = AMP_OUT_ZERO; 13689 else if (hp_nid == 0x15) 13690 dac_vol1 = AMP_OUT_ZERO; 13691 if (line_nid != 0x16 || hp_nid != 0x16 || 13692 spec->autocfg.line_out_pins[1] != 0x16 || 13693 spec->autocfg.line_out_pins[2] != 0x16) 13694 dac_vol1 = dac_vol2 = AMP_OUT_ZERO; 13695 13696 snd_hda_codec_write(codec, 0x02, 0, 13697 AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1); 13698 snd_hda_codec_write(codec, 0x03, 0, 13699 AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2); 13700} 13701 13702/* pcm configuration: identical with ALC880 */ 13703#define alc268_pcm_analog_playback alc880_pcm_analog_playback 13704#define alc268_pcm_analog_capture alc880_pcm_analog_capture 13705#define alc268_pcm_analog_alt_capture alc880_pcm_analog_alt_capture 13706#define alc268_pcm_digital_playback alc880_pcm_digital_playback 13707 13708/* 13709 * BIOS auto configuration 13710 */ 13711static int alc268_parse_auto_config(struct hda_codec *codec) 13712{ 13713 struct alc_spec *spec = codec->spec; 13714 int err; 13715 static hda_nid_t alc268_ignore[] = { 0 }; 13716 13717 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 13718 alc268_ignore); 13719 if (err < 0) 13720 return err; 13721 if (!spec->autocfg.line_outs) { 13722 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) { 13723 spec->multiout.max_channels = 2; 13724 spec->no_analog = 1; 13725 goto dig_only; 13726 } 13727 return 0; /* can't find valid BIOS pin config */ 13728 } 13729 err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg); 13730 if (err < 0) 13731 return err; 13732 err = alc268_auto_create_input_ctls(codec, &spec->autocfg); 13733 if (err < 0) 13734 return err; 13735 13736 spec->multiout.max_channels = 2; 13737 13738 dig_only: 13739 /* digital only support output */ 13740 alc_auto_parse_digital(codec); 13741 if (spec->kctls.list) 13742 add_mixer(spec, spec->kctls.list); 13743 13744 if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d) 13745 add_mixer(spec, alc268_beep_mixer); 13746 13747 add_verb(spec, alc268_volume_init_verbs); 13748 spec->num_mux_defs = 2; 13749 spec->input_mux = &spec->private_imux[0]; 13750 13751 err = alc_auto_add_mic_boost(codec); 13752 if (err < 0) 13753 return err; 13754 13755 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0); 13756 13757 return 1; 13758} 13759 13760#define alc268_auto_init_analog_input alc882_auto_init_analog_input 13761#define alc268_auto_init_input_src alc882_auto_init_input_src 13762 13763/* init callback for auto-configuration model -- overriding the default init */ 13764static void alc268_auto_init(struct hda_codec *codec) 13765{ 13766 struct alc_spec *spec = codec->spec; 13767 alc268_auto_init_multi_out(codec); 13768 alc268_auto_init_hp_out(codec); 13769 alc268_auto_init_mono_speaker_out(codec); 13770 alc268_auto_init_analog_input(codec); 13771 alc268_auto_init_input_src(codec); 13772 alc_auto_init_digital(codec); 13773 if (spec->unsol_event) 13774 alc_inithook(codec); 13775} 13776 13777/* 13778 * configuration and preset 13779 */ 13780static const char * const alc268_models[ALC268_MODEL_LAST] = { 13781 [ALC267_QUANTA_IL1] = "quanta-il1", 13782 [ALC268_3ST] = "3stack", 13783 [ALC268_TOSHIBA] = "toshiba", 13784 [ALC268_ACER] = "acer", 13785 [ALC268_ACER_DMIC] = "acer-dmic", 13786 [ALC268_ACER_ASPIRE_ONE] = "acer-aspire", 13787 [ALC268_DELL] = "dell", 13788 [ALC268_ZEPTO] = "zepto", 13789#ifdef CONFIG_SND_DEBUG 13790 [ALC268_TEST] = "test", 13791#endif 13792 [ALC268_AUTO] = "auto", 13793}; 13794 13795static struct snd_pci_quirk alc268_cfg_tbl[] = { 13796 SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER), 13797 SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER), 13798 SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER), 13799 SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER), 13800 SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER), 13801 SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One", 13802 ALC268_ACER_ASPIRE_ONE), 13803 SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL), 13804 SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0, 13805 "Dell Inspiron Mini9/Vostro A90", ALC268_DELL), 13806 /* almost compatible with toshiba but with optional digital outs; 13807 * auto-probing seems working fine 13808 */ 13809 SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series", 13810 ALC268_AUTO), 13811 SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST), 13812 SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO), 13813 SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA), 13814 SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER), 13815 SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1), 13816 {} 13817}; 13818 13819/* Toshiba laptops have no unique PCI SSID but only codec SSID */ 13820static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = { 13821 SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO), 13822 SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO), 13823 SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05", 13824 ALC268_TOSHIBA), 13825 {} 13826}; 13827 13828static struct alc_config_preset alc268_presets[] = { 13829 [ALC267_QUANTA_IL1] = { 13830 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer, 13831 alc268_capture_nosrc_mixer }, 13832 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 13833 alc267_quanta_il1_verbs }, 13834 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 13835 .dac_nids = alc268_dac_nids, 13836 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 13837 .adc_nids = alc268_adc_nids_alt, 13838 .hp_nid = 0x03, 13839 .num_channel_mode = ARRAY_SIZE(alc268_modes), 13840 .channel_mode = alc268_modes, 13841 .unsol_event = alc_sku_unsol_event, 13842 .setup = alc267_quanta_il1_setup, 13843 .init_hook = alc_inithook, 13844 }, 13845 [ALC268_3ST] = { 13846 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer, 13847 alc268_beep_mixer }, 13848 .init_verbs = { alc268_base_init_verbs }, 13849 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 13850 .dac_nids = alc268_dac_nids, 13851 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 13852 .adc_nids = alc268_adc_nids_alt, 13853 .capsrc_nids = alc268_capsrc_nids, 13854 .hp_nid = 0x03, 13855 .dig_out_nid = ALC268_DIGOUT_NID, 13856 .num_channel_mode = ARRAY_SIZE(alc268_modes), 13857 .channel_mode = alc268_modes, 13858 .input_mux = &alc268_capture_source, 13859 }, 13860 [ALC268_TOSHIBA] = { 13861 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer, 13862 alc268_beep_mixer }, 13863 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 13864 alc268_toshiba_verbs }, 13865 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 13866 .dac_nids = alc268_dac_nids, 13867 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 13868 .adc_nids = alc268_adc_nids_alt, 13869 .capsrc_nids = alc268_capsrc_nids, 13870 .hp_nid = 0x03, 13871 .num_channel_mode = ARRAY_SIZE(alc268_modes), 13872 .channel_mode = alc268_modes, 13873 .input_mux = &alc268_capture_source, 13874 .unsol_event = alc268_toshiba_unsol_event, 13875 .setup = alc268_toshiba_setup, 13876 .init_hook = alc268_toshiba_automute, 13877 }, 13878 [ALC268_ACER] = { 13879 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer, 13880 alc268_beep_mixer }, 13881 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 13882 alc268_acer_verbs }, 13883 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 13884 .dac_nids = alc268_dac_nids, 13885 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 13886 .adc_nids = alc268_adc_nids_alt, 13887 .capsrc_nids = alc268_capsrc_nids, 13888 .hp_nid = 0x02, 13889 .num_channel_mode = ARRAY_SIZE(alc268_modes), 13890 .channel_mode = alc268_modes, 13891 .input_mux = &alc268_acer_capture_source, 13892 .unsol_event = alc268_acer_unsol_event, 13893 .init_hook = alc268_acer_init_hook, 13894 }, 13895 [ALC268_ACER_DMIC] = { 13896 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer, 13897 alc268_beep_mixer }, 13898 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 13899 alc268_acer_verbs }, 13900 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 13901 .dac_nids = alc268_dac_nids, 13902 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 13903 .adc_nids = alc268_adc_nids_alt, 13904 .capsrc_nids = alc268_capsrc_nids, 13905 .hp_nid = 0x02, 13906 .num_channel_mode = ARRAY_SIZE(alc268_modes), 13907 .channel_mode = alc268_modes, 13908 .input_mux = &alc268_acer_dmic_capture_source, 13909 .unsol_event = alc268_acer_unsol_event, 13910 .init_hook = alc268_acer_init_hook, 13911 }, 13912 [ALC268_ACER_ASPIRE_ONE] = { 13913 .mixers = { alc268_acer_aspire_one_mixer, 13914 alc268_beep_mixer, 13915 alc268_capture_nosrc_mixer }, 13916 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 13917 alc268_acer_aspire_one_verbs }, 13918 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 13919 .dac_nids = alc268_dac_nids, 13920 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 13921 .adc_nids = alc268_adc_nids_alt, 13922 .capsrc_nids = alc268_capsrc_nids, 13923 .hp_nid = 0x03, 13924 .num_channel_mode = ARRAY_SIZE(alc268_modes), 13925 .channel_mode = alc268_modes, 13926 .unsol_event = alc268_acer_lc_unsol_event, 13927 .setup = alc268_acer_lc_setup, 13928 .init_hook = alc268_acer_lc_init_hook, 13929 }, 13930 [ALC268_DELL] = { 13931 .mixers = { alc268_dell_mixer, alc268_beep_mixer, 13932 alc268_capture_nosrc_mixer }, 13933 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 13934 alc268_dell_verbs }, 13935 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 13936 .dac_nids = alc268_dac_nids, 13937 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 13938 .adc_nids = alc268_adc_nids_alt, 13939 .capsrc_nids = alc268_capsrc_nids, 13940 .hp_nid = 0x02, 13941 .num_channel_mode = ARRAY_SIZE(alc268_modes), 13942 .channel_mode = alc268_modes, 13943 .unsol_event = alc_sku_unsol_event, 13944 .setup = alc268_dell_setup, 13945 .init_hook = alc_inithook, 13946 }, 13947 [ALC268_ZEPTO] = { 13948 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer, 13949 alc268_beep_mixer }, 13950 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 13951 alc268_toshiba_verbs }, 13952 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 13953 .dac_nids = alc268_dac_nids, 13954 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 13955 .adc_nids = alc268_adc_nids_alt, 13956 .capsrc_nids = alc268_capsrc_nids, 13957 .hp_nid = 0x03, 13958 .dig_out_nid = ALC268_DIGOUT_NID, 13959 .num_channel_mode = ARRAY_SIZE(alc268_modes), 13960 .channel_mode = alc268_modes, 13961 .input_mux = &alc268_capture_source, 13962 .setup = alc268_toshiba_setup, 13963 .init_hook = alc268_toshiba_automute, 13964 }, 13965#ifdef CONFIG_SND_DEBUG 13966 [ALC268_TEST] = { 13967 .mixers = { alc268_test_mixer, alc268_capture_mixer }, 13968 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 13969 alc268_volume_init_verbs }, 13970 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 13971 .dac_nids = alc268_dac_nids, 13972 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 13973 .adc_nids = alc268_adc_nids_alt, 13974 .capsrc_nids = alc268_capsrc_nids, 13975 .hp_nid = 0x03, 13976 .dig_out_nid = ALC268_DIGOUT_NID, 13977 .num_channel_mode = ARRAY_SIZE(alc268_modes), 13978 .channel_mode = alc268_modes, 13979 .input_mux = &alc268_capture_source, 13980 }, 13981#endif 13982}; 13983 13984static int patch_alc268(struct hda_codec *codec) 13985{ 13986 struct alc_spec *spec; 13987 int board_config; 13988 int i, has_beep, err; 13989 13990 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 13991 if (spec == NULL) 13992 return -ENOMEM; 13993 13994 codec->spec = spec; 13995 13996 board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST, 13997 alc268_models, 13998 alc268_cfg_tbl); 13999 14000 if (board_config < 0 || board_config >= ALC268_MODEL_LAST) 14001 board_config = snd_hda_check_board_codec_sid_config(codec, 14002 ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl); 14003 14004 if (board_config < 0 || board_config >= ALC268_MODEL_LAST) { 14005 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 14006 codec->chip_name); 14007 board_config = ALC268_AUTO; 14008 } 14009 14010 if (board_config == ALC268_AUTO) { 14011 /* automatic parse from the BIOS config */ 14012 err = alc268_parse_auto_config(codec); 14013 if (err < 0) { 14014 alc_free(codec); 14015 return err; 14016 } else if (!err) { 14017 printk(KERN_INFO 14018 "hda_codec: Cannot set up configuration " 14019 "from BIOS. Using base mode...\n"); 14020 board_config = ALC268_3ST; 14021 } 14022 } 14023 14024 if (board_config != ALC268_AUTO) 14025 setup_preset(codec, &alc268_presets[board_config]); 14026 14027 spec->stream_analog_playback = &alc268_pcm_analog_playback; 14028 spec->stream_analog_capture = &alc268_pcm_analog_capture; 14029 spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture; 14030 14031 spec->stream_digital_playback = &alc268_pcm_digital_playback; 14032 14033 has_beep = 0; 14034 for (i = 0; i < spec->num_mixers; i++) { 14035 if (spec->mixers[i] == alc268_beep_mixer) { 14036 has_beep = 1; 14037 break; 14038 } 14039 } 14040 14041 if (has_beep) { 14042 err = snd_hda_attach_beep_device(codec, 0x1); 14043 if (err < 0) { 14044 alc_free(codec); 14045 return err; 14046 } 14047 if (!query_amp_caps(codec, 0x1d, HDA_INPUT)) 14048 /* override the amp caps for beep generator */ 14049 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT, 14050 (0x0c << AC_AMPCAP_OFFSET_SHIFT) | 14051 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) | 14052 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) | 14053 (0 << AC_AMPCAP_MUTE_SHIFT)); 14054 } 14055 14056 if (!spec->no_analog && !spec->adc_nids && spec->input_mux) { 14057 /* check whether NID 0x07 is valid */ 14058 unsigned int wcap = get_wcaps(codec, 0x07); 14059 int i; 14060 14061 spec->capsrc_nids = alc268_capsrc_nids; 14062 /* get type */ 14063 wcap = get_wcaps_type(wcap); 14064 if (spec->auto_mic || 14065 wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) { 14066 spec->adc_nids = alc268_adc_nids_alt; 14067 spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt); 14068 if (spec->auto_mic) 14069 fixup_automic_adc(codec); 14070 if (spec->auto_mic || spec->input_mux->num_items == 1) 14071 add_mixer(spec, alc268_capture_nosrc_mixer); 14072 else 14073 add_mixer(spec, alc268_capture_alt_mixer); 14074 } else { 14075 spec->adc_nids = alc268_adc_nids; 14076 spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids); 14077 add_mixer(spec, alc268_capture_mixer); 14078 } 14079 } 14080 14081 spec->vmaster_nid = 0x02; 14082 14083 codec->patch_ops = alc_patch_ops; 14084 if (board_config == ALC268_AUTO) 14085 spec->init_hook = alc268_auto_init; 14086 14087 alc_init_jacks(codec); 14088 14089 return 0; 14090} 14091 14092/* 14093 * ALC269 channel source setting (2 channel) 14094 */ 14095#define ALC269_DIGOUT_NID ALC880_DIGOUT_NID 14096 14097#define alc269_dac_nids alc260_dac_nids 14098 14099static hda_nid_t alc269_adc_nids[1] = { 14100 /* ADC1 */ 14101 0x08, 14102}; 14103 14104static hda_nid_t alc269_capsrc_nids[1] = { 14105 0x23, 14106}; 14107 14108static hda_nid_t alc269vb_adc_nids[1] = { 14109 /* ADC1 */ 14110 0x09, 14111}; 14112 14113static hda_nid_t alc269vb_capsrc_nids[1] = { 14114 0x22, 14115}; 14116 14117static hda_nid_t alc269_adc_candidates[] = { 14118 0x08, 0x09, 0x07, 14119}; 14120 14121#define alc269_modes alc260_modes 14122#define alc269_capture_source alc880_lg_lw_capture_source 14123 14124static struct snd_kcontrol_new alc269_base_mixer[] = { 14125 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 14126 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 14127 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 14128 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 14129 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 14130 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 14131 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 14132 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 14133 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 14134 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT), 14135 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 14136 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT), 14137 { } /* end */ 14138}; 14139 14140static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = { 14141 /* output mixer control */ 14142 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol), 14143 { 14144 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 14145 .name = "Master Playback Switch", 14146 .subdevice = HDA_SUBDEV_AMP_FLAG, 14147 .info = snd_hda_mixer_amp_switch_info, 14148 .get = snd_hda_mixer_amp_switch_get, 14149 .put = alc268_acer_master_sw_put, 14150 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 14151 }, 14152 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 14153 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 14154 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 14155 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 14156 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 14157 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT), 14158 { } 14159}; 14160 14161static struct snd_kcontrol_new alc269_lifebook_mixer[] = { 14162 /* output mixer control */ 14163 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol), 14164 { 14165 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 14166 .name = "Master Playback Switch", 14167 .subdevice = HDA_SUBDEV_AMP_FLAG, 14168 .info = snd_hda_mixer_amp_switch_info, 14169 .get = snd_hda_mixer_amp_switch_get, 14170 .put = alc268_acer_master_sw_put, 14171 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 14172 }, 14173 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 14174 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 14175 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 14176 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 14177 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 14178 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT), 14179 HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT), 14180 HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT), 14181 HDA_CODEC_VOLUME("Dock Mic Boost Volume", 0x1b, 0, HDA_INPUT), 14182 { } 14183}; 14184 14185static struct snd_kcontrol_new alc269_laptop_mixer[] = { 14186 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 14187 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 14188 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 14189 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 14190 { } /* end */ 14191}; 14192 14193static struct snd_kcontrol_new alc269vb_laptop_mixer[] = { 14194 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 14195 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 14196 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT), 14197 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 14198 { } /* end */ 14199}; 14200 14201static struct snd_kcontrol_new alc269_asus_mixer[] = { 14202 HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT), 14203 HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x0, HDA_INPUT), 14204 { } /* end */ 14205}; 14206 14207/* capture mixer elements */ 14208static struct snd_kcontrol_new alc269_laptop_analog_capture_mixer[] = { 14209 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 14210 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 14211 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 14212 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT), 14213 { } /* end */ 14214}; 14215 14216static struct snd_kcontrol_new alc269_laptop_digital_capture_mixer[] = { 14217 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 14218 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 14219 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 14220 { } /* end */ 14221}; 14222 14223static struct snd_kcontrol_new alc269vb_laptop_analog_capture_mixer[] = { 14224 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT), 14225 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT), 14226 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 14227 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT), 14228 { } /* end */ 14229}; 14230 14231static struct snd_kcontrol_new alc269vb_laptop_digital_capture_mixer[] = { 14232 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT), 14233 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT), 14234 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 14235 { } /* end */ 14236}; 14237 14238/* FSC amilo */ 14239#define alc269_fujitsu_mixer alc269_laptop_mixer 14240 14241static struct hda_verb alc269_quanta_fl1_verbs[] = { 14242 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 14243 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14244 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 14245 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 14246 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 14247 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14248 { } 14249}; 14250 14251static struct hda_verb alc269_lifebook_verbs[] = { 14252 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 14253 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, 14254 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14255 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 14256 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 14257 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14258 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 14259 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 14260 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 14261 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14262 { } 14263}; 14264 14265/* toggle speaker-output according to the hp-jack state */ 14266static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec) 14267{ 14268 unsigned int present; 14269 unsigned char bits; 14270 14271 present = snd_hda_jack_detect(codec, 0x15); 14272 bits = present ? HDA_AMP_MUTE : 0; 14273 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 14274 HDA_AMP_MUTE, bits); 14275 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 14276 HDA_AMP_MUTE, bits); 14277 14278 snd_hda_codec_write(codec, 0x20, 0, 14279 AC_VERB_SET_COEF_INDEX, 0x0c); 14280 snd_hda_codec_write(codec, 0x20, 0, 14281 AC_VERB_SET_PROC_COEF, 0x680); 14282 14283 snd_hda_codec_write(codec, 0x20, 0, 14284 AC_VERB_SET_COEF_INDEX, 0x0c); 14285 snd_hda_codec_write(codec, 0x20, 0, 14286 AC_VERB_SET_PROC_COEF, 0x480); 14287} 14288 14289/* toggle speaker-output according to the hp-jacks state */ 14290static void alc269_lifebook_speaker_automute(struct hda_codec *codec) 14291{ 14292 unsigned int present; 14293 unsigned char bits; 14294 14295 /* Check laptop headphone socket */ 14296 present = snd_hda_jack_detect(codec, 0x15); 14297 14298 /* Check port replicator headphone socket */ 14299 present |= snd_hda_jack_detect(codec, 0x1a); 14300 14301 bits = present ? HDA_AMP_MUTE : 0; 14302 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 14303 HDA_AMP_MUTE, bits); 14304 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 14305 HDA_AMP_MUTE, bits); 14306 14307 snd_hda_codec_write(codec, 0x20, 0, 14308 AC_VERB_SET_COEF_INDEX, 0x0c); 14309 snd_hda_codec_write(codec, 0x20, 0, 14310 AC_VERB_SET_PROC_COEF, 0x680); 14311 14312 snd_hda_codec_write(codec, 0x20, 0, 14313 AC_VERB_SET_COEF_INDEX, 0x0c); 14314 snd_hda_codec_write(codec, 0x20, 0, 14315 AC_VERB_SET_PROC_COEF, 0x480); 14316} 14317 14318static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec) 14319{ 14320 unsigned int present_laptop; 14321 unsigned int present_dock; 14322 14323 present_laptop = snd_hda_jack_detect(codec, 0x18); 14324 present_dock = snd_hda_jack_detect(codec, 0x1b); 14325 14326 /* Laptop mic port overrides dock mic port, design decision */ 14327 if (present_dock) 14328 snd_hda_codec_write(codec, 0x23, 0, 14329 AC_VERB_SET_CONNECT_SEL, 0x3); 14330 if (present_laptop) 14331 snd_hda_codec_write(codec, 0x23, 0, 14332 AC_VERB_SET_CONNECT_SEL, 0x0); 14333 if (!present_dock && !present_laptop) 14334 snd_hda_codec_write(codec, 0x23, 0, 14335 AC_VERB_SET_CONNECT_SEL, 0x1); 14336} 14337 14338static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec, 14339 unsigned int res) 14340{ 14341 switch (res >> 26) { 14342 case ALC880_HP_EVENT: 14343 alc269_quanta_fl1_speaker_automute(codec); 14344 break; 14345 case ALC880_MIC_EVENT: 14346 alc_mic_automute(codec); 14347 break; 14348 } 14349} 14350 14351static void alc269_lifebook_unsol_event(struct hda_codec *codec, 14352 unsigned int res) 14353{ 14354 if ((res >> 26) == ALC880_HP_EVENT) 14355 alc269_lifebook_speaker_automute(codec); 14356 if ((res >> 26) == ALC880_MIC_EVENT) 14357 alc269_lifebook_mic_autoswitch(codec); 14358} 14359 14360static void alc269_quanta_fl1_setup(struct hda_codec *codec) 14361{ 14362 struct alc_spec *spec = codec->spec; 14363 spec->autocfg.hp_pins[0] = 0x15; 14364 spec->autocfg.speaker_pins[0] = 0x14; 14365 spec->ext_mic.pin = 0x18; 14366 spec->ext_mic.mux_idx = 0; 14367 spec->int_mic.pin = 0x19; 14368 spec->int_mic.mux_idx = 1; 14369 spec->auto_mic = 1; 14370} 14371 14372static void alc269_quanta_fl1_init_hook(struct hda_codec *codec) 14373{ 14374 alc269_quanta_fl1_speaker_automute(codec); 14375 alc_mic_automute(codec); 14376} 14377 14378static void alc269_lifebook_init_hook(struct hda_codec *codec) 14379{ 14380 alc269_lifebook_speaker_automute(codec); 14381 alc269_lifebook_mic_autoswitch(codec); 14382} 14383 14384static struct hda_verb alc269_laptop_dmic_init_verbs[] = { 14385 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 14386 {0x23, AC_VERB_SET_CONNECT_SEL, 0x05}, 14387 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 }, 14388 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))}, 14389 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14390 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 14391 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 14392 {} 14393}; 14394 14395static struct hda_verb alc269_laptop_amic_init_verbs[] = { 14396 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 14397 {0x23, AC_VERB_SET_CONNECT_SEL, 0x01}, 14398 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 }, 14399 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))}, 14400 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 14401 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 14402 {} 14403}; 14404 14405static struct hda_verb alc269vb_laptop_dmic_init_verbs[] = { 14406 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01}, 14407 {0x22, AC_VERB_SET_CONNECT_SEL, 0x06}, 14408 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 }, 14409 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))}, 14410 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14411 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 14412 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 14413 {} 14414}; 14415 14416static struct hda_verb alc269vb_laptop_amic_init_verbs[] = { 14417 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01}, 14418 {0x22, AC_VERB_SET_CONNECT_SEL, 0x01}, 14419 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 }, 14420 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))}, 14421 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14422 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 14423 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 14424 {} 14425}; 14426 14427static struct hda_verb alc271_acer_dmic_verbs[] = { 14428 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d}, 14429 {0x20, AC_VERB_SET_PROC_COEF, 0x4000}, 14430 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14431 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14432 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 14433 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14434 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00}, 14435 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 14436 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 14437 {0x22, AC_VERB_SET_CONNECT_SEL, 6}, 14438 { } 14439}; 14440 14441/* toggle speaker-output according to the hp-jack state */ 14442static void alc269_speaker_automute(struct hda_codec *codec) 14443{ 14444 struct alc_spec *spec = codec->spec; 14445 unsigned int nid = spec->autocfg.hp_pins[0]; 14446 unsigned int present; 14447 unsigned char bits; 14448 14449 present = snd_hda_jack_detect(codec, nid); 14450 bits = present ? HDA_AMP_MUTE : 0; 14451 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 14452 HDA_AMP_MUTE, bits); 14453 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 14454 HDA_AMP_MUTE, bits); 14455 snd_hda_input_jack_report(codec, nid); 14456} 14457 14458/* unsolicited event for HP jack sensing */ 14459static void alc269_laptop_unsol_event(struct hda_codec *codec, 14460 unsigned int res) 14461{ 14462 switch (res >> 26) { 14463 case ALC880_HP_EVENT: 14464 alc269_speaker_automute(codec); 14465 break; 14466 case ALC880_MIC_EVENT: 14467 alc_mic_automute(codec); 14468 break; 14469 } 14470} 14471 14472static void alc269_laptop_amic_setup(struct hda_codec *codec) 14473{ 14474 struct alc_spec *spec = codec->spec; 14475 spec->autocfg.hp_pins[0] = 0x15; 14476 spec->autocfg.speaker_pins[0] = 0x14; 14477 spec->ext_mic.pin = 0x18; 14478 spec->ext_mic.mux_idx = 0; 14479 spec->int_mic.pin = 0x19; 14480 spec->int_mic.mux_idx = 1; 14481 spec->auto_mic = 1; 14482} 14483 14484static void alc269_laptop_dmic_setup(struct hda_codec *codec) 14485{ 14486 struct alc_spec *spec = codec->spec; 14487 spec->autocfg.hp_pins[0] = 0x15; 14488 spec->autocfg.speaker_pins[0] = 0x14; 14489 spec->ext_mic.pin = 0x18; 14490 spec->ext_mic.mux_idx = 0; 14491 spec->int_mic.pin = 0x12; 14492 spec->int_mic.mux_idx = 5; 14493 spec->auto_mic = 1; 14494} 14495 14496static void alc269vb_laptop_amic_setup(struct hda_codec *codec) 14497{ 14498 struct alc_spec *spec = codec->spec; 14499 spec->autocfg.hp_pins[0] = 0x21; 14500 spec->autocfg.speaker_pins[0] = 0x14; 14501 spec->ext_mic.pin = 0x18; 14502 spec->ext_mic.mux_idx = 0; 14503 spec->int_mic.pin = 0x19; 14504 spec->int_mic.mux_idx = 1; 14505 spec->auto_mic = 1; 14506} 14507 14508static void alc269vb_laptop_dmic_setup(struct hda_codec *codec) 14509{ 14510 struct alc_spec *spec = codec->spec; 14511 spec->autocfg.hp_pins[0] = 0x21; 14512 spec->autocfg.speaker_pins[0] = 0x14; 14513 spec->ext_mic.pin = 0x18; 14514 spec->ext_mic.mux_idx = 0; 14515 spec->int_mic.pin = 0x12; 14516 spec->int_mic.mux_idx = 6; 14517 spec->auto_mic = 1; 14518} 14519 14520static void alc269_laptop_inithook(struct hda_codec *codec) 14521{ 14522 alc269_speaker_automute(codec); 14523 alc_mic_automute(codec); 14524} 14525 14526/* 14527 * generic initialization of ADC, input mixers and output mixers 14528 */ 14529static struct hda_verb alc269_init_verbs[] = { 14530 /* 14531 * Unmute ADC0 and set the default input to mic-in 14532 */ 14533 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14534 14535 /* 14536 * Set up output mixers (0x02 - 0x03) 14537 */ 14538 /* set vol=0 to output mixers */ 14539 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14540 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14541 14542 /* set up input amps for analog loopback */ 14543 /* Amp Indices: DAC = 0, mixer = 1 */ 14544 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14545 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14546 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14547 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14548 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14549 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14550 14551 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14552 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 14553 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14554 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 14555 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 14556 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14557 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14558 14559 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14560 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14561 14562 /* FIXME: use Mux-type input source selection */ 14563 /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */ 14564 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 14565 {0x23, AC_VERB_SET_CONNECT_SEL, 0x00}, 14566 14567 /* set EAPD */ 14568 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 14569 { } 14570}; 14571 14572static struct hda_verb alc269vb_init_verbs[] = { 14573 /* 14574 * Unmute ADC0 and set the default input to mic-in 14575 */ 14576 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14577 14578 /* 14579 * Set up output mixers (0x02 - 0x03) 14580 */ 14581 /* set vol=0 to output mixers */ 14582 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14583 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14584 14585 /* set up input amps for analog loopback */ 14586 /* Amp Indices: DAC = 0, mixer = 1 */ 14587 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14588 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14589 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14590 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14591 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14592 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14593 14594 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14595 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 14596 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14597 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 14598 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 14599 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14600 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14601 14602 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14603 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14604 14605 /* FIXME: use Mux-type input source selection */ 14606 /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */ 14607 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 14608 {0x22, AC_VERB_SET_CONNECT_SEL, 0x00}, 14609 14610 /* set EAPD */ 14611 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 14612 { } 14613}; 14614 14615#define alc269_auto_create_multi_out_ctls \ 14616 alc268_auto_create_multi_out_ctls 14617#define alc269_auto_create_input_ctls \ 14618 alc268_auto_create_input_ctls 14619 14620#ifdef CONFIG_SND_HDA_POWER_SAVE 14621#define alc269_loopbacks alc880_loopbacks 14622#endif 14623 14624/* pcm configuration: identical with ALC880 */ 14625#define alc269_pcm_analog_playback alc880_pcm_analog_playback 14626#define alc269_pcm_analog_capture alc880_pcm_analog_capture 14627#define alc269_pcm_digital_playback alc880_pcm_digital_playback 14628#define alc269_pcm_digital_capture alc880_pcm_digital_capture 14629 14630static struct hda_pcm_stream alc269_44k_pcm_analog_playback = { 14631 .substreams = 1, 14632 .channels_min = 2, 14633 .channels_max = 8, 14634 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */ 14635 /* NID is set in alc_build_pcms */ 14636 .ops = { 14637 .open = alc880_playback_pcm_open, 14638 .prepare = alc880_playback_pcm_prepare, 14639 .cleanup = alc880_playback_pcm_cleanup 14640 }, 14641}; 14642 14643static struct hda_pcm_stream alc269_44k_pcm_analog_capture = { 14644 .substreams = 1, 14645 .channels_min = 2, 14646 .channels_max = 2, 14647 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */ 14648 /* NID is set in alc_build_pcms */ 14649}; 14650 14651#ifdef CONFIG_SND_HDA_POWER_SAVE 14652static int alc269_mic2_for_mute_led(struct hda_codec *codec) 14653{ 14654 switch (codec->subsystem_id) { 14655 case 0x103c1586: 14656 return 1; 14657 } 14658 return 0; 14659} 14660 14661static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid) 14662{ 14663 /* update mute-LED according to the speaker mute state */ 14664 if (nid == 0x01 || nid == 0x14) { 14665 int pinval; 14666 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) & 14667 HDA_AMP_MUTE) 14668 pinval = 0x24; 14669 else 14670 pinval = 0x20; 14671 /* mic2 vref pin is used for mute LED control */ 14672 snd_hda_codec_update_cache(codec, 0x19, 0, 14673 AC_VERB_SET_PIN_WIDGET_CONTROL, 14674 pinval); 14675 } 14676 return alc_check_power_status(codec, nid); 14677} 14678#endif /* CONFIG_SND_HDA_POWER_SAVE */ 14679 14680static int alc275_setup_dual_adc(struct hda_codec *codec) 14681{ 14682 struct alc_spec *spec = codec->spec; 14683 14684 if (codec->vendor_id != 0x10ec0275 || !spec->auto_mic) 14685 return 0; 14686 if ((spec->ext_mic.pin >= 0x18 && spec->int_mic.pin <= 0x13) || 14687 (spec->ext_mic.pin <= 0x12 && spec->int_mic.pin >= 0x18)) { 14688 if (spec->ext_mic.pin <= 0x12) { 14689 spec->private_adc_nids[0] = 0x08; 14690 spec->private_adc_nids[1] = 0x11; 14691 spec->private_capsrc_nids[0] = 0x23; 14692 spec->private_capsrc_nids[1] = 0x22; 14693 } else { 14694 spec->private_adc_nids[0] = 0x11; 14695 spec->private_adc_nids[1] = 0x08; 14696 spec->private_capsrc_nids[0] = 0x22; 14697 spec->private_capsrc_nids[1] = 0x23; 14698 } 14699 spec->adc_nids = spec->private_adc_nids; 14700 spec->capsrc_nids = spec->private_capsrc_nids; 14701 spec->num_adc_nids = 2; 14702 spec->dual_adc_switch = 1; 14703 snd_printdd("realtek: enabling dual ADC switchg (%02x:%02x)\n", 14704 spec->adc_nids[0], spec->adc_nids[1]); 14705 return 1; 14706 } 14707 return 0; 14708} 14709 14710/* different alc269-variants */ 14711enum { 14712 ALC269_TYPE_NORMAL, 14713 ALC269_TYPE_ALC258, 14714 ALC269_TYPE_ALC259, 14715 ALC269_TYPE_ALC269VB, 14716 ALC269_TYPE_ALC270, 14717 ALC269_TYPE_ALC271X, 14718}; 14719 14720/* 14721 * BIOS auto configuration 14722 */ 14723static int alc269_parse_auto_config(struct hda_codec *codec) 14724{ 14725 struct alc_spec *spec = codec->spec; 14726 int err; 14727 static hda_nid_t alc269_ignore[] = { 0x1d, 0 }; 14728 14729 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 14730 alc269_ignore); 14731 if (err < 0) 14732 return err; 14733 14734 err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg); 14735 if (err < 0) 14736 return err; 14737 if (spec->codec_variant == ALC269_TYPE_NORMAL) 14738 err = alc269_auto_create_input_ctls(codec, &spec->autocfg); 14739 else 14740 err = alc_auto_create_input_ctls(codec, &spec->autocfg, 0, 14741 0x22, 0); 14742 if (err < 0) 14743 return err; 14744 14745 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 14746 14747 alc_auto_parse_digital(codec); 14748 14749 if (spec->kctls.list) 14750 add_mixer(spec, spec->kctls.list); 14751 14752 if (spec->codec_variant != ALC269_TYPE_NORMAL) { 14753 add_verb(spec, alc269vb_init_verbs); 14754 alc_ssid_check(codec, 0, 0x1b, 0x14, 0x21); 14755 } else { 14756 add_verb(spec, alc269_init_verbs); 14757 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0); 14758 } 14759 14760 spec->num_mux_defs = 1; 14761 spec->input_mux = &spec->private_imux[0]; 14762 14763 if (!alc275_setup_dual_adc(codec)) 14764 fillup_priv_adc_nids(codec, alc269_adc_candidates, 14765 sizeof(alc269_adc_candidates)); 14766 14767 err = alc_auto_add_mic_boost(codec); 14768 if (err < 0) 14769 return err; 14770 14771 if (!spec->cap_mixer && !spec->no_analog) 14772 set_capture_mixer(codec); 14773 14774 return 1; 14775} 14776 14777#define alc269_auto_init_multi_out alc268_auto_init_multi_out 14778#define alc269_auto_init_hp_out alc268_auto_init_hp_out 14779#define alc269_auto_init_analog_input alc882_auto_init_analog_input 14780#define alc269_auto_init_input_src alc882_auto_init_input_src 14781 14782 14783/* init callback for auto-configuration model -- overriding the default init */ 14784static void alc269_auto_init(struct hda_codec *codec) 14785{ 14786 struct alc_spec *spec = codec->spec; 14787 alc269_auto_init_multi_out(codec); 14788 alc269_auto_init_hp_out(codec); 14789 alc269_auto_init_analog_input(codec); 14790 if (!spec->dual_adc_switch) 14791 alc269_auto_init_input_src(codec); 14792 alc_auto_init_digital(codec); 14793 if (spec->unsol_event) 14794 alc_inithook(codec); 14795} 14796 14797#ifdef SND_HDA_NEEDS_RESUME 14798static void alc269_toggle_power_output(struct hda_codec *codec, int power_up) 14799{ 14800 int val = alc_read_coef_idx(codec, 0x04); 14801 if (power_up) 14802 val |= 1 << 11; 14803 else 14804 val &= ~(1 << 11); 14805 alc_write_coef_idx(codec, 0x04, val); 14806} 14807 14808#ifdef CONFIG_SND_HDA_POWER_SAVE 14809static int alc269_suspend(struct hda_codec *codec, pm_message_t state) 14810{ 14811 struct alc_spec *spec = codec->spec; 14812 14813 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) 14814 alc269_toggle_power_output(codec, 0); 14815 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) { 14816 alc269_toggle_power_output(codec, 0); 14817 msleep(150); 14818 } 14819 14820 alc_shutup(codec); 14821 if (spec && spec->power_hook) 14822 spec->power_hook(codec); 14823 return 0; 14824} 14825#endif /* CONFIG_SND_HDA_POWER_SAVE */ 14826 14827static int alc269_resume(struct hda_codec *codec) 14828{ 14829 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) { 14830 alc269_toggle_power_output(codec, 0); 14831 msleep(150); 14832 } 14833 14834 codec->patch_ops.init(codec); 14835 14836 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) { 14837 alc269_toggle_power_output(codec, 1); 14838 msleep(200); 14839 } 14840 14841 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) 14842 alc269_toggle_power_output(codec, 1); 14843 14844 snd_hda_codec_resume_amp(codec); 14845 snd_hda_codec_resume_cache(codec); 14846 hda_call_check_power_status(codec, 0x01); 14847 return 0; 14848} 14849#endif /* SND_HDA_NEEDS_RESUME */ 14850 14851static void alc269_fixup_hweq(struct hda_codec *codec, 14852 const struct alc_fixup *fix, int action) 14853{ 14854 int coef; 14855 14856 if (action != ALC_FIXUP_ACT_INIT) 14857 return; 14858 coef = alc_read_coef_idx(codec, 0x1e); 14859 alc_write_coef_idx(codec, 0x1e, coef | 0x80); 14860} 14861 14862enum { 14863 ALC269_FIXUP_SONY_VAIO, 14864 ALC275_FIXUP_SONY_VAIO_GPIO2, 14865 ALC269_FIXUP_DELL_M101Z, 14866 ALC269_FIXUP_SKU_IGNORE, 14867 ALC269_FIXUP_ASUS_G73JW, 14868 ALC269_FIXUP_LENOVO_EAPD, 14869 ALC275_FIXUP_SONY_HWEQ, 14870}; 14871 14872static const struct alc_fixup alc269_fixups[] = { 14873 [ALC269_FIXUP_SONY_VAIO] = { 14874 .type = ALC_FIXUP_VERBS, 14875 .v.verbs = (const struct hda_verb[]) { 14876 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD}, 14877 {} 14878 } 14879 }, 14880 [ALC275_FIXUP_SONY_VAIO_GPIO2] = { 14881 .type = ALC_FIXUP_VERBS, 14882 .v.verbs = (const struct hda_verb[]) { 14883 {0x01, AC_VERB_SET_GPIO_MASK, 0x04}, 14884 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04}, 14885 {0x01, AC_VERB_SET_GPIO_DATA, 0x00}, 14886 { } 14887 }, 14888 .chained = true, 14889 .chain_id = ALC269_FIXUP_SONY_VAIO 14890 }, 14891 [ALC269_FIXUP_DELL_M101Z] = { 14892 .type = ALC_FIXUP_VERBS, 14893 .v.verbs = (const struct hda_verb[]) { 14894 /* Enables internal speaker */ 14895 {0x20, AC_VERB_SET_COEF_INDEX, 13}, 14896 {0x20, AC_VERB_SET_PROC_COEF, 0x4040}, 14897 {} 14898 } 14899 }, 14900 [ALC269_FIXUP_SKU_IGNORE] = { 14901 .type = ALC_FIXUP_SKU, 14902 .v.sku = ALC_FIXUP_SKU_IGNORE, 14903 }, 14904 [ALC269_FIXUP_ASUS_G73JW] = { 14905 .type = ALC_FIXUP_PINS, 14906 .v.pins = (const struct alc_pincfg[]) { 14907 { 0x17, 0x99130111 }, /* subwoofer */ 14908 { } 14909 } 14910 }, 14911 [ALC269_FIXUP_LENOVO_EAPD] = { 14912 .type = ALC_FIXUP_VERBS, 14913 .v.verbs = (const struct hda_verb[]) { 14914 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0}, 14915 {} 14916 } 14917 }, 14918 [ALC275_FIXUP_SONY_HWEQ] = { 14919 .type = ALC_FIXUP_FUNC, 14920 .v.func = alc269_fixup_hweq, 14921 .chained = true, 14922 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2 14923 } 14924}; 14925 14926static struct snd_pci_quirk alc269_fixup_tbl[] = { 14927 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2), 14928 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ), 14929 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ), 14930 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO), 14931 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z), 14932 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE), 14933 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE), 14934 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE), 14935 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE), 14936 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE), 14937 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW), 14938 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD), 14939 {} 14940}; 14941 14942 14943/* 14944 * configuration and preset 14945 */ 14946static const char * const alc269_models[ALC269_MODEL_LAST] = { 14947 [ALC269_BASIC] = "basic", 14948 [ALC269_QUANTA_FL1] = "quanta", 14949 [ALC269_AMIC] = "laptop-amic", 14950 [ALC269_DMIC] = "laptop-dmic", 14951 [ALC269_FUJITSU] = "fujitsu", 14952 [ALC269_LIFEBOOK] = "lifebook", 14953 [ALC269_AUTO] = "auto", 14954}; 14955 14956static struct snd_pci_quirk alc269_cfg_tbl[] = { 14957 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1), 14958 SND_PCI_QUIRK(0x1025, 0x047c, "ACER ZGA", ALC271_ACER), 14959 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A", 14960 ALC269_AMIC), 14961 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269VB_AMIC), 14962 SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269VB_AMIC), 14963 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269VB_AMIC), 14964 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_AMIC), 14965 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269VB_AMIC), 14966 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269VB_AMIC), 14967 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269VB_AMIC), 14968 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269VB_AMIC), 14969 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_AMIC), 14970 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269VB_AMIC), 14971 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_AMIC), 14972 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_AMIC), 14973 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_AMIC), 14974 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_AMIC), 14975 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_AMIC), 14976 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_AMIC), 14977 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_AMIC), 14978 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_AMIC), 14979 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_AMIC), 14980 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_AMIC), 14981 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_AMIC), 14982 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_AMIC), 14983 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_AMIC), 14984 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_AMIC), 14985 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_AMIC), 14986 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_AMIC), 14987 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_AMIC), 14988 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_AMIC), 14989 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_AMIC), 14990 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_AMIC), 14991 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_AMIC), 14992 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_DMIC), 14993 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_AMIC), 14994 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_AMIC), 14995 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_AMIC), 14996 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_AMIC), 14997 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901", 14998 ALC269_DMIC), 14999 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101", 15000 ALC269_DMIC), 15001 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_DMIC), 15002 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_DMIC), 15003 SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_AUTO), 15004 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK), 15005 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_DMIC), 15006 SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU), 15007 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_AMIC), 15008 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_AMIC), 15009 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_DMIC), 15010 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_DMIC), 15011 {} 15012}; 15013 15014static struct alc_config_preset alc269_presets[] = { 15015 [ALC269_BASIC] = { 15016 .mixers = { alc269_base_mixer }, 15017 .init_verbs = { alc269_init_verbs }, 15018 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 15019 .dac_nids = alc269_dac_nids, 15020 .hp_nid = 0x03, 15021 .num_channel_mode = ARRAY_SIZE(alc269_modes), 15022 .channel_mode = alc269_modes, 15023 .input_mux = &alc269_capture_source, 15024 }, 15025 [ALC269_QUANTA_FL1] = { 15026 .mixers = { alc269_quanta_fl1_mixer }, 15027 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs }, 15028 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 15029 .dac_nids = alc269_dac_nids, 15030 .hp_nid = 0x03, 15031 .num_channel_mode = ARRAY_SIZE(alc269_modes), 15032 .channel_mode = alc269_modes, 15033 .input_mux = &alc269_capture_source, 15034 .unsol_event = alc269_quanta_fl1_unsol_event, 15035 .setup = alc269_quanta_fl1_setup, 15036 .init_hook = alc269_quanta_fl1_init_hook, 15037 }, 15038 [ALC269_AMIC] = { 15039 .mixers = { alc269_laptop_mixer }, 15040 .cap_mixer = alc269_laptop_analog_capture_mixer, 15041 .init_verbs = { alc269_init_verbs, 15042 alc269_laptop_amic_init_verbs }, 15043 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 15044 .dac_nids = alc269_dac_nids, 15045 .hp_nid = 0x03, 15046 .num_channel_mode = ARRAY_SIZE(alc269_modes), 15047 .channel_mode = alc269_modes, 15048 .unsol_event = alc269_laptop_unsol_event, 15049 .setup = alc269_laptop_amic_setup, 15050 .init_hook = alc269_laptop_inithook, 15051 }, 15052 [ALC269_DMIC] = { 15053 .mixers = { alc269_laptop_mixer }, 15054 .cap_mixer = alc269_laptop_digital_capture_mixer, 15055 .init_verbs = { alc269_init_verbs, 15056 alc269_laptop_dmic_init_verbs }, 15057 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 15058 .dac_nids = alc269_dac_nids, 15059 .hp_nid = 0x03, 15060 .num_channel_mode = ARRAY_SIZE(alc269_modes), 15061 .channel_mode = alc269_modes, 15062 .unsol_event = alc269_laptop_unsol_event, 15063 .setup = alc269_laptop_dmic_setup, 15064 .init_hook = alc269_laptop_inithook, 15065 }, 15066 [ALC269VB_AMIC] = { 15067 .mixers = { alc269vb_laptop_mixer }, 15068 .cap_mixer = alc269vb_laptop_analog_capture_mixer, 15069 .init_verbs = { alc269vb_init_verbs, 15070 alc269vb_laptop_amic_init_verbs }, 15071 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 15072 .dac_nids = alc269_dac_nids, 15073 .hp_nid = 0x03, 15074 .num_channel_mode = ARRAY_SIZE(alc269_modes), 15075 .channel_mode = alc269_modes, 15076 .unsol_event = alc269_laptop_unsol_event, 15077 .setup = alc269vb_laptop_amic_setup, 15078 .init_hook = alc269_laptop_inithook, 15079 }, 15080 [ALC269VB_DMIC] = { 15081 .mixers = { alc269vb_laptop_mixer }, 15082 .cap_mixer = alc269vb_laptop_digital_capture_mixer, 15083 .init_verbs = { alc269vb_init_verbs, 15084 alc269vb_laptop_dmic_init_verbs }, 15085 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 15086 .dac_nids = alc269_dac_nids, 15087 .hp_nid = 0x03, 15088 .num_channel_mode = ARRAY_SIZE(alc269_modes), 15089 .channel_mode = alc269_modes, 15090 .unsol_event = alc269_laptop_unsol_event, 15091 .setup = alc269vb_laptop_dmic_setup, 15092 .init_hook = alc269_laptop_inithook, 15093 }, 15094 [ALC269_FUJITSU] = { 15095 .mixers = { alc269_fujitsu_mixer }, 15096 .cap_mixer = alc269_laptop_digital_capture_mixer, 15097 .init_verbs = { alc269_init_verbs, 15098 alc269_laptop_dmic_init_verbs }, 15099 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 15100 .dac_nids = alc269_dac_nids, 15101 .hp_nid = 0x03, 15102 .num_channel_mode = ARRAY_SIZE(alc269_modes), 15103 .channel_mode = alc269_modes, 15104 .unsol_event = alc269_laptop_unsol_event, 15105 .setup = alc269_laptop_dmic_setup, 15106 .init_hook = alc269_laptop_inithook, 15107 }, 15108 [ALC269_LIFEBOOK] = { 15109 .mixers = { alc269_lifebook_mixer }, 15110 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs }, 15111 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 15112 .dac_nids = alc269_dac_nids, 15113 .hp_nid = 0x03, 15114 .num_channel_mode = ARRAY_SIZE(alc269_modes), 15115 .channel_mode = alc269_modes, 15116 .input_mux = &alc269_capture_source, 15117 .unsol_event = alc269_lifebook_unsol_event, 15118 .init_hook = alc269_lifebook_init_hook, 15119 }, 15120 [ALC271_ACER] = { 15121 .mixers = { alc269_asus_mixer }, 15122 .cap_mixer = alc269vb_laptop_digital_capture_mixer, 15123 .init_verbs = { alc269_init_verbs, alc271_acer_dmic_verbs }, 15124 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 15125 .dac_nids = alc269_dac_nids, 15126 .adc_nids = alc262_dmic_adc_nids, 15127 .num_adc_nids = ARRAY_SIZE(alc262_dmic_adc_nids), 15128 .capsrc_nids = alc262_dmic_capsrc_nids, 15129 .num_channel_mode = ARRAY_SIZE(alc269_modes), 15130 .channel_mode = alc269_modes, 15131 .input_mux = &alc269_capture_source, 15132 .dig_out_nid = ALC880_DIGOUT_NID, 15133 .unsol_event = alc_sku_unsol_event, 15134 .setup = alc269vb_laptop_dmic_setup, 15135 .init_hook = alc_inithook, 15136 }, 15137}; 15138 15139static int alc269_fill_coef(struct hda_codec *codec) 15140{ 15141 int val; 15142 15143 if ((alc_read_coef_idx(codec, 0) & 0x00ff) < 0x015) { 15144 alc_write_coef_idx(codec, 0xf, 0x960b); 15145 alc_write_coef_idx(codec, 0xe, 0x8817); 15146 } 15147 15148 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x016) { 15149 alc_write_coef_idx(codec, 0xf, 0x960b); 15150 alc_write_coef_idx(codec, 0xe, 0x8814); 15151 } 15152 15153 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) { 15154 val = alc_read_coef_idx(codec, 0x04); 15155 /* Power up output pin */ 15156 alc_write_coef_idx(codec, 0x04, val | (1<<11)); 15157 } 15158 15159 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) { 15160 val = alc_read_coef_idx(codec, 0xd); 15161 if ((val & 0x0c00) >> 10 != 0x1) { 15162 /* Capless ramp up clock control */ 15163 alc_write_coef_idx(codec, 0xd, val | 1<<10); 15164 } 15165 val = alc_read_coef_idx(codec, 0x17); 15166 if ((val & 0x01c0) >> 6 != 0x4) { 15167 /* Class D power on reset */ 15168 alc_write_coef_idx(codec, 0x17, val | 1<<7); 15169 } 15170 } 15171 return 0; 15172} 15173 15174static int patch_alc269(struct hda_codec *codec) 15175{ 15176 struct alc_spec *spec; 15177 int board_config, coef; 15178 int err; 15179 15180 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 15181 if (spec == NULL) 15182 return -ENOMEM; 15183 15184 codec->spec = spec; 15185 15186 alc_auto_parse_customize_define(codec); 15187 15188 if (codec->vendor_id == 0x10ec0269) { 15189 coef = alc_read_coef_idx(codec, 0); 15190 if ((coef & 0x00f0) == 0x0010) { 15191 if (codec->bus->pci->subsystem_vendor == 0x1025 && 15192 spec->cdefine.platform_type == 1) { 15193 alc_codec_rename(codec, "ALC271X"); 15194 spec->codec_variant = ALC269_TYPE_ALC271X; 15195 } else if ((coef & 0xf000) == 0x1000) { 15196 spec->codec_variant = ALC269_TYPE_ALC270; 15197 } else if ((coef & 0xf000) == 0x2000) { 15198 alc_codec_rename(codec, "ALC259"); 15199 spec->codec_variant = ALC269_TYPE_ALC259; 15200 } else if ((coef & 0xf000) == 0x3000) { 15201 alc_codec_rename(codec, "ALC258"); 15202 spec->codec_variant = ALC269_TYPE_ALC258; 15203 } else { 15204 alc_codec_rename(codec, "ALC269VB"); 15205 spec->codec_variant = ALC269_TYPE_ALC269VB; 15206 } 15207 } else 15208 alc_fix_pll_init(codec, 0x20, 0x04, 15); 15209 alc269_fill_coef(codec); 15210 } 15211 15212 board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST, 15213 alc269_models, 15214 alc269_cfg_tbl); 15215 15216 if (board_config < 0) { 15217 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 15218 codec->chip_name); 15219 board_config = ALC269_AUTO; 15220 } 15221 15222 if (board_config == ALC269_AUTO) { 15223 alc_pick_fixup(codec, NULL, alc269_fixup_tbl, alc269_fixups); 15224 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE); 15225 } 15226 15227 if (board_config == ALC269_AUTO) { 15228 /* automatic parse from the BIOS config */ 15229 err = alc269_parse_auto_config(codec); 15230 if (err < 0) { 15231 alc_free(codec); 15232 return err; 15233 } else if (!err) { 15234 printk(KERN_INFO 15235 "hda_codec: Cannot set up configuration " 15236 "from BIOS. Using base mode...\n"); 15237 board_config = ALC269_BASIC; 15238 } 15239 } 15240 15241 if (has_cdefine_beep(codec)) { 15242 err = snd_hda_attach_beep_device(codec, 0x1); 15243 if (err < 0) { 15244 alc_free(codec); 15245 return err; 15246 } 15247 } 15248 15249 if (board_config != ALC269_AUTO) 15250 setup_preset(codec, &alc269_presets[board_config]); 15251 15252 if (board_config == ALC269_QUANTA_FL1) { 15253 /* Due to a hardware problem on Lenovo Ideadpad, we need to 15254 * fix the sample rate of analog I/O to 44.1kHz 15255 */ 15256 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback; 15257 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture; 15258 } else if (spec->dual_adc_switch) { 15259 spec->stream_analog_playback = &alc269_pcm_analog_playback; 15260 /* switch ADC dynamically */ 15261 spec->stream_analog_capture = &dualmic_pcm_analog_capture; 15262 } else { 15263 spec->stream_analog_playback = &alc269_pcm_analog_playback; 15264 spec->stream_analog_capture = &alc269_pcm_analog_capture; 15265 } 15266 spec->stream_digital_playback = &alc269_pcm_digital_playback; 15267 spec->stream_digital_capture = &alc269_pcm_digital_capture; 15268 15269 if (!spec->adc_nids) { /* wasn't filled automatically? use default */ 15270 if (spec->codec_variant == ALC269_TYPE_NORMAL) { 15271 spec->adc_nids = alc269_adc_nids; 15272 spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids); 15273 spec->capsrc_nids = alc269_capsrc_nids; 15274 } else { 15275 spec->adc_nids = alc269vb_adc_nids; 15276 spec->num_adc_nids = ARRAY_SIZE(alc269vb_adc_nids); 15277 spec->capsrc_nids = alc269vb_capsrc_nids; 15278 } 15279 } 15280 15281 if (!spec->cap_mixer) 15282 set_capture_mixer(codec); 15283 if (has_cdefine_beep(codec)) 15284 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT); 15285 15286 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE); 15287 15288 spec->vmaster_nid = 0x02; 15289 15290 codec->patch_ops = alc_patch_ops; 15291#ifdef CONFIG_SND_HDA_POWER_SAVE 15292 codec->patch_ops.suspend = alc269_suspend; 15293#endif 15294#ifdef SND_HDA_NEEDS_RESUME 15295 codec->patch_ops.resume = alc269_resume; 15296#endif 15297 if (board_config == ALC269_AUTO) 15298 spec->init_hook = alc269_auto_init; 15299 15300 alc_init_jacks(codec); 15301#ifdef CONFIG_SND_HDA_POWER_SAVE 15302 if (!spec->loopback.amplist) 15303 spec->loopback.amplist = alc269_loopbacks; 15304 if (alc269_mic2_for_mute_led(codec)) 15305 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps; 15306#endif 15307 15308 return 0; 15309} 15310 15311/* 15312 * ALC861 channel source setting (2/6 channel selection for 3-stack) 15313 */ 15314 15315/* 15316 * set the path ways for 2 channel output 15317 * need to set the codec line out and mic 1 pin widgets to inputs 15318 */ 15319static struct hda_verb alc861_threestack_ch2_init[] = { 15320 /* set pin widget 1Ah (line in) for input */ 15321 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 15322 /* set pin widget 18h (mic1/2) for input, for mic also enable 15323 * the vref 15324 */ 15325 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 15326 15327 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c }, 15328#if 0 15329 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/ 15330 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/ 15331#endif 15332 { } /* end */ 15333}; 15334/* 15335 * 6ch mode 15336 * need to set the codec line out and mic 1 pin widgets to outputs 15337 */ 15338static struct hda_verb alc861_threestack_ch6_init[] = { 15339 /* set pin widget 1Ah (line in) for output (Back Surround)*/ 15340 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 15341 /* set pin widget 18h (mic1) for output (CLFE)*/ 15342 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 15343 15344 { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 }, 15345 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 }, 15346 15347 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 }, 15348#if 0 15349 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/ 15350 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/ 15351#endif 15352 { } /* end */ 15353}; 15354 15355static struct hda_channel_mode alc861_threestack_modes[2] = { 15356 { 2, alc861_threestack_ch2_init }, 15357 { 6, alc861_threestack_ch6_init }, 15358}; 15359/* Set mic1 as input and unmute the mixer */ 15360static struct hda_verb alc861_uniwill_m31_ch2_init[] = { 15361 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 15362 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/ 15363 { } /* end */ 15364}; 15365/* Set mic1 as output and mute mixer */ 15366static struct hda_verb alc861_uniwill_m31_ch4_init[] = { 15367 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 15368 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/ 15369 { } /* end */ 15370}; 15371 15372static struct hda_channel_mode alc861_uniwill_m31_modes[2] = { 15373 { 2, alc861_uniwill_m31_ch2_init }, 15374 { 4, alc861_uniwill_m31_ch4_init }, 15375}; 15376 15377/* Set mic1 and line-in as input and unmute the mixer */ 15378static struct hda_verb alc861_asus_ch2_init[] = { 15379 /* set pin widget 1Ah (line in) for input */ 15380 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 15381 /* set pin widget 18h (mic1/2) for input, for mic also enable 15382 * the vref 15383 */ 15384 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 15385 15386 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c }, 15387#if 0 15388 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/ 15389 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/ 15390#endif 15391 { } /* end */ 15392}; 15393/* Set mic1 nad line-in as output and mute mixer */ 15394static struct hda_verb alc861_asus_ch6_init[] = { 15395 /* set pin widget 1Ah (line in) for output (Back Surround)*/ 15396 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 15397 /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */ 15398 /* set pin widget 18h (mic1) for output (CLFE)*/ 15399 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 15400 /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */ 15401 { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 }, 15402 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 }, 15403 15404 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 }, 15405#if 0 15406 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/ 15407 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/ 15408#endif 15409 { } /* end */ 15410}; 15411 15412static struct hda_channel_mode alc861_asus_modes[2] = { 15413 { 2, alc861_asus_ch2_init }, 15414 { 6, alc861_asus_ch6_init }, 15415}; 15416 15417/* patch-ALC861 */ 15418 15419static struct snd_kcontrol_new alc861_base_mixer[] = { 15420 /* output mixer control */ 15421 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT), 15422 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT), 15423 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT), 15424 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT), 15425 HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), 15426 15427 /*Input mixer control */ 15428 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT), 15429 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */ 15430 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 15431 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 15432 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT), 15433 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT), 15434 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 15435 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 15436 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT), 15437 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT), 15438 15439 { } /* end */ 15440}; 15441 15442static struct snd_kcontrol_new alc861_3ST_mixer[] = { 15443 /* output mixer control */ 15444 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT), 15445 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT), 15446 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT), 15447 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT), 15448 /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */ 15449 15450 /* Input mixer control */ 15451 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT), 15452 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */ 15453 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 15454 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 15455 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT), 15456 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT), 15457 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 15458 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 15459 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT), 15460 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT), 15461 15462 { 15463 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 15464 .name = "Channel Mode", 15465 .info = alc_ch_mode_info, 15466 .get = alc_ch_mode_get, 15467 .put = alc_ch_mode_put, 15468 .private_value = ARRAY_SIZE(alc861_threestack_modes), 15469 }, 15470 { } /* end */ 15471}; 15472 15473static struct snd_kcontrol_new alc861_toshiba_mixer[] = { 15474 /* output mixer control */ 15475 HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT), 15476 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 15477 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 15478 15479 { } /* end */ 15480}; 15481 15482static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = { 15483 /* output mixer control */ 15484 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT), 15485 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT), 15486 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT), 15487 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT), 15488 /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */ 15489 15490 /* Input mixer control */ 15491 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT), 15492 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */ 15493 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 15494 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 15495 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT), 15496 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT), 15497 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 15498 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 15499 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT), 15500 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT), 15501 15502 { 15503 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 15504 .name = "Channel Mode", 15505 .info = alc_ch_mode_info, 15506 .get = alc_ch_mode_get, 15507 .put = alc_ch_mode_put, 15508 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes), 15509 }, 15510 { } /* end */ 15511}; 15512 15513static struct snd_kcontrol_new alc861_asus_mixer[] = { 15514 /* output mixer control */ 15515 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT), 15516 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT), 15517 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT), 15518 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT), 15519 HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), 15520 15521 /* Input mixer control */ 15522 HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT), 15523 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), 15524 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 15525 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 15526 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT), 15527 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT), 15528 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 15529 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 15530 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT), 15531 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT), 15532 15533 { 15534 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 15535 .name = "Channel Mode", 15536 .info = alc_ch_mode_info, 15537 .get = alc_ch_mode_get, 15538 .put = alc_ch_mode_put, 15539 .private_value = ARRAY_SIZE(alc861_asus_modes), 15540 }, 15541 { } 15542}; 15543 15544/* additional mixer */ 15545static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = { 15546 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 15547 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 15548 { } 15549}; 15550 15551/* 15552 * generic initialization of ADC, input mixers and output mixers 15553 */ 15554static struct hda_verb alc861_base_init_verbs[] = { 15555 /* 15556 * Unmute ADC0 and set the default input to mic-in 15557 */ 15558 /* port-A for surround (rear panel) */ 15559 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 15560 { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 }, 15561 /* port-B for mic-in (rear panel) with vref */ 15562 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 15563 /* port-C for line-in (rear panel) */ 15564 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 15565 /* port-D for Front */ 15566 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 15567 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 }, 15568 /* port-E for HP out (front panel) */ 15569 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 15570 /* route front PCM to HP */ 15571 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 15572 /* port-F for mic-in (front panel) with vref */ 15573 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 15574 /* port-G for CLFE (rear panel) */ 15575 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 15576 { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 15577 /* port-H for side (rear panel) */ 15578 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 15579 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 }, 15580 /* CD-in */ 15581 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 15582 /* route front mic to ADC1*/ 15583 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 15584 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15585 15586 /* Unmute DAC0~3 & spdif out*/ 15587 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15588 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15589 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15590 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15591 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15592 15593 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 15594 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15595 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15596 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15597 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15598 15599 /* Unmute Stereo Mixer 15 */ 15600 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15601 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15602 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 15603 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */ 15604 15605 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15606 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15607 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15608 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15609 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15610 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15611 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15612 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15613 /* hp used DAC 3 (Front) */ 15614 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 15615 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 15616 15617 { } 15618}; 15619 15620static struct hda_verb alc861_threestack_init_verbs[] = { 15621 /* 15622 * Unmute ADC0 and set the default input to mic-in 15623 */ 15624 /* port-A for surround (rear panel) */ 15625 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 15626 /* port-B for mic-in (rear panel) with vref */ 15627 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 15628 /* port-C for line-in (rear panel) */ 15629 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 15630 /* port-D for Front */ 15631 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 15632 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 }, 15633 /* port-E for HP out (front panel) */ 15634 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 15635 /* route front PCM to HP */ 15636 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 15637 /* port-F for mic-in (front panel) with vref */ 15638 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 15639 /* port-G for CLFE (rear panel) */ 15640 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 15641 /* port-H for side (rear panel) */ 15642 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 15643 /* CD-in */ 15644 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 15645 /* route front mic to ADC1*/ 15646 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 15647 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15648 /* Unmute DAC0~3 & spdif out*/ 15649 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15650 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15651 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15652 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15653 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15654 15655 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 15656 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15657 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15658 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15659 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15660 15661 /* Unmute Stereo Mixer 15 */ 15662 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15663 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15664 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 15665 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */ 15666 15667 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15668 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15669 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15670 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15671 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15672 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15673 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15674 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15675 /* hp used DAC 3 (Front) */ 15676 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 15677 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 15678 { } 15679}; 15680 15681static struct hda_verb alc861_uniwill_m31_init_verbs[] = { 15682 /* 15683 * Unmute ADC0 and set the default input to mic-in 15684 */ 15685 /* port-A for surround (rear panel) */ 15686 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 15687 /* port-B for mic-in (rear panel) with vref */ 15688 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 15689 /* port-C for line-in (rear panel) */ 15690 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 15691 /* port-D for Front */ 15692 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 15693 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 }, 15694 /* port-E for HP out (front panel) */ 15695 /* this has to be set to VREF80 */ 15696 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 15697 /* route front PCM to HP */ 15698 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 15699 /* port-F for mic-in (front panel) with vref */ 15700 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 15701 /* port-G for CLFE (rear panel) */ 15702 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 15703 /* port-H for side (rear panel) */ 15704 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 15705 /* CD-in */ 15706 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 15707 /* route front mic to ADC1*/ 15708 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 15709 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15710 /* Unmute DAC0~3 & spdif out*/ 15711 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15712 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15713 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15714 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15715 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15716 15717 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 15718 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15719 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15720 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15721 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15722 15723 /* Unmute Stereo Mixer 15 */ 15724 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15725 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15726 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 15727 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */ 15728 15729 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15730 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15731 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15732 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15733 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15734 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15735 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15736 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15737 /* hp used DAC 3 (Front) */ 15738 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 15739 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 15740 { } 15741}; 15742 15743static struct hda_verb alc861_asus_init_verbs[] = { 15744 /* 15745 * Unmute ADC0 and set the default input to mic-in 15746 */ 15747 /* port-A for surround (rear panel) 15748 * according to codec#0 this is the HP jack 15749 */ 15750 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */ 15751 /* route front PCM to HP */ 15752 { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 }, 15753 /* port-B for mic-in (rear panel) with vref */ 15754 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 15755 /* port-C for line-in (rear panel) */ 15756 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 15757 /* port-D for Front */ 15758 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 15759 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 }, 15760 /* port-E for HP out (front panel) */ 15761 /* this has to be set to VREF80 */ 15762 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 15763 /* route front PCM to HP */ 15764 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 15765 /* port-F for mic-in (front panel) with vref */ 15766 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 15767 /* port-G for CLFE (rear panel) */ 15768 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 15769 /* port-H for side (rear panel) */ 15770 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 15771 /* CD-in */ 15772 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 15773 /* route front mic to ADC1*/ 15774 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 15775 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15776 /* Unmute DAC0~3 & spdif out*/ 15777 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15778 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15779 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15780 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15781 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15782 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 15783 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15784 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15785 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15786 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15787 15788 /* Unmute Stereo Mixer 15 */ 15789 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15790 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15791 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 15792 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */ 15793 15794 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15795 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15796 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15797 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15798 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15799 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15800 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15801 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15802 /* hp used DAC 3 (Front) */ 15803 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 15804 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 15805 { } 15806}; 15807 15808/* additional init verbs for ASUS laptops */ 15809static struct hda_verb alc861_asus_laptop_init_verbs[] = { 15810 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */ 15811 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */ 15812 { } 15813}; 15814 15815/* 15816 * generic initialization of ADC, input mixers and output mixers 15817 */ 15818static struct hda_verb alc861_auto_init_verbs[] = { 15819 /* 15820 * Unmute ADC0 and set the default input to mic-in 15821 */ 15822 /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */ 15823 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15824 15825 /* Unmute DAC0~3 & spdif out*/ 15826 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 15827 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 15828 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 15829 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 15830 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15831 15832 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 15833 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15834 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15835 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15836 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15837 15838 /* Unmute Stereo Mixer 15 */ 15839 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15840 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15841 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 15842 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, 15843 15844 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15845 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 15846 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15847 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 15848 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15849 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 15850 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15851 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 15852 15853 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15854 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 15855 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 15856 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 15857 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15858 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 15859 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 15860 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 15861 15862 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, /* set Mic 1 */ 15863 15864 { } 15865}; 15866 15867static struct hda_verb alc861_toshiba_init_verbs[] = { 15868 {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15869 15870 { } 15871}; 15872 15873/* toggle speaker-output according to the hp-jack state */ 15874static void alc861_toshiba_automute(struct hda_codec *codec) 15875{ 15876 unsigned int present = snd_hda_jack_detect(codec, 0x0f); 15877 15878 snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0, 15879 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 15880 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3, 15881 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE); 15882} 15883 15884static void alc861_toshiba_unsol_event(struct hda_codec *codec, 15885 unsigned int res) 15886{ 15887 if ((res >> 26) == ALC880_HP_EVENT) 15888 alc861_toshiba_automute(codec); 15889} 15890 15891/* pcm configuration: identical with ALC880 */ 15892#define alc861_pcm_analog_playback alc880_pcm_analog_playback 15893#define alc861_pcm_analog_capture alc880_pcm_analog_capture 15894#define alc861_pcm_digital_playback alc880_pcm_digital_playback 15895#define alc861_pcm_digital_capture alc880_pcm_digital_capture 15896 15897 15898#define ALC861_DIGOUT_NID 0x07 15899 15900static struct hda_channel_mode alc861_8ch_modes[1] = { 15901 { 8, NULL } 15902}; 15903 15904static hda_nid_t alc861_dac_nids[4] = { 15905 /* front, surround, clfe, side */ 15906 0x03, 0x06, 0x05, 0x04 15907}; 15908 15909static hda_nid_t alc660_dac_nids[3] = { 15910 /* front, clfe, surround */ 15911 0x03, 0x05, 0x06 15912}; 15913 15914static hda_nid_t alc861_adc_nids[1] = { 15915 /* ADC0-2 */ 15916 0x08, 15917}; 15918 15919static struct hda_input_mux alc861_capture_source = { 15920 .num_items = 5, 15921 .items = { 15922 { "Mic", 0x0 }, 15923 { "Front Mic", 0x3 }, 15924 { "Line", 0x1 }, 15925 { "CD", 0x4 }, 15926 { "Mixer", 0x5 }, 15927 }, 15928}; 15929 15930static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin) 15931{ 15932 struct alc_spec *spec = codec->spec; 15933 hda_nid_t mix, srcs[5]; 15934 int i, j, num; 15935 15936 if (snd_hda_get_connections(codec, pin, &mix, 1) != 1) 15937 return 0; 15938 num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs)); 15939 if (num < 0) 15940 return 0; 15941 for (i = 0; i < num; i++) { 15942 unsigned int type; 15943 type = get_wcaps_type(get_wcaps(codec, srcs[i])); 15944 if (type != AC_WID_AUD_OUT) 15945 continue; 15946 for (j = 0; j < spec->multiout.num_dacs; j++) 15947 if (spec->multiout.dac_nids[j] == srcs[i]) 15948 break; 15949 if (j >= spec->multiout.num_dacs) 15950 return srcs[i]; 15951 } 15952 return 0; 15953} 15954 15955/* fill in the dac_nids table from the parsed pin configuration */ 15956static int alc861_auto_fill_dac_nids(struct hda_codec *codec, 15957 const struct auto_pin_cfg *cfg) 15958{ 15959 struct alc_spec *spec = codec->spec; 15960 int i; 15961 hda_nid_t nid, dac; 15962 15963 spec->multiout.dac_nids = spec->private_dac_nids; 15964 for (i = 0; i < cfg->line_outs; i++) { 15965 nid = cfg->line_out_pins[i]; 15966 dac = alc861_look_for_dac(codec, nid); 15967 if (!dac) 15968 continue; 15969 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac; 15970 } 15971 return 0; 15972} 15973 15974static int __alc861_create_out_sw(struct hda_codec *codec, const char *pfx, 15975 hda_nid_t nid, int idx, unsigned int chs) 15976{ 15977 return __add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx, idx, 15978 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT)); 15979} 15980 15981#define alc861_create_out_sw(codec, pfx, nid, chs) \ 15982 __alc861_create_out_sw(codec, pfx, nid, 0, chs) 15983 15984/* add playback controls from the parsed DAC table */ 15985static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec, 15986 const struct auto_pin_cfg *cfg) 15987{ 15988 struct alc_spec *spec = codec->spec; 15989 static const char * const chname[4] = { 15990 "Front", "Surround", NULL /*CLFE*/, "Side" 15991 }; 15992 const char *pfx = alc_get_line_out_pfx(cfg, true); 15993 hda_nid_t nid; 15994 int i, err; 15995 15996 for (i = 0; i < cfg->line_outs; i++) { 15997 nid = spec->multiout.dac_nids[i]; 15998 if (!nid) 15999 continue; 16000 if (!pfx && i == 2) { 16001 /* Center/LFE */ 16002 err = alc861_create_out_sw(codec, "Center", nid, 1); 16003 if (err < 0) 16004 return err; 16005 err = alc861_create_out_sw(codec, "LFE", nid, 2); 16006 if (err < 0) 16007 return err; 16008 } else { 16009 const char *name = pfx; 16010 if (!name) 16011 name = chname[i]; 16012 err = __alc861_create_out_sw(codec, name, nid, i, 3); 16013 if (err < 0) 16014 return err; 16015 } 16016 } 16017 return 0; 16018} 16019 16020static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin) 16021{ 16022 struct alc_spec *spec = codec->spec; 16023 int err; 16024 hda_nid_t nid; 16025 16026 if (!pin) 16027 return 0; 16028 16029 if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) { 16030 nid = alc861_look_for_dac(codec, pin); 16031 if (nid) { 16032 err = alc861_create_out_sw(codec, "Headphone", nid, 3); 16033 if (err < 0) 16034 return err; 16035 spec->multiout.hp_nid = nid; 16036 } 16037 } 16038 return 0; 16039} 16040 16041/* create playback/capture controls for input pins */ 16042static int alc861_auto_create_input_ctls(struct hda_codec *codec, 16043 const struct auto_pin_cfg *cfg) 16044{ 16045 return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0); 16046} 16047 16048static void alc861_auto_set_output_and_unmute(struct hda_codec *codec, 16049 hda_nid_t nid, 16050 int pin_type, hda_nid_t dac) 16051{ 16052 hda_nid_t mix, srcs[5]; 16053 int i, num; 16054 16055 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 16056 pin_type); 16057 snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE, 16058 AMP_OUT_UNMUTE); 16059 if (snd_hda_get_connections(codec, nid, &mix, 1) != 1) 16060 return; 16061 num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs)); 16062 if (num < 0) 16063 return; 16064 for (i = 0; i < num; i++) { 16065 unsigned int mute; 16066 if (srcs[i] == dac || srcs[i] == 0x15) 16067 mute = AMP_IN_UNMUTE(i); 16068 else 16069 mute = AMP_IN_MUTE(i); 16070 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE, 16071 mute); 16072 } 16073} 16074 16075static void alc861_auto_init_multi_out(struct hda_codec *codec) 16076{ 16077 struct alc_spec *spec = codec->spec; 16078 int i; 16079 16080 for (i = 0; i < spec->autocfg.line_outs; i++) { 16081 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 16082 int pin_type = get_pin_type(spec->autocfg.line_out_type); 16083 if (nid) 16084 alc861_auto_set_output_and_unmute(codec, nid, pin_type, 16085 spec->multiout.dac_nids[i]); 16086 } 16087} 16088 16089static void alc861_auto_init_hp_out(struct hda_codec *codec) 16090{ 16091 struct alc_spec *spec = codec->spec; 16092 16093 if (spec->autocfg.hp_outs) 16094 alc861_auto_set_output_and_unmute(codec, 16095 spec->autocfg.hp_pins[0], 16096 PIN_HP, 16097 spec->multiout.hp_nid); 16098 if (spec->autocfg.speaker_outs) 16099 alc861_auto_set_output_and_unmute(codec, 16100 spec->autocfg.speaker_pins[0], 16101 PIN_OUT, 16102 spec->multiout.dac_nids[0]); 16103} 16104 16105static void alc861_auto_init_analog_input(struct hda_codec *codec) 16106{ 16107 struct alc_spec *spec = codec->spec; 16108 struct auto_pin_cfg *cfg = &spec->autocfg; 16109 int i; 16110 16111 for (i = 0; i < cfg->num_inputs; i++) { 16112 hda_nid_t nid = cfg->inputs[i].pin; 16113 if (nid >= 0x0c && nid <= 0x11) 16114 alc_set_input_pin(codec, nid, cfg->inputs[i].type); 16115 } 16116} 16117 16118/* parse the BIOS configuration and set up the alc_spec */ 16119/* return 1 if successful, 0 if the proper config is not found, 16120 * or a negative error code 16121 */ 16122static int alc861_parse_auto_config(struct hda_codec *codec) 16123{ 16124 struct alc_spec *spec = codec->spec; 16125 int err; 16126 static hda_nid_t alc861_ignore[] = { 0x1d, 0 }; 16127 16128 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 16129 alc861_ignore); 16130 if (err < 0) 16131 return err; 16132 if (!spec->autocfg.line_outs) 16133 return 0; /* can't find valid BIOS pin config */ 16134 16135 err = alc861_auto_fill_dac_nids(codec, &spec->autocfg); 16136 if (err < 0) 16137 return err; 16138 err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg); 16139 if (err < 0) 16140 return err; 16141 err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]); 16142 if (err < 0) 16143 return err; 16144 err = alc861_auto_create_input_ctls(codec, &spec->autocfg); 16145 if (err < 0) 16146 return err; 16147 16148 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 16149 16150 alc_auto_parse_digital(codec); 16151 16152 if (spec->kctls.list) 16153 add_mixer(spec, spec->kctls.list); 16154 16155 add_verb(spec, alc861_auto_init_verbs); 16156 16157 spec->num_mux_defs = 1; 16158 spec->input_mux = &spec->private_imux[0]; 16159 16160 spec->adc_nids = alc861_adc_nids; 16161 spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids); 16162 set_capture_mixer(codec); 16163 16164 alc_ssid_check(codec, 0x0e, 0x0f, 0x0b, 0); 16165 16166 return 1; 16167} 16168 16169/* additional initialization for auto-configuration model */ 16170static void alc861_auto_init(struct hda_codec *codec) 16171{ 16172 struct alc_spec *spec = codec->spec; 16173 alc861_auto_init_multi_out(codec); 16174 alc861_auto_init_hp_out(codec); 16175 alc861_auto_init_analog_input(codec); 16176 alc_auto_init_digital(codec); 16177 if (spec->unsol_event) 16178 alc_inithook(codec); 16179} 16180 16181#ifdef CONFIG_SND_HDA_POWER_SAVE 16182static struct hda_amp_list alc861_loopbacks[] = { 16183 { 0x15, HDA_INPUT, 0 }, 16184 { 0x15, HDA_INPUT, 1 }, 16185 { 0x15, HDA_INPUT, 2 }, 16186 { 0x15, HDA_INPUT, 3 }, 16187 { } /* end */ 16188}; 16189#endif 16190 16191 16192/* 16193 * configuration and preset 16194 */ 16195static const char * const alc861_models[ALC861_MODEL_LAST] = { 16196 [ALC861_3ST] = "3stack", 16197 [ALC660_3ST] = "3stack-660", 16198 [ALC861_3ST_DIG] = "3stack-dig", 16199 [ALC861_6ST_DIG] = "6stack-dig", 16200 [ALC861_UNIWILL_M31] = "uniwill-m31", 16201 [ALC861_TOSHIBA] = "toshiba", 16202 [ALC861_ASUS] = "asus", 16203 [ALC861_ASUS_LAPTOP] = "asus-laptop", 16204 [ALC861_AUTO] = "auto", 16205}; 16206 16207static struct snd_pci_quirk alc861_cfg_tbl[] = { 16208 SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST), 16209 SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP), 16210 SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP), 16211 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS), 16212 SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP), 16213 SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG), 16214 SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA), 16215 /* FIXME: the entry below breaks Toshiba A100 (model=auto works!) 16216 * Any other models that need this preset? 16217 */ 16218 /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */ 16219 SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST), 16220 SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST), 16221 SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31), 16222 SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31), 16223 SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP), 16224 /* FIXME: the below seems conflict */ 16225 /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */ 16226 SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST), 16227 SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST), 16228 {} 16229}; 16230 16231static struct alc_config_preset alc861_presets[] = { 16232 [ALC861_3ST] = { 16233 .mixers = { alc861_3ST_mixer }, 16234 .init_verbs = { alc861_threestack_init_verbs }, 16235 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 16236 .dac_nids = alc861_dac_nids, 16237 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes), 16238 .channel_mode = alc861_threestack_modes, 16239 .need_dac_fix = 1, 16240 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 16241 .adc_nids = alc861_adc_nids, 16242 .input_mux = &alc861_capture_source, 16243 }, 16244 [ALC861_3ST_DIG] = { 16245 .mixers = { alc861_base_mixer }, 16246 .init_verbs = { alc861_threestack_init_verbs }, 16247 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 16248 .dac_nids = alc861_dac_nids, 16249 .dig_out_nid = ALC861_DIGOUT_NID, 16250 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes), 16251 .channel_mode = alc861_threestack_modes, 16252 .need_dac_fix = 1, 16253 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 16254 .adc_nids = alc861_adc_nids, 16255 .input_mux = &alc861_capture_source, 16256 }, 16257 [ALC861_6ST_DIG] = { 16258 .mixers = { alc861_base_mixer }, 16259 .init_verbs = { alc861_base_init_verbs }, 16260 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 16261 .dac_nids = alc861_dac_nids, 16262 .dig_out_nid = ALC861_DIGOUT_NID, 16263 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes), 16264 .channel_mode = alc861_8ch_modes, 16265 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 16266 .adc_nids = alc861_adc_nids, 16267 .input_mux = &alc861_capture_source, 16268 }, 16269 [ALC660_3ST] = { 16270 .mixers = { alc861_3ST_mixer }, 16271 .init_verbs = { alc861_threestack_init_verbs }, 16272 .num_dacs = ARRAY_SIZE(alc660_dac_nids), 16273 .dac_nids = alc660_dac_nids, 16274 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes), 16275 .channel_mode = alc861_threestack_modes, 16276 .need_dac_fix = 1, 16277 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 16278 .adc_nids = alc861_adc_nids, 16279 .input_mux = &alc861_capture_source, 16280 }, 16281 [ALC861_UNIWILL_M31] = { 16282 .mixers = { alc861_uniwill_m31_mixer }, 16283 .init_verbs = { alc861_uniwill_m31_init_verbs }, 16284 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 16285 .dac_nids = alc861_dac_nids, 16286 .dig_out_nid = ALC861_DIGOUT_NID, 16287 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes), 16288 .channel_mode = alc861_uniwill_m31_modes, 16289 .need_dac_fix = 1, 16290 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 16291 .adc_nids = alc861_adc_nids, 16292 .input_mux = &alc861_capture_source, 16293 }, 16294 [ALC861_TOSHIBA] = { 16295 .mixers = { alc861_toshiba_mixer }, 16296 .init_verbs = { alc861_base_init_verbs, 16297 alc861_toshiba_init_verbs }, 16298 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 16299 .dac_nids = alc861_dac_nids, 16300 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 16301 .channel_mode = alc883_3ST_2ch_modes, 16302 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 16303 .adc_nids = alc861_adc_nids, 16304 .input_mux = &alc861_capture_source, 16305 .unsol_event = alc861_toshiba_unsol_event, 16306 .init_hook = alc861_toshiba_automute, 16307 }, 16308 [ALC861_ASUS] = { 16309 .mixers = { alc861_asus_mixer }, 16310 .init_verbs = { alc861_asus_init_verbs }, 16311 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 16312 .dac_nids = alc861_dac_nids, 16313 .dig_out_nid = ALC861_DIGOUT_NID, 16314 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes), 16315 .channel_mode = alc861_asus_modes, 16316 .need_dac_fix = 1, 16317 .hp_nid = 0x06, 16318 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 16319 .adc_nids = alc861_adc_nids, 16320 .input_mux = &alc861_capture_source, 16321 }, 16322 [ALC861_ASUS_LAPTOP] = { 16323 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer }, 16324 .init_verbs = { alc861_asus_init_verbs, 16325 alc861_asus_laptop_init_verbs }, 16326 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 16327 .dac_nids = alc861_dac_nids, 16328 .dig_out_nid = ALC861_DIGOUT_NID, 16329 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 16330 .channel_mode = alc883_3ST_2ch_modes, 16331 .need_dac_fix = 1, 16332 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 16333 .adc_nids = alc861_adc_nids, 16334 .input_mux = &alc861_capture_source, 16335 }, 16336}; 16337 16338/* Pin config fixes */ 16339enum { 16340 PINFIX_FSC_AMILO_PI1505, 16341}; 16342 16343static const struct alc_fixup alc861_fixups[] = { 16344 [PINFIX_FSC_AMILO_PI1505] = { 16345 .type = ALC_FIXUP_PINS, 16346 .v.pins = (const struct alc_pincfg[]) { 16347 { 0x0b, 0x0221101f }, /* HP */ 16348 { 0x0f, 0x90170310 }, /* speaker */ 16349 { } 16350 } 16351 }, 16352}; 16353 16354static struct snd_pci_quirk alc861_fixup_tbl[] = { 16355 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505), 16356 {} 16357}; 16358 16359static int patch_alc861(struct hda_codec *codec) 16360{ 16361 struct alc_spec *spec; 16362 int board_config; 16363 int err; 16364 16365 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 16366 if (spec == NULL) 16367 return -ENOMEM; 16368 16369 codec->spec = spec; 16370 16371 board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST, 16372 alc861_models, 16373 alc861_cfg_tbl); 16374 16375 if (board_config < 0) { 16376 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 16377 codec->chip_name); 16378 board_config = ALC861_AUTO; 16379 } 16380 16381 if (board_config == ALC861_AUTO) { 16382 alc_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups); 16383 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE); 16384 } 16385 16386 if (board_config == ALC861_AUTO) { 16387 /* automatic parse from the BIOS config */ 16388 err = alc861_parse_auto_config(codec); 16389 if (err < 0) { 16390 alc_free(codec); 16391 return err; 16392 } else if (!err) { 16393 printk(KERN_INFO 16394 "hda_codec: Cannot set up configuration " 16395 "from BIOS. Using base mode...\n"); 16396 board_config = ALC861_3ST_DIG; 16397 } 16398 } 16399 16400 err = snd_hda_attach_beep_device(codec, 0x23); 16401 if (err < 0) { 16402 alc_free(codec); 16403 return err; 16404 } 16405 16406 if (board_config != ALC861_AUTO) 16407 setup_preset(codec, &alc861_presets[board_config]); 16408 16409 spec->stream_analog_playback = &alc861_pcm_analog_playback; 16410 spec->stream_analog_capture = &alc861_pcm_analog_capture; 16411 16412 spec->stream_digital_playback = &alc861_pcm_digital_playback; 16413 spec->stream_digital_capture = &alc861_pcm_digital_capture; 16414 16415 if (!spec->cap_mixer) 16416 set_capture_mixer(codec); 16417 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT); 16418 16419 spec->vmaster_nid = 0x03; 16420 16421 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE); 16422 16423 codec->patch_ops = alc_patch_ops; 16424 if (board_config == ALC861_AUTO) { 16425 spec->init_hook = alc861_auto_init; 16426#ifdef CONFIG_SND_HDA_POWER_SAVE 16427 spec->power_hook = alc_power_eapd; 16428#endif 16429 } 16430#ifdef CONFIG_SND_HDA_POWER_SAVE 16431 if (!spec->loopback.amplist) 16432 spec->loopback.amplist = alc861_loopbacks; 16433#endif 16434 16435 return 0; 16436} 16437 16438/* 16439 * ALC861-VD support 16440 * 16441 * Based on ALC882 16442 * 16443 * In addition, an independent DAC 16444 */ 16445#define ALC861VD_DIGOUT_NID 0x06 16446 16447static hda_nid_t alc861vd_dac_nids[4] = { 16448 /* front, surr, clfe, side surr */ 16449 0x02, 0x03, 0x04, 0x05 16450}; 16451 16452/* dac_nids for ALC660vd are in a different order - according to 16453 * Realtek's driver. 16454 * This should probably result in a different mixer for 6stack models 16455 * of ALC660vd codecs, but for now there is only 3stack mixer 16456 * - and it is the same as in 861vd. 16457 * adc_nids in ALC660vd are (is) the same as in 861vd 16458 */ 16459static hda_nid_t alc660vd_dac_nids[3] = { 16460 /* front, rear, clfe, rear_surr */ 16461 0x02, 0x04, 0x03 16462}; 16463 16464static hda_nid_t alc861vd_adc_nids[1] = { 16465 /* ADC0 */ 16466 0x09, 16467}; 16468 16469static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 }; 16470 16471/* input MUX */ 16472/* FIXME: should be a matrix-type input source selection */ 16473static struct hda_input_mux alc861vd_capture_source = { 16474 .num_items = 4, 16475 .items = { 16476 { "Mic", 0x0 }, 16477 { "Front Mic", 0x1 }, 16478 { "Line", 0x2 }, 16479 { "CD", 0x4 }, 16480 }, 16481}; 16482 16483static struct hda_input_mux alc861vd_dallas_capture_source = { 16484 .num_items = 2, 16485 .items = { 16486 { "Mic", 0x0 }, 16487 { "Internal Mic", 0x1 }, 16488 }, 16489}; 16490 16491static struct hda_input_mux alc861vd_hp_capture_source = { 16492 .num_items = 2, 16493 .items = { 16494 { "Front Mic", 0x0 }, 16495 { "ATAPI Mic", 0x1 }, 16496 }, 16497}; 16498 16499/* 16500 * 2ch mode 16501 */ 16502static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = { 16503 { 2, NULL } 16504}; 16505 16506/* 16507 * 6ch mode 16508 */ 16509static struct hda_verb alc861vd_6stack_ch6_init[] = { 16510 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 16511 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 16512 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 16513 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 16514 { } /* end */ 16515}; 16516 16517/* 16518 * 8ch mode 16519 */ 16520static struct hda_verb alc861vd_6stack_ch8_init[] = { 16521 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 16522 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 16523 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 16524 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 16525 { } /* end */ 16526}; 16527 16528static struct hda_channel_mode alc861vd_6stack_modes[2] = { 16529 { 6, alc861vd_6stack_ch6_init }, 16530 { 8, alc861vd_6stack_ch8_init }, 16531}; 16532 16533static struct snd_kcontrol_new alc861vd_chmode_mixer[] = { 16534 { 16535 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 16536 .name = "Channel Mode", 16537 .info = alc_ch_mode_info, 16538 .get = alc_ch_mode_get, 16539 .put = alc_ch_mode_put, 16540 }, 16541 { } /* end */ 16542}; 16543 16544/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17 16545 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b 16546 */ 16547static struct snd_kcontrol_new alc861vd_6st_mixer[] = { 16548 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 16549 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 16550 16551 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT), 16552 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 16553 16554 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, 16555 HDA_OUTPUT), 16556 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, 16557 HDA_OUTPUT), 16558 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 16559 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 16560 16561 HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT), 16562 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 16563 16564 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 16565 16566 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 16567 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 16568 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 16569 16570 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT), 16571 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 16572 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 16573 16574 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 16575 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 16576 16577 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 16578 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 16579 16580 { } /* end */ 16581}; 16582 16583static struct snd_kcontrol_new alc861vd_3st_mixer[] = { 16584 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 16585 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 16586 16587 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 16588 16589 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 16590 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 16591 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 16592 16593 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT), 16594 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 16595 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 16596 16597 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 16598 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 16599 16600 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 16601 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 16602 16603 { } /* end */ 16604}; 16605 16606static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = { 16607 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 16608 /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/ 16609 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 16610 16611 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 16612 16613 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 16614 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 16615 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 16616 16617 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT), 16618 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 16619 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 16620 16621 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 16622 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 16623 16624 { } /* end */ 16625}; 16626 16627/* Pin assignment: Speaker=0x14, HP = 0x15, 16628 * Mic=0x18, Internal Mic = 0x19, CD = 0x1c, PC Beep = 0x1d 16629 */ 16630static struct snd_kcontrol_new alc861vd_dallas_mixer[] = { 16631 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 16632 HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT), 16633 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 16634 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT), 16635 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 16636 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 16637 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 16638 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT), 16639 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 16640 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 16641 { } /* end */ 16642}; 16643 16644/* Pin assignment: Speaker=0x14, Line-out = 0x15, 16645 * Front Mic=0x18, ATAPI Mic = 0x19, 16646 */ 16647static struct snd_kcontrol_new alc861vd_hp_mixer[] = { 16648 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 16649 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 16650 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 16651 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT), 16652 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 16653 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 16654 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 16655 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 16656 16657 { } /* end */ 16658}; 16659 16660/* 16661 * generic initialization of ADC, input mixers and output mixers 16662 */ 16663static struct hda_verb alc861vd_volume_init_verbs[] = { 16664 /* 16665 * Unmute ADC0 and set the default input to mic-in 16666 */ 16667 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 16668 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 16669 16670 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of 16671 * the analog-loopback mixer widget 16672 */ 16673 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 16674 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 16675 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 16676 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 16677 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 16678 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 16679 16680 /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */ 16681 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 16682 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 16683 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 16684 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 16685 16686 /* 16687 * Set up output mixers (0x02 - 0x05) 16688 */ 16689 /* set vol=0 to output mixers */ 16690 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 16691 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 16692 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 16693 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 16694 16695 /* set up input amps for analog loopback */ 16696 /* Amp Indices: DAC = 0, mixer = 1 */ 16697 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 16698 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 16699 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 16700 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 16701 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 16702 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 16703 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 16704 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 16705 16706 { } 16707}; 16708 16709/* 16710 * 3-stack pin configuration: 16711 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b 16712 */ 16713static struct hda_verb alc861vd_3stack_init_verbs[] = { 16714 /* 16715 * Set pin mode and muting 16716 */ 16717 /* set front pin widgets 0x14 for output */ 16718 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 16719 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 16720 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 16721 16722 /* Mic (rear) pin: input vref at 80% */ 16723 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 16724 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 16725 /* Front Mic pin: input vref at 80% */ 16726 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 16727 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 16728 /* Line In pin: input */ 16729 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 16730 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 16731 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 16732 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 16733 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 16734 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 16735 /* CD pin widget for input */ 16736 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 16737 16738 { } 16739}; 16740 16741/* 16742 * 6-stack pin configuration: 16743 */ 16744static struct hda_verb alc861vd_6stack_init_verbs[] = { 16745 /* 16746 * Set pin mode and muting 16747 */ 16748 /* set front pin widgets 0x14 for output */ 16749 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 16750 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 16751 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 16752 16753 /* Rear Pin: output 1 (0x0d) */ 16754 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 16755 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 16756 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 16757 /* CLFE Pin: output 2 (0x0e) */ 16758 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 16759 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 16760 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02}, 16761 /* Side Pin: output 3 (0x0f) */ 16762 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 16763 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 16764 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 16765 16766 /* Mic (rear) pin: input vref at 80% */ 16767 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 16768 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 16769 /* Front Mic pin: input vref at 80% */ 16770 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 16771 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 16772 /* Line In pin: input */ 16773 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 16774 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 16775 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 16776 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 16777 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 16778 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 16779 /* CD pin widget for input */ 16780 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 16781 16782 { } 16783}; 16784 16785static struct hda_verb alc861vd_eapd_verbs[] = { 16786 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 16787 { } 16788}; 16789 16790static struct hda_verb alc660vd_eapd_verbs[] = { 16791 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 16792 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 16793 { } 16794}; 16795 16796static struct hda_verb alc861vd_lenovo_unsol_verbs[] = { 16797 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 16798 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 16799 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 16800 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 16801 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 16802 {} 16803}; 16804 16805static void alc861vd_lenovo_setup(struct hda_codec *codec) 16806{ 16807 struct alc_spec *spec = codec->spec; 16808 spec->autocfg.hp_pins[0] = 0x1b; 16809 spec->autocfg.speaker_pins[0] = 0x14; 16810} 16811 16812static void alc861vd_lenovo_init_hook(struct hda_codec *codec) 16813{ 16814 alc_automute_amp(codec); 16815 alc88x_simple_mic_automute(codec); 16816} 16817 16818static void alc861vd_lenovo_unsol_event(struct hda_codec *codec, 16819 unsigned int res) 16820{ 16821 switch (res >> 26) { 16822 case ALC880_MIC_EVENT: 16823 alc88x_simple_mic_automute(codec); 16824 break; 16825 default: 16826 alc_automute_amp_unsol_event(codec, res); 16827 break; 16828 } 16829} 16830 16831static struct hda_verb alc861vd_dallas_verbs[] = { 16832 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 16833 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 16834 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 16835 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 16836 16837 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 16838 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 16839 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 16840 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 16841 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 16842 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 16843 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 16844 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 16845 16846 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 16847 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 16848 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 16849 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 16850 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 16851 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 16852 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 16853 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 16854 16855 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50}, 16856 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 16857 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50}, 16858 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 16859 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 16860 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 16861 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 16862 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 16863 16864 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 16865 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 16866 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 16867 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 16868 16869 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 16870 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 16871 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 16872 16873 { } /* end */ 16874}; 16875 16876/* toggle speaker-output according to the hp-jack state */ 16877static void alc861vd_dallas_setup(struct hda_codec *codec) 16878{ 16879 struct alc_spec *spec = codec->spec; 16880 16881 spec->autocfg.hp_pins[0] = 0x15; 16882 spec->autocfg.speaker_pins[0] = 0x14; 16883} 16884 16885#ifdef CONFIG_SND_HDA_POWER_SAVE 16886#define alc861vd_loopbacks alc880_loopbacks 16887#endif 16888 16889/* pcm configuration: identical with ALC880 */ 16890#define alc861vd_pcm_analog_playback alc880_pcm_analog_playback 16891#define alc861vd_pcm_analog_capture alc880_pcm_analog_capture 16892#define alc861vd_pcm_digital_playback alc880_pcm_digital_playback 16893#define alc861vd_pcm_digital_capture alc880_pcm_digital_capture 16894 16895/* 16896 * configuration and preset 16897 */ 16898static const char * const alc861vd_models[ALC861VD_MODEL_LAST] = { 16899 [ALC660VD_3ST] = "3stack-660", 16900 [ALC660VD_3ST_DIG] = "3stack-660-digout", 16901 [ALC660VD_ASUS_V1S] = "asus-v1s", 16902 [ALC861VD_3ST] = "3stack", 16903 [ALC861VD_3ST_DIG] = "3stack-digout", 16904 [ALC861VD_6ST_DIG] = "6stack-digout", 16905 [ALC861VD_LENOVO] = "lenovo", 16906 [ALC861VD_DALLAS] = "dallas", 16907 [ALC861VD_HP] = "hp", 16908 [ALC861VD_AUTO] = "auto", 16909}; 16910 16911static struct snd_pci_quirk alc861vd_cfg_tbl[] = { 16912 SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST), 16913 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP), 16914 SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST), 16915 /*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */ 16916 SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S), 16917 SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG), 16918 SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST), 16919 SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO), 16920 /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/ 16921 SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO), 16922 SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO), 16923 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS), 16924 SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG), 16925 SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO), 16926 SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG), 16927 {} 16928}; 16929 16930static struct alc_config_preset alc861vd_presets[] = { 16931 [ALC660VD_3ST] = { 16932 .mixers = { alc861vd_3st_mixer }, 16933 .init_verbs = { alc861vd_volume_init_verbs, 16934 alc861vd_3stack_init_verbs }, 16935 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids), 16936 .dac_nids = alc660vd_dac_nids, 16937 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 16938 .channel_mode = alc861vd_3stack_2ch_modes, 16939 .input_mux = &alc861vd_capture_source, 16940 }, 16941 [ALC660VD_3ST_DIG] = { 16942 .mixers = { alc861vd_3st_mixer }, 16943 .init_verbs = { alc861vd_volume_init_verbs, 16944 alc861vd_3stack_init_verbs }, 16945 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids), 16946 .dac_nids = alc660vd_dac_nids, 16947 .dig_out_nid = ALC861VD_DIGOUT_NID, 16948 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 16949 .channel_mode = alc861vd_3stack_2ch_modes, 16950 .input_mux = &alc861vd_capture_source, 16951 }, 16952 [ALC861VD_3ST] = { 16953 .mixers = { alc861vd_3st_mixer }, 16954 .init_verbs = { alc861vd_volume_init_verbs, 16955 alc861vd_3stack_init_verbs }, 16956 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 16957 .dac_nids = alc861vd_dac_nids, 16958 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 16959 .channel_mode = alc861vd_3stack_2ch_modes, 16960 .input_mux = &alc861vd_capture_source, 16961 }, 16962 [ALC861VD_3ST_DIG] = { 16963 .mixers = { alc861vd_3st_mixer }, 16964 .init_verbs = { alc861vd_volume_init_verbs, 16965 alc861vd_3stack_init_verbs }, 16966 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 16967 .dac_nids = alc861vd_dac_nids, 16968 .dig_out_nid = ALC861VD_DIGOUT_NID, 16969 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 16970 .channel_mode = alc861vd_3stack_2ch_modes, 16971 .input_mux = &alc861vd_capture_source, 16972 }, 16973 [ALC861VD_6ST_DIG] = { 16974 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer }, 16975 .init_verbs = { alc861vd_volume_init_verbs, 16976 alc861vd_6stack_init_verbs }, 16977 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 16978 .dac_nids = alc861vd_dac_nids, 16979 .dig_out_nid = ALC861VD_DIGOUT_NID, 16980 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes), 16981 .channel_mode = alc861vd_6stack_modes, 16982 .input_mux = &alc861vd_capture_source, 16983 }, 16984 [ALC861VD_LENOVO] = { 16985 .mixers = { alc861vd_lenovo_mixer }, 16986 .init_verbs = { alc861vd_volume_init_verbs, 16987 alc861vd_3stack_init_verbs, 16988 alc861vd_eapd_verbs, 16989 alc861vd_lenovo_unsol_verbs }, 16990 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids), 16991 .dac_nids = alc660vd_dac_nids, 16992 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 16993 .channel_mode = alc861vd_3stack_2ch_modes, 16994 .input_mux = &alc861vd_capture_source, 16995 .unsol_event = alc861vd_lenovo_unsol_event, 16996 .setup = alc861vd_lenovo_setup, 16997 .init_hook = alc861vd_lenovo_init_hook, 16998 }, 16999 [ALC861VD_DALLAS] = { 17000 .mixers = { alc861vd_dallas_mixer }, 17001 .init_verbs = { alc861vd_dallas_verbs }, 17002 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 17003 .dac_nids = alc861vd_dac_nids, 17004 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 17005 .channel_mode = alc861vd_3stack_2ch_modes, 17006 .input_mux = &alc861vd_dallas_capture_source, 17007 .unsol_event = alc_automute_amp_unsol_event, 17008 .setup = alc861vd_dallas_setup, 17009 .init_hook = alc_automute_amp, 17010 }, 17011 [ALC861VD_HP] = { 17012 .mixers = { alc861vd_hp_mixer }, 17013 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs }, 17014 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 17015 .dac_nids = alc861vd_dac_nids, 17016 .dig_out_nid = ALC861VD_DIGOUT_NID, 17017 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 17018 .channel_mode = alc861vd_3stack_2ch_modes, 17019 .input_mux = &alc861vd_hp_capture_source, 17020 .unsol_event = alc_automute_amp_unsol_event, 17021 .setup = alc861vd_dallas_setup, 17022 .init_hook = alc_automute_amp, 17023 }, 17024 [ALC660VD_ASUS_V1S] = { 17025 .mixers = { alc861vd_lenovo_mixer }, 17026 .init_verbs = { alc861vd_volume_init_verbs, 17027 alc861vd_3stack_init_verbs, 17028 alc861vd_eapd_verbs, 17029 alc861vd_lenovo_unsol_verbs }, 17030 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids), 17031 .dac_nids = alc660vd_dac_nids, 17032 .dig_out_nid = ALC861VD_DIGOUT_NID, 17033 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 17034 .channel_mode = alc861vd_3stack_2ch_modes, 17035 .input_mux = &alc861vd_capture_source, 17036 .unsol_event = alc861vd_lenovo_unsol_event, 17037 .setup = alc861vd_lenovo_setup, 17038 .init_hook = alc861vd_lenovo_init_hook, 17039 }, 17040}; 17041 17042/* 17043 * BIOS auto configuration 17044 */ 17045static int alc861vd_auto_create_input_ctls(struct hda_codec *codec, 17046 const struct auto_pin_cfg *cfg) 17047{ 17048 return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x22, 0); 17049} 17050 17051 17052static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec, 17053 hda_nid_t nid, int pin_type, int dac_idx) 17054{ 17055 alc_set_pin_output(codec, nid, pin_type); 17056} 17057 17058static void alc861vd_auto_init_multi_out(struct hda_codec *codec) 17059{ 17060 struct alc_spec *spec = codec->spec; 17061 int i; 17062 17063 for (i = 0; i <= HDA_SIDE; i++) { 17064 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 17065 int pin_type = get_pin_type(spec->autocfg.line_out_type); 17066 if (nid) 17067 alc861vd_auto_set_output_and_unmute(codec, nid, 17068 pin_type, i); 17069 } 17070} 17071 17072 17073static void alc861vd_auto_init_hp_out(struct hda_codec *codec) 17074{ 17075 struct alc_spec *spec = codec->spec; 17076 hda_nid_t pin; 17077 17078 pin = spec->autocfg.hp_pins[0]; 17079 if (pin) /* connect to front and use dac 0 */ 17080 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 17081 pin = spec->autocfg.speaker_pins[0]; 17082 if (pin) 17083 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 17084} 17085 17086#define ALC861VD_PIN_CD_NID ALC880_PIN_CD_NID 17087 17088static void alc861vd_auto_init_analog_input(struct hda_codec *codec) 17089{ 17090 struct alc_spec *spec = codec->spec; 17091 struct auto_pin_cfg *cfg = &spec->autocfg; 17092 int i; 17093 17094 for (i = 0; i < cfg->num_inputs; i++) { 17095 hda_nid_t nid = cfg->inputs[i].pin; 17096 if (alc_is_input_pin(codec, nid)) { 17097 alc_set_input_pin(codec, nid, cfg->inputs[i].type); 17098 if (nid != ALC861VD_PIN_CD_NID && 17099 (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)) 17100 snd_hda_codec_write(codec, nid, 0, 17101 AC_VERB_SET_AMP_GAIN_MUTE, 17102 AMP_OUT_MUTE); 17103 } 17104 } 17105} 17106 17107#define alc861vd_auto_init_input_src alc882_auto_init_input_src 17108 17109#define alc861vd_idx_to_mixer_vol(nid) ((nid) + 0x02) 17110#define alc861vd_idx_to_mixer_switch(nid) ((nid) + 0x0c) 17111 17112/* add playback controls from the parsed DAC table */ 17113/* Based on ALC880 version. But ALC861VD has separate, 17114 * different NIDs for mute/unmute switch and volume control */ 17115static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec, 17116 const struct auto_pin_cfg *cfg) 17117{ 17118 static const char * const chname[4] = { 17119 "Front", "Surround", "CLFE", "Side" 17120 }; 17121 const char *pfx = alc_get_line_out_pfx(cfg, true); 17122 hda_nid_t nid_v, nid_s; 17123 int i, err; 17124 17125 for (i = 0; i < cfg->line_outs; i++) { 17126 if (!spec->multiout.dac_nids[i]) 17127 continue; 17128 nid_v = alc861vd_idx_to_mixer_vol( 17129 alc880_dac_to_idx( 17130 spec->multiout.dac_nids[i])); 17131 nid_s = alc861vd_idx_to_mixer_switch( 17132 alc880_dac_to_idx( 17133 spec->multiout.dac_nids[i])); 17134 17135 if (!pfx && i == 2) { 17136 /* Center/LFE */ 17137 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, 17138 "Center", 17139 HDA_COMPOSE_AMP_VAL(nid_v, 1, 0, 17140 HDA_OUTPUT)); 17141 if (err < 0) 17142 return err; 17143 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, 17144 "LFE", 17145 HDA_COMPOSE_AMP_VAL(nid_v, 2, 0, 17146 HDA_OUTPUT)); 17147 if (err < 0) 17148 return err; 17149 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, 17150 "Center", 17151 HDA_COMPOSE_AMP_VAL(nid_s, 1, 2, 17152 HDA_INPUT)); 17153 if (err < 0) 17154 return err; 17155 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, 17156 "LFE", 17157 HDA_COMPOSE_AMP_VAL(nid_s, 2, 2, 17158 HDA_INPUT)); 17159 if (err < 0) 17160 return err; 17161 } else { 17162 const char *name = pfx; 17163 if (!name) 17164 name = chname[i]; 17165 err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, 17166 name, i, 17167 HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, 17168 HDA_OUTPUT)); 17169 if (err < 0) 17170 return err; 17171 err = __add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, 17172 name, i, 17173 HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, 17174 HDA_INPUT)); 17175 if (err < 0) 17176 return err; 17177 } 17178 } 17179 return 0; 17180} 17181 17182/* add playback controls for speaker and HP outputs */ 17183/* Based on ALC880 version. But ALC861VD has separate, 17184 * different NIDs for mute/unmute switch and volume control */ 17185static int alc861vd_auto_create_extra_out(struct alc_spec *spec, 17186 hda_nid_t pin, const char *pfx) 17187{ 17188 hda_nid_t nid_v, nid_s; 17189 int err; 17190 17191 if (!pin) 17192 return 0; 17193 17194 if (alc880_is_fixed_pin(pin)) { 17195 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin)); 17196 /* specify the DAC as the extra output */ 17197 if (!spec->multiout.hp_nid) 17198 spec->multiout.hp_nid = nid_v; 17199 else 17200 spec->multiout.extra_out_nid[0] = nid_v; 17201 /* control HP volume/switch on the output mixer amp */ 17202 nid_v = alc861vd_idx_to_mixer_vol( 17203 alc880_fixed_pin_idx(pin)); 17204 nid_s = alc861vd_idx_to_mixer_switch( 17205 alc880_fixed_pin_idx(pin)); 17206 17207 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, 17208 HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT)); 17209 if (err < 0) 17210 return err; 17211 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx, 17212 HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT)); 17213 if (err < 0) 17214 return err; 17215 } else if (alc880_is_multi_pin(pin)) { 17216 /* set manual connection */ 17217 /* we have only a switch on HP-out PIN */ 17218 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, 17219 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 17220 if (err < 0) 17221 return err; 17222 } 17223 return 0; 17224} 17225 17226/* parse the BIOS configuration and set up the alc_spec 17227 * return 1 if successful, 0 if the proper config is not found, 17228 * or a negative error code 17229 * Based on ALC880 version - had to change it to override 17230 * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */ 17231static int alc861vd_parse_auto_config(struct hda_codec *codec) 17232{ 17233 struct alc_spec *spec = codec->spec; 17234 int err; 17235 static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 }; 17236 17237 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 17238 alc861vd_ignore); 17239 if (err < 0) 17240 return err; 17241 if (!spec->autocfg.line_outs) 17242 return 0; /* can't find valid BIOS pin config */ 17243 17244 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg); 17245 if (err < 0) 17246 return err; 17247 err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg); 17248 if (err < 0) 17249 return err; 17250 err = alc861vd_auto_create_extra_out(spec, 17251 spec->autocfg.speaker_pins[0], 17252 "Speaker"); 17253 if (err < 0) 17254 return err; 17255 err = alc861vd_auto_create_extra_out(spec, 17256 spec->autocfg.hp_pins[0], 17257 "Headphone"); 17258 if (err < 0) 17259 return err; 17260 err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg); 17261 if (err < 0) 17262 return err; 17263 17264 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 17265 17266 alc_auto_parse_digital(codec); 17267 17268 if (spec->kctls.list) 17269 add_mixer(spec, spec->kctls.list); 17270 17271 add_verb(spec, alc861vd_volume_init_verbs); 17272 17273 spec->num_mux_defs = 1; 17274 spec->input_mux = &spec->private_imux[0]; 17275 17276 err = alc_auto_add_mic_boost(codec); 17277 if (err < 0) 17278 return err; 17279 17280 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0); 17281 17282 return 1; 17283} 17284 17285/* additional initialization for auto-configuration model */ 17286static void alc861vd_auto_init(struct hda_codec *codec) 17287{ 17288 struct alc_spec *spec = codec->spec; 17289 alc861vd_auto_init_multi_out(codec); 17290 alc861vd_auto_init_hp_out(codec); 17291 alc861vd_auto_init_analog_input(codec); 17292 alc861vd_auto_init_input_src(codec); 17293 alc_auto_init_digital(codec); 17294 if (spec->unsol_event) 17295 alc_inithook(codec); 17296} 17297 17298enum { 17299 ALC660VD_FIX_ASUS_GPIO1 17300}; 17301 17302/* reset GPIO1 */ 17303static const struct alc_fixup alc861vd_fixups[] = { 17304 [ALC660VD_FIX_ASUS_GPIO1] = { 17305 .type = ALC_FIXUP_VERBS, 17306 .v.verbs = (const struct hda_verb[]) { 17307 {0x01, AC_VERB_SET_GPIO_MASK, 0x03}, 17308 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, 17309 {0x01, AC_VERB_SET_GPIO_DATA, 0x01}, 17310 { } 17311 } 17312 }, 17313}; 17314 17315static struct snd_pci_quirk alc861vd_fixup_tbl[] = { 17316 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1), 17317 {} 17318}; 17319 17320static int patch_alc861vd(struct hda_codec *codec) 17321{ 17322 struct alc_spec *spec; 17323 int err, board_config; 17324 17325 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 17326 if (spec == NULL) 17327 return -ENOMEM; 17328 17329 codec->spec = spec; 17330 17331 board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST, 17332 alc861vd_models, 17333 alc861vd_cfg_tbl); 17334 17335 if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) { 17336 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 17337 codec->chip_name); 17338 board_config = ALC861VD_AUTO; 17339 } 17340 17341 if (board_config == ALC861VD_AUTO) { 17342 alc_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups); 17343 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE); 17344 } 17345 17346 if (board_config == ALC861VD_AUTO) { 17347 /* automatic parse from the BIOS config */ 17348 err = alc861vd_parse_auto_config(codec); 17349 if (err < 0) { 17350 alc_free(codec); 17351 return err; 17352 } else if (!err) { 17353 printk(KERN_INFO 17354 "hda_codec: Cannot set up configuration " 17355 "from BIOS. Using base mode...\n"); 17356 board_config = ALC861VD_3ST; 17357 } 17358 } 17359 17360 err = snd_hda_attach_beep_device(codec, 0x23); 17361 if (err < 0) { 17362 alc_free(codec); 17363 return err; 17364 } 17365 17366 if (board_config != ALC861VD_AUTO) 17367 setup_preset(codec, &alc861vd_presets[board_config]); 17368 17369 if (codec->vendor_id == 0x10ec0660) { 17370 /* always turn on EAPD */ 17371 add_verb(spec, alc660vd_eapd_verbs); 17372 } 17373 17374 spec->stream_analog_playback = &alc861vd_pcm_analog_playback; 17375 spec->stream_analog_capture = &alc861vd_pcm_analog_capture; 17376 17377 spec->stream_digital_playback = &alc861vd_pcm_digital_playback; 17378 spec->stream_digital_capture = &alc861vd_pcm_digital_capture; 17379 17380 if (!spec->adc_nids) { 17381 spec->adc_nids = alc861vd_adc_nids; 17382 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids); 17383 } 17384 if (!spec->capsrc_nids) 17385 spec->capsrc_nids = alc861vd_capsrc_nids; 17386 17387 set_capture_mixer(codec); 17388 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 17389 17390 spec->vmaster_nid = 0x02; 17391 17392 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE); 17393 17394 codec->patch_ops = alc_patch_ops; 17395 17396 if (board_config == ALC861VD_AUTO) 17397 spec->init_hook = alc861vd_auto_init; 17398#ifdef CONFIG_SND_HDA_POWER_SAVE 17399 if (!spec->loopback.amplist) 17400 spec->loopback.amplist = alc861vd_loopbacks; 17401#endif 17402 17403 return 0; 17404} 17405 17406/* 17407 * ALC662 support 17408 * 17409 * ALC662 is almost identical with ALC880 but has cleaner and more flexible 17410 * configuration. Each pin widget can choose any input DACs and a mixer. 17411 * Each ADC is connected from a mixer of all inputs. This makes possible 17412 * 6-channel independent captures. 17413 * 17414 * In addition, an independent DAC for the multi-playback (not used in this 17415 * driver yet). 17416 */ 17417#define ALC662_DIGOUT_NID 0x06 17418#define ALC662_DIGIN_NID 0x0a 17419 17420static hda_nid_t alc662_dac_nids[4] = { 17421 /* front, rear, clfe, rear_surr */ 17422 0x02, 0x03, 0x04 17423}; 17424 17425static hda_nid_t alc272_dac_nids[2] = { 17426 0x02, 0x03 17427}; 17428 17429static hda_nid_t alc662_adc_nids[2] = { 17430 /* ADC1-2 */ 17431 0x09, 0x08 17432}; 17433 17434static hda_nid_t alc272_adc_nids[1] = { 17435 /* ADC1-2 */ 17436 0x08, 17437}; 17438 17439static hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 }; 17440static hda_nid_t alc272_capsrc_nids[1] = { 0x23 }; 17441 17442 17443/* input MUX */ 17444/* FIXME: should be a matrix-type input source selection */ 17445static struct hda_input_mux alc662_capture_source = { 17446 .num_items = 4, 17447 .items = { 17448 { "Mic", 0x0 }, 17449 { "Front Mic", 0x1 }, 17450 { "Line", 0x2 }, 17451 { "CD", 0x4 }, 17452 }, 17453}; 17454 17455static struct hda_input_mux alc662_lenovo_101e_capture_source = { 17456 .num_items = 2, 17457 .items = { 17458 { "Mic", 0x1 }, 17459 { "Line", 0x2 }, 17460 }, 17461}; 17462 17463static struct hda_input_mux alc663_capture_source = { 17464 .num_items = 3, 17465 .items = { 17466 { "Mic", 0x0 }, 17467 { "Front Mic", 0x1 }, 17468 { "Line", 0x2 }, 17469 }, 17470}; 17471 17472#if 0 /* set to 1 for testing other input sources below */ 17473static struct hda_input_mux alc272_nc10_capture_source = { 17474 .num_items = 16, 17475 .items = { 17476 { "Autoselect Mic", 0x0 }, 17477 { "Internal Mic", 0x1 }, 17478 { "In-0x02", 0x2 }, 17479 { "In-0x03", 0x3 }, 17480 { "In-0x04", 0x4 }, 17481 { "In-0x05", 0x5 }, 17482 { "In-0x06", 0x6 }, 17483 { "In-0x07", 0x7 }, 17484 { "In-0x08", 0x8 }, 17485 { "In-0x09", 0x9 }, 17486 { "In-0x0a", 0x0a }, 17487 { "In-0x0b", 0x0b }, 17488 { "In-0x0c", 0x0c }, 17489 { "In-0x0d", 0x0d }, 17490 { "In-0x0e", 0x0e }, 17491 { "In-0x0f", 0x0f }, 17492 }, 17493}; 17494#endif 17495 17496/* 17497 * 2ch mode 17498 */ 17499static struct hda_channel_mode alc662_3ST_2ch_modes[1] = { 17500 { 2, NULL } 17501}; 17502 17503/* 17504 * 2ch mode 17505 */ 17506static struct hda_verb alc662_3ST_ch2_init[] = { 17507 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 17508 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 17509 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 17510 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 17511 { } /* end */ 17512}; 17513 17514/* 17515 * 6ch mode 17516 */ 17517static struct hda_verb alc662_3ST_ch6_init[] = { 17518 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 17519 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 17520 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 }, 17521 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 17522 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 17523 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 17524 { } /* end */ 17525}; 17526 17527static struct hda_channel_mode alc662_3ST_6ch_modes[2] = { 17528 { 2, alc662_3ST_ch2_init }, 17529 { 6, alc662_3ST_ch6_init }, 17530}; 17531 17532/* 17533 * 2ch mode 17534 */ 17535static struct hda_verb alc662_sixstack_ch6_init[] = { 17536 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 17537 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 17538 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 17539 { } /* end */ 17540}; 17541 17542/* 17543 * 6ch mode 17544 */ 17545static struct hda_verb alc662_sixstack_ch8_init[] = { 17546 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 17547 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 17548 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 17549 { } /* end */ 17550}; 17551 17552static struct hda_channel_mode alc662_5stack_modes[2] = { 17553 { 2, alc662_sixstack_ch6_init }, 17554 { 6, alc662_sixstack_ch8_init }, 17555}; 17556 17557/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17 17558 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b 17559 */ 17560 17561static struct snd_kcontrol_new alc662_base_mixer[] = { 17562 /* output mixer control */ 17563 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT), 17564 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT), 17565 HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT), 17566 HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT), 17567 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT), 17568 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT), 17569 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT), 17570 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT), 17571 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 17572 17573 /*Input mixer control */ 17574 HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT), 17575 HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT), 17576 HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT), 17577 HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT), 17578 HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT), 17579 HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT), 17580 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT), 17581 HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT), 17582 { } /* end */ 17583}; 17584 17585static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = { 17586 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 17587 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT), 17588 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 17589 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 17590 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 17591 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 17592 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 17593 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 17594 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 17595 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 17596 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 17597 { } /* end */ 17598}; 17599 17600static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = { 17601 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 17602 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT), 17603 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT), 17604 HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT), 17605 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT), 17606 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT), 17607 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT), 17608 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT), 17609 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 17610 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 17611 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 17612 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 17613 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 17614 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 17615 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 17616 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 17617 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 17618 { } /* end */ 17619}; 17620 17621static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = { 17622 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 17623 HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT), 17624 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT), 17625 HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT), 17626 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 17627 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 17628 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 17629 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 17630 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 17631 { } /* end */ 17632}; 17633 17634static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = { 17635 HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT), 17636 ALC262_HIPPO_MASTER_SWITCH, 17637 17638 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 17639 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 17640 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 17641 17642 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT), 17643 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 17644 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 17645 { } /* end */ 17646}; 17647 17648static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = { 17649 ALC262_HIPPO_MASTER_SWITCH, 17650 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 17651 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT), 17652 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT), 17653 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT), 17654 HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT), 17655 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 17656 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 17657 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 17658 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 17659 { } /* end */ 17660}; 17661 17662static struct hda_bind_ctls alc663_asus_bind_master_vol = { 17663 .ops = &snd_hda_bind_vol, 17664 .values = { 17665 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT), 17666 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT), 17667 0 17668 }, 17669}; 17670 17671static struct hda_bind_ctls alc663_asus_one_bind_switch = { 17672 .ops = &snd_hda_bind_sw, 17673 .values = { 17674 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 17675 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT), 17676 0 17677 }, 17678}; 17679 17680static struct snd_kcontrol_new alc663_m51va_mixer[] = { 17681 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol), 17682 HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch), 17683 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 17684 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 17685 { } /* end */ 17686}; 17687 17688static struct hda_bind_ctls alc663_asus_tree_bind_switch = { 17689 .ops = &snd_hda_bind_sw, 17690 .values = { 17691 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 17692 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT), 17693 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT), 17694 0 17695 }, 17696}; 17697 17698static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = { 17699 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol), 17700 HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch), 17701 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 17702 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 17703 HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 17704 HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 17705 17706 { } /* end */ 17707}; 17708 17709static struct hda_bind_ctls alc663_asus_four_bind_switch = { 17710 .ops = &snd_hda_bind_sw, 17711 .values = { 17712 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 17713 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT), 17714 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT), 17715 0 17716 }, 17717}; 17718 17719static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = { 17720 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol), 17721 HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch), 17722 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 17723 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 17724 HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 17725 HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 17726 { } /* end */ 17727}; 17728 17729static struct snd_kcontrol_new alc662_1bjd_mixer[] = { 17730 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 17731 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 17732 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 17733 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 17734 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 17735 HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 17736 HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 17737 { } /* end */ 17738}; 17739 17740static struct hda_bind_ctls alc663_asus_two_bind_master_vol = { 17741 .ops = &snd_hda_bind_vol, 17742 .values = { 17743 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT), 17744 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT), 17745 0 17746 }, 17747}; 17748 17749static struct hda_bind_ctls alc663_asus_two_bind_switch = { 17750 .ops = &snd_hda_bind_sw, 17751 .values = { 17752 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 17753 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT), 17754 0 17755 }, 17756}; 17757 17758static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = { 17759 HDA_BIND_VOL("Master Playback Volume", 17760 &alc663_asus_two_bind_master_vol), 17761 HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch), 17762 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 17763 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT), 17764 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 17765 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 17766 { } /* end */ 17767}; 17768 17769static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = { 17770 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol), 17771 HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch), 17772 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 17773 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 17774 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 17775 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 17776 { } /* end */ 17777}; 17778 17779static struct snd_kcontrol_new alc663_g71v_mixer[] = { 17780 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 17781 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 17782 HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT), 17783 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT), 17784 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT), 17785 17786 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 17787 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 17788 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 17789 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 17790 { } /* end */ 17791}; 17792 17793static struct snd_kcontrol_new alc663_g50v_mixer[] = { 17794 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 17795 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 17796 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT), 17797 17798 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 17799 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 17800 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 17801 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 17802 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 17803 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 17804 { } /* end */ 17805}; 17806 17807static struct hda_bind_ctls alc663_asus_mode7_8_all_bind_switch = { 17808 .ops = &snd_hda_bind_sw, 17809 .values = { 17810 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 17811 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT), 17812 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT), 17813 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT), 17814 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT), 17815 0 17816 }, 17817}; 17818 17819static struct hda_bind_ctls alc663_asus_mode7_8_sp_bind_switch = { 17820 .ops = &snd_hda_bind_sw, 17821 .values = { 17822 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 17823 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT), 17824 0 17825 }, 17826}; 17827 17828static struct snd_kcontrol_new alc663_mode7_mixer[] = { 17829 HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch), 17830 HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol), 17831 HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch), 17832 HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 17833 HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT), 17834 HDA_CODEC_VOLUME("IntMic Playback Volume", 0x0b, 0x0, HDA_INPUT), 17835 HDA_CODEC_MUTE("IntMic Playback Switch", 0x0b, 0x0, HDA_INPUT), 17836 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 17837 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 17838 { } /* end */ 17839}; 17840 17841static struct snd_kcontrol_new alc663_mode8_mixer[] = { 17842 HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch), 17843 HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol), 17844 HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch), 17845 HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x15, 0x0, HDA_OUTPUT), 17846 HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT), 17847 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 17848 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 17849 { } /* end */ 17850}; 17851 17852 17853static struct snd_kcontrol_new alc662_chmode_mixer[] = { 17854 { 17855 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 17856 .name = "Channel Mode", 17857 .info = alc_ch_mode_info, 17858 .get = alc_ch_mode_get, 17859 .put = alc_ch_mode_put, 17860 }, 17861 { } /* end */ 17862}; 17863 17864static struct hda_verb alc662_init_verbs[] = { 17865 /* ADC: mute amp left and right */ 17866 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 17867 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 17868 17869 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 17870 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 17871 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 17872 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 17873 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 17874 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 17875 17876 /* Front Pin: output 0 (0x0c) */ 17877 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 17878 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 17879 17880 /* Rear Pin: output 1 (0x0d) */ 17881 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 17882 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 17883 17884 /* CLFE Pin: output 2 (0x0e) */ 17885 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 17886 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 17887 17888 /* Mic (rear) pin: input vref at 80% */ 17889 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 17890 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 17891 /* Front Mic pin: input vref at 80% */ 17892 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 17893 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 17894 /* Line In pin: input */ 17895 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 17896 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 17897 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 17898 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 17899 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 17900 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 17901 /* CD pin widget for input */ 17902 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 17903 17904 /* FIXME: use matrix-type input source selection */ 17905 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 17906 /* Input mixer */ 17907 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 17908 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 17909 17910 /* always trun on EAPD */ 17911 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 17912 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 17913 17914 { } 17915}; 17916 17917static struct hda_verb alc663_init_verbs[] = { 17918 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 17919 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 17920 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 17921 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 17922 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 17923 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 17924 { } 17925}; 17926 17927static struct hda_verb alc272_init_verbs[] = { 17928 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 17929 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 17930 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 17931 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 17932 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 17933 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 17934 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 17935 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 17936 { } 17937}; 17938 17939static struct hda_verb alc662_sue_init_verbs[] = { 17940 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT}, 17941 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT}, 17942 {} 17943}; 17944 17945static struct hda_verb alc662_eeepc_sue_init_verbs[] = { 17946 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 17947 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 17948 {} 17949}; 17950 17951/* Set Unsolicited Event*/ 17952static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = { 17953 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 17954 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 17955 {} 17956}; 17957 17958static struct hda_verb alc663_m51va_init_verbs[] = { 17959 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 17960 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 17961 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 17962 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 17963 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */ 17964 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 17965 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)}, 17966 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 17967 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 17968 {} 17969}; 17970 17971static struct hda_verb alc663_21jd_amic_init_verbs[] = { 17972 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 17973 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 17974 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */ 17975 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 17976 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 17977 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 17978 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 17979 {} 17980}; 17981 17982static struct hda_verb alc662_1bjd_amic_init_verbs[] = { 17983 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 17984 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 17985 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 17986 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */ 17987 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 17988 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 17989 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 17990 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 17991 {} 17992}; 17993 17994static struct hda_verb alc663_15jd_amic_init_verbs[] = { 17995 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 17996 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 17997 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */ 17998 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 17999 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 18000 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 18001 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 18002 {} 18003}; 18004 18005static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = { 18006 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 18007 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 18008 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 18009 {0x21, AC_VERB_SET_CONNECT_SEL, 0x0}, /* Headphone */ 18010 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 18011 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 18012 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0}, /* Headphone */ 18013 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 18014 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 18015 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 18016 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 18017 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 18018 {} 18019}; 18020 18021static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = { 18022 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 18023 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 18024 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 18025 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */ 18026 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 18027 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 18028 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */ 18029 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 18030 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 18031 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 18032 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 18033 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 18034 {} 18035}; 18036 18037static struct hda_verb alc663_g71v_init_verbs[] = { 18038 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 18039 /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */ 18040 /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */ 18041 18042 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 18043 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 18044 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */ 18045 18046 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT}, 18047 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT}, 18048 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT}, 18049 {} 18050}; 18051 18052static struct hda_verb alc663_g50v_init_verbs[] = { 18053 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 18054 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 18055 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */ 18056 18057 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 18058 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 18059 {} 18060}; 18061 18062static struct hda_verb alc662_ecs_init_verbs[] = { 18063 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f}, 18064 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 18065 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 18066 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 18067 {} 18068}; 18069 18070static struct hda_verb alc272_dell_zm1_init_verbs[] = { 18071 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 18072 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 18073 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 18074 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 18075 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 18076 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 18077 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */ 18078 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 18079 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)}, 18080 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 18081 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 18082 {} 18083}; 18084 18085static struct hda_verb alc272_dell_init_verbs[] = { 18086 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 18087 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 18088 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 18089 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 18090 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 18091 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 18092 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */ 18093 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 18094 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)}, 18095 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 18096 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 18097 {} 18098}; 18099 18100static struct hda_verb alc663_mode7_init_verbs[] = { 18101 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 18102 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 18103 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 18104 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 18105 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 18106 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 18107 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01}, 18108 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 18109 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 18110 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */ 18111 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 18112 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)}, 18113 {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 18114 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 18115 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 18116 {} 18117}; 18118 18119static struct hda_verb alc663_mode8_init_verbs[] = { 18120 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 18121 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 18122 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 18123 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 18124 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 18125 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 18126 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 18127 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 18128 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 18129 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 18130 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */ 18131 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 18132 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)}, 18133 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 18134 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 18135 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 18136 {} 18137}; 18138 18139static struct snd_kcontrol_new alc662_auto_capture_mixer[] = { 18140 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT), 18141 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT), 18142 { } /* end */ 18143}; 18144 18145static struct snd_kcontrol_new alc272_auto_capture_mixer[] = { 18146 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 18147 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 18148 { } /* end */ 18149}; 18150 18151static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec) 18152{ 18153 unsigned int present; 18154 unsigned char bits; 18155 18156 present = snd_hda_jack_detect(codec, 0x14); 18157 bits = present ? HDA_AMP_MUTE : 0; 18158 18159 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 18160 HDA_AMP_MUTE, bits); 18161} 18162 18163static void alc662_lenovo_101e_all_automute(struct hda_codec *codec) 18164{ 18165 unsigned int present; 18166 unsigned char bits; 18167 18168 present = snd_hda_jack_detect(codec, 0x1b); 18169 bits = present ? HDA_AMP_MUTE : 0; 18170 18171 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 18172 HDA_AMP_MUTE, bits); 18173 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 18174 HDA_AMP_MUTE, bits); 18175} 18176 18177static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec, 18178 unsigned int res) 18179{ 18180 if ((res >> 26) == ALC880_HP_EVENT) 18181 alc662_lenovo_101e_all_automute(codec); 18182 if ((res >> 26) == ALC880_FRONT_EVENT) 18183 alc662_lenovo_101e_ispeaker_automute(codec); 18184} 18185 18186/* unsolicited event for HP jack sensing */ 18187static void alc662_eeepc_unsol_event(struct hda_codec *codec, 18188 unsigned int res) 18189{ 18190 if ((res >> 26) == ALC880_MIC_EVENT) 18191 alc_mic_automute(codec); 18192 else 18193 alc262_hippo_unsol_event(codec, res); 18194} 18195 18196static void alc662_eeepc_setup(struct hda_codec *codec) 18197{ 18198 struct alc_spec *spec = codec->spec; 18199 18200 alc262_hippo1_setup(codec); 18201 spec->ext_mic.pin = 0x18; 18202 spec->ext_mic.mux_idx = 0; 18203 spec->int_mic.pin = 0x19; 18204 spec->int_mic.mux_idx = 1; 18205 spec->auto_mic = 1; 18206} 18207 18208static void alc662_eeepc_inithook(struct hda_codec *codec) 18209{ 18210 alc262_hippo_automute(codec); 18211 alc_mic_automute(codec); 18212} 18213 18214static void alc662_eeepc_ep20_setup(struct hda_codec *codec) 18215{ 18216 struct alc_spec *spec = codec->spec; 18217 18218 spec->autocfg.hp_pins[0] = 0x14; 18219 spec->autocfg.speaker_pins[0] = 0x1b; 18220} 18221 18222#define alc662_eeepc_ep20_inithook alc262_hippo_master_update 18223 18224static void alc663_m51va_speaker_automute(struct hda_codec *codec) 18225{ 18226 unsigned int present; 18227 unsigned char bits; 18228 18229 present = snd_hda_jack_detect(codec, 0x21); 18230 bits = present ? HDA_AMP_MUTE : 0; 18231 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 18232 HDA_AMP_MUTE, bits); 18233 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 18234 HDA_AMP_MUTE, bits); 18235} 18236 18237static void alc663_21jd_two_speaker_automute(struct hda_codec *codec) 18238{ 18239 unsigned int present; 18240 unsigned char bits; 18241 18242 present = snd_hda_jack_detect(codec, 0x21); 18243 bits = present ? HDA_AMP_MUTE : 0; 18244 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 18245 HDA_AMP_MUTE, bits); 18246 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 18247 HDA_AMP_MUTE, bits); 18248 snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0, 18249 HDA_AMP_MUTE, bits); 18250 snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1, 18251 HDA_AMP_MUTE, bits); 18252} 18253 18254static void alc663_15jd_two_speaker_automute(struct hda_codec *codec) 18255{ 18256 unsigned int present; 18257 unsigned char bits; 18258 18259 present = snd_hda_jack_detect(codec, 0x15); 18260 bits = present ? HDA_AMP_MUTE : 0; 18261 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 18262 HDA_AMP_MUTE, bits); 18263 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 18264 HDA_AMP_MUTE, bits); 18265 snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0, 18266 HDA_AMP_MUTE, bits); 18267 snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1, 18268 HDA_AMP_MUTE, bits); 18269} 18270 18271static void alc662_f5z_speaker_automute(struct hda_codec *codec) 18272{ 18273 unsigned int present; 18274 unsigned char bits; 18275 18276 present = snd_hda_jack_detect(codec, 0x1b); 18277 bits = present ? 0 : PIN_OUT; 18278 snd_hda_codec_write(codec, 0x14, 0, 18279 AC_VERB_SET_PIN_WIDGET_CONTROL, bits); 18280} 18281 18282static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec) 18283{ 18284 unsigned int present1, present2; 18285 18286 present1 = snd_hda_jack_detect(codec, 0x21); 18287 present2 = snd_hda_jack_detect(codec, 0x15); 18288 18289 if (present1 || present2) { 18290 snd_hda_codec_write_cache(codec, 0x14, 0, 18291 AC_VERB_SET_PIN_WIDGET_CONTROL, 0); 18292 } else { 18293 snd_hda_codec_write_cache(codec, 0x14, 0, 18294 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 18295 } 18296} 18297 18298static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec) 18299{ 18300 unsigned int present1, present2; 18301 18302 present1 = snd_hda_jack_detect(codec, 0x1b); 18303 present2 = snd_hda_jack_detect(codec, 0x15); 18304 18305 if (present1 || present2) { 18306 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 18307 HDA_AMP_MUTE, HDA_AMP_MUTE); 18308 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 18309 HDA_AMP_MUTE, HDA_AMP_MUTE); 18310 } else { 18311 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 18312 HDA_AMP_MUTE, 0); 18313 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 18314 HDA_AMP_MUTE, 0); 18315 } 18316} 18317 18318static void alc663_two_hp_m7_speaker_automute(struct hda_codec *codec) 18319{ 18320 unsigned int present1, present2; 18321 18322 present1 = snd_hda_codec_read(codec, 0x1b, 0, 18323 AC_VERB_GET_PIN_SENSE, 0) 18324 & AC_PINSENSE_PRESENCE; 18325 present2 = snd_hda_codec_read(codec, 0x21, 0, 18326 AC_VERB_GET_PIN_SENSE, 0) 18327 & AC_PINSENSE_PRESENCE; 18328 18329 if (present1 || present2) { 18330 snd_hda_codec_write_cache(codec, 0x14, 0, 18331 AC_VERB_SET_PIN_WIDGET_CONTROL, 0); 18332 snd_hda_codec_write_cache(codec, 0x17, 0, 18333 AC_VERB_SET_PIN_WIDGET_CONTROL, 0); 18334 } else { 18335 snd_hda_codec_write_cache(codec, 0x14, 0, 18336 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 18337 snd_hda_codec_write_cache(codec, 0x17, 0, 18338 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 18339 } 18340} 18341 18342static void alc663_two_hp_m8_speaker_automute(struct hda_codec *codec) 18343{ 18344 unsigned int present1, present2; 18345 18346 present1 = snd_hda_codec_read(codec, 0x21, 0, 18347 AC_VERB_GET_PIN_SENSE, 0) 18348 & AC_PINSENSE_PRESENCE; 18349 present2 = snd_hda_codec_read(codec, 0x15, 0, 18350 AC_VERB_GET_PIN_SENSE, 0) 18351 & AC_PINSENSE_PRESENCE; 18352 18353 if (present1 || present2) { 18354 snd_hda_codec_write_cache(codec, 0x14, 0, 18355 AC_VERB_SET_PIN_WIDGET_CONTROL, 0); 18356 snd_hda_codec_write_cache(codec, 0x17, 0, 18357 AC_VERB_SET_PIN_WIDGET_CONTROL, 0); 18358 } else { 18359 snd_hda_codec_write_cache(codec, 0x14, 0, 18360 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 18361 snd_hda_codec_write_cache(codec, 0x17, 0, 18362 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 18363 } 18364} 18365 18366static void alc663_m51va_unsol_event(struct hda_codec *codec, 18367 unsigned int res) 18368{ 18369 switch (res >> 26) { 18370 case ALC880_HP_EVENT: 18371 alc663_m51va_speaker_automute(codec); 18372 break; 18373 case ALC880_MIC_EVENT: 18374 alc_mic_automute(codec); 18375 break; 18376 } 18377} 18378 18379static void alc663_m51va_setup(struct hda_codec *codec) 18380{ 18381 struct alc_spec *spec = codec->spec; 18382 spec->ext_mic.pin = 0x18; 18383 spec->ext_mic.mux_idx = 0; 18384 spec->int_mic.pin = 0x12; 18385 spec->int_mic.mux_idx = 9; 18386 spec->auto_mic = 1; 18387} 18388 18389static void alc663_m51va_inithook(struct hda_codec *codec) 18390{ 18391 alc663_m51va_speaker_automute(codec); 18392 alc_mic_automute(codec); 18393} 18394 18395/* ***************** Mode1 ******************************/ 18396#define alc663_mode1_unsol_event alc663_m51va_unsol_event 18397 18398static void alc663_mode1_setup(struct hda_codec *codec) 18399{ 18400 struct alc_spec *spec = codec->spec; 18401 spec->ext_mic.pin = 0x18; 18402 spec->ext_mic.mux_idx = 0; 18403 spec->int_mic.pin = 0x19; 18404 spec->int_mic.mux_idx = 1; 18405 spec->auto_mic = 1; 18406} 18407 18408#define alc663_mode1_inithook alc663_m51va_inithook 18409 18410/* ***************** Mode2 ******************************/ 18411static void alc662_mode2_unsol_event(struct hda_codec *codec, 18412 unsigned int res) 18413{ 18414 switch (res >> 26) { 18415 case ALC880_HP_EVENT: 18416 alc662_f5z_speaker_automute(codec); 18417 break; 18418 case ALC880_MIC_EVENT: 18419 alc_mic_automute(codec); 18420 break; 18421 } 18422} 18423 18424#define alc662_mode2_setup alc663_mode1_setup 18425 18426static void alc662_mode2_inithook(struct hda_codec *codec) 18427{ 18428 alc662_f5z_speaker_automute(codec); 18429 alc_mic_automute(codec); 18430} 18431/* ***************** Mode3 ******************************/ 18432static void alc663_mode3_unsol_event(struct hda_codec *codec, 18433 unsigned int res) 18434{ 18435 switch (res >> 26) { 18436 case ALC880_HP_EVENT: 18437 alc663_two_hp_m1_speaker_automute(codec); 18438 break; 18439 case ALC880_MIC_EVENT: 18440 alc_mic_automute(codec); 18441 break; 18442 } 18443} 18444 18445#define alc663_mode3_setup alc663_mode1_setup 18446 18447static void alc663_mode3_inithook(struct hda_codec *codec) 18448{ 18449 alc663_two_hp_m1_speaker_automute(codec); 18450 alc_mic_automute(codec); 18451} 18452/* ***************** Mode4 ******************************/ 18453static void alc663_mode4_unsol_event(struct hda_codec *codec, 18454 unsigned int res) 18455{ 18456 switch (res >> 26) { 18457 case ALC880_HP_EVENT: 18458 alc663_21jd_two_speaker_automute(codec); 18459 break; 18460 case ALC880_MIC_EVENT: 18461 alc_mic_automute(codec); 18462 break; 18463 } 18464} 18465 18466#define alc663_mode4_setup alc663_mode1_setup 18467 18468static void alc663_mode4_inithook(struct hda_codec *codec) 18469{ 18470 alc663_21jd_two_speaker_automute(codec); 18471 alc_mic_automute(codec); 18472} 18473/* ***************** Mode5 ******************************/ 18474static void alc663_mode5_unsol_event(struct hda_codec *codec, 18475 unsigned int res) 18476{ 18477 switch (res >> 26) { 18478 case ALC880_HP_EVENT: 18479 alc663_15jd_two_speaker_automute(codec); 18480 break; 18481 case ALC880_MIC_EVENT: 18482 alc_mic_automute(codec); 18483 break; 18484 } 18485} 18486 18487#define alc663_mode5_setup alc663_mode1_setup 18488 18489static void alc663_mode5_inithook(struct hda_codec *codec) 18490{ 18491 alc663_15jd_two_speaker_automute(codec); 18492 alc_mic_automute(codec); 18493} 18494/* ***************** Mode6 ******************************/ 18495static void alc663_mode6_unsol_event(struct hda_codec *codec, 18496 unsigned int res) 18497{ 18498 switch (res >> 26) { 18499 case ALC880_HP_EVENT: 18500 alc663_two_hp_m2_speaker_automute(codec); 18501 break; 18502 case ALC880_MIC_EVENT: 18503 alc_mic_automute(codec); 18504 break; 18505 } 18506} 18507 18508#define alc663_mode6_setup alc663_mode1_setup 18509 18510static void alc663_mode6_inithook(struct hda_codec *codec) 18511{ 18512 alc663_two_hp_m2_speaker_automute(codec); 18513 alc_mic_automute(codec); 18514} 18515 18516/* ***************** Mode7 ******************************/ 18517static void alc663_mode7_unsol_event(struct hda_codec *codec, 18518 unsigned int res) 18519{ 18520 switch (res >> 26) { 18521 case ALC880_HP_EVENT: 18522 alc663_two_hp_m7_speaker_automute(codec); 18523 break; 18524 case ALC880_MIC_EVENT: 18525 alc_mic_automute(codec); 18526 break; 18527 } 18528} 18529 18530#define alc663_mode7_setup alc663_mode1_setup 18531 18532static void alc663_mode7_inithook(struct hda_codec *codec) 18533{ 18534 alc663_two_hp_m7_speaker_automute(codec); 18535 alc_mic_automute(codec); 18536} 18537 18538/* ***************** Mode8 ******************************/ 18539static void alc663_mode8_unsol_event(struct hda_codec *codec, 18540 unsigned int res) 18541{ 18542 switch (res >> 26) { 18543 case ALC880_HP_EVENT: 18544 alc663_two_hp_m8_speaker_automute(codec); 18545 break; 18546 case ALC880_MIC_EVENT: 18547 alc_mic_automute(codec); 18548 break; 18549 } 18550} 18551 18552#define alc663_mode8_setup alc663_m51va_setup 18553 18554static void alc663_mode8_inithook(struct hda_codec *codec) 18555{ 18556 alc663_two_hp_m8_speaker_automute(codec); 18557 alc_mic_automute(codec); 18558} 18559 18560static void alc663_g71v_hp_automute(struct hda_codec *codec) 18561{ 18562 unsigned int present; 18563 unsigned char bits; 18564 18565 present = snd_hda_jack_detect(codec, 0x21); 18566 bits = present ? HDA_AMP_MUTE : 0; 18567 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 18568 HDA_AMP_MUTE, bits); 18569 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 18570 HDA_AMP_MUTE, bits); 18571} 18572 18573static void alc663_g71v_front_automute(struct hda_codec *codec) 18574{ 18575 unsigned int present; 18576 unsigned char bits; 18577 18578 present = snd_hda_jack_detect(codec, 0x15); 18579 bits = present ? HDA_AMP_MUTE : 0; 18580 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 18581 HDA_AMP_MUTE, bits); 18582} 18583 18584static void alc663_g71v_unsol_event(struct hda_codec *codec, 18585 unsigned int res) 18586{ 18587 switch (res >> 26) { 18588 case ALC880_HP_EVENT: 18589 alc663_g71v_hp_automute(codec); 18590 break; 18591 case ALC880_FRONT_EVENT: 18592 alc663_g71v_front_automute(codec); 18593 break; 18594 case ALC880_MIC_EVENT: 18595 alc_mic_automute(codec); 18596 break; 18597 } 18598} 18599 18600#define alc663_g71v_setup alc663_m51va_setup 18601 18602static void alc663_g71v_inithook(struct hda_codec *codec) 18603{ 18604 alc663_g71v_front_automute(codec); 18605 alc663_g71v_hp_automute(codec); 18606 alc_mic_automute(codec); 18607} 18608 18609static void alc663_g50v_unsol_event(struct hda_codec *codec, 18610 unsigned int res) 18611{ 18612 switch (res >> 26) { 18613 case ALC880_HP_EVENT: 18614 alc663_m51va_speaker_automute(codec); 18615 break; 18616 case ALC880_MIC_EVENT: 18617 alc_mic_automute(codec); 18618 break; 18619 } 18620} 18621 18622#define alc663_g50v_setup alc663_m51va_setup 18623 18624static void alc663_g50v_inithook(struct hda_codec *codec) 18625{ 18626 alc663_m51va_speaker_automute(codec); 18627 alc_mic_automute(codec); 18628} 18629 18630static struct snd_kcontrol_new alc662_ecs_mixer[] = { 18631 HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT), 18632 ALC262_HIPPO_MASTER_SWITCH, 18633 18634 HDA_CODEC_VOLUME("Mic/LineIn Boost Volume", 0x18, 0, HDA_INPUT), 18635 HDA_CODEC_VOLUME("Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT), 18636 HDA_CODEC_MUTE("Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT), 18637 18638 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT), 18639 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 18640 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 18641 { } /* end */ 18642}; 18643 18644static struct snd_kcontrol_new alc272_nc10_mixer[] = { 18645 /* Master Playback automatically created from Speaker and Headphone */ 18646 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 18647 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 18648 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 18649 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT), 18650 18651 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 18652 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 18653 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 18654 18655 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 18656 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 18657 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT), 18658 { } /* end */ 18659}; 18660 18661#ifdef CONFIG_SND_HDA_POWER_SAVE 18662#define alc662_loopbacks alc880_loopbacks 18663#endif 18664 18665 18666/* pcm configuration: identical with ALC880 */ 18667#define alc662_pcm_analog_playback alc880_pcm_analog_playback 18668#define alc662_pcm_analog_capture alc880_pcm_analog_capture 18669#define alc662_pcm_digital_playback alc880_pcm_digital_playback 18670#define alc662_pcm_digital_capture alc880_pcm_digital_capture 18671 18672/* 18673 * configuration and preset 18674 */ 18675static const char * const alc662_models[ALC662_MODEL_LAST] = { 18676 [ALC662_3ST_2ch_DIG] = "3stack-dig", 18677 [ALC662_3ST_6ch_DIG] = "3stack-6ch-dig", 18678 [ALC662_3ST_6ch] = "3stack-6ch", 18679 [ALC662_5ST_DIG] = "6stack-dig", 18680 [ALC662_LENOVO_101E] = "lenovo-101e", 18681 [ALC662_ASUS_EEEPC_P701] = "eeepc-p701", 18682 [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20", 18683 [ALC662_ECS] = "ecs", 18684 [ALC663_ASUS_M51VA] = "m51va", 18685 [ALC663_ASUS_G71V] = "g71v", 18686 [ALC663_ASUS_H13] = "h13", 18687 [ALC663_ASUS_G50V] = "g50v", 18688 [ALC663_ASUS_MODE1] = "asus-mode1", 18689 [ALC662_ASUS_MODE2] = "asus-mode2", 18690 [ALC663_ASUS_MODE3] = "asus-mode3", 18691 [ALC663_ASUS_MODE4] = "asus-mode4", 18692 [ALC663_ASUS_MODE5] = "asus-mode5", 18693 [ALC663_ASUS_MODE6] = "asus-mode6", 18694 [ALC663_ASUS_MODE7] = "asus-mode7", 18695 [ALC663_ASUS_MODE8] = "asus-mode8", 18696 [ALC272_DELL] = "dell", 18697 [ALC272_DELL_ZM1] = "dell-zm1", 18698 [ALC272_SAMSUNG_NC10] = "samsung-nc10", 18699 [ALC662_AUTO] = "auto", 18700}; 18701 18702static struct snd_pci_quirk alc662_cfg_tbl[] = { 18703 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS), 18704 SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL), 18705 SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1), 18706 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1), 18707 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3), 18708 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC663_ASUS_MODE1), 18709 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3), 18710 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1), 18711 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2), 18712 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1), 18713 SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC663_ASUS_MODE1), 18714 SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC663_ASUS_MODE1), 18715 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2), 18716 SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC663_ASUS_MODE7), 18717 SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC663_ASUS_MODE7), 18718 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC663_ASUS_MODE8), 18719 SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC663_ASUS_MODE3), 18720 SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC663_ASUS_MODE1), 18721 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2), 18722 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_ASUS_MODE2), 18723 SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC663_ASUS_MODE1), 18724 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2), 18725 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6), 18726 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6), 18727 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2), 18728 SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC663_ASUS_MODE1), 18729 SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3), 18730 SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA), 18731 SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2), 18732 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2), 18733 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5), 18734 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6), 18735 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2), 18736 SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1), 18737 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2), 18738 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2), 18739 SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA), 18740 /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/ 18741 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3), 18742 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3), 18743 SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1), 18744 SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC663_ASUS_MODE1), 18745 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1), 18746 SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1), 18747 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1), 18748 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2), 18749 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2), 18750 SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1), 18751 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1), 18752 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3), 18753 SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1), 18754 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1), 18755 SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V), 18756 /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/ 18757 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1), 18758 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2), 18759 SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA), 18760 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1), 18761 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4), 18762 SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG), 18763 SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701), 18764 SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20), 18765 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS), 18766 SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K", 18767 ALC662_3ST_6ch_DIG), 18768 SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB20x", ALC662_AUTO), 18769 SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10), 18770 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L", 18771 ALC662_3ST_6ch_DIG), 18772 SND_PCI_QUIRK(0x152d, 0x2304, "Quanta WH1", ALC663_ASUS_H13), 18773 SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG), 18774 SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA), 18775 SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E), 18776 SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0", 18777 ALC662_3ST_6ch_DIG), 18778 SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x", 18779 ALC663_ASUS_H13), 18780 SND_PCI_QUIRK(0x1991, 0x5628, "Ordissimo EVE", ALC662_LENOVO_101E), 18781 {} 18782}; 18783 18784static struct alc_config_preset alc662_presets[] = { 18785 [ALC662_3ST_2ch_DIG] = { 18786 .mixers = { alc662_3ST_2ch_mixer }, 18787 .init_verbs = { alc662_init_verbs }, 18788 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 18789 .dac_nids = alc662_dac_nids, 18790 .dig_out_nid = ALC662_DIGOUT_NID, 18791 .dig_in_nid = ALC662_DIGIN_NID, 18792 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 18793 .channel_mode = alc662_3ST_2ch_modes, 18794 .input_mux = &alc662_capture_source, 18795 }, 18796 [ALC662_3ST_6ch_DIG] = { 18797 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer }, 18798 .init_verbs = { alc662_init_verbs }, 18799 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 18800 .dac_nids = alc662_dac_nids, 18801 .dig_out_nid = ALC662_DIGOUT_NID, 18802 .dig_in_nid = ALC662_DIGIN_NID, 18803 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes), 18804 .channel_mode = alc662_3ST_6ch_modes, 18805 .need_dac_fix = 1, 18806 .input_mux = &alc662_capture_source, 18807 }, 18808 [ALC662_3ST_6ch] = { 18809 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer }, 18810 .init_verbs = { alc662_init_verbs }, 18811 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 18812 .dac_nids = alc662_dac_nids, 18813 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes), 18814 .channel_mode = alc662_3ST_6ch_modes, 18815 .need_dac_fix = 1, 18816 .input_mux = &alc662_capture_source, 18817 }, 18818 [ALC662_5ST_DIG] = { 18819 .mixers = { alc662_base_mixer, alc662_chmode_mixer }, 18820 .init_verbs = { alc662_init_verbs }, 18821 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 18822 .dac_nids = alc662_dac_nids, 18823 .dig_out_nid = ALC662_DIGOUT_NID, 18824 .dig_in_nid = ALC662_DIGIN_NID, 18825 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes), 18826 .channel_mode = alc662_5stack_modes, 18827 .input_mux = &alc662_capture_source, 18828 }, 18829 [ALC662_LENOVO_101E] = { 18830 .mixers = { alc662_lenovo_101e_mixer }, 18831 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs }, 18832 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 18833 .dac_nids = alc662_dac_nids, 18834 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 18835 .channel_mode = alc662_3ST_2ch_modes, 18836 .input_mux = &alc662_lenovo_101e_capture_source, 18837 .unsol_event = alc662_lenovo_101e_unsol_event, 18838 .init_hook = alc662_lenovo_101e_all_automute, 18839 }, 18840 [ALC662_ASUS_EEEPC_P701] = { 18841 .mixers = { alc662_eeepc_p701_mixer }, 18842 .init_verbs = { alc662_init_verbs, 18843 alc662_eeepc_sue_init_verbs }, 18844 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 18845 .dac_nids = alc662_dac_nids, 18846 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 18847 .channel_mode = alc662_3ST_2ch_modes, 18848 .unsol_event = alc662_eeepc_unsol_event, 18849 .setup = alc662_eeepc_setup, 18850 .init_hook = alc662_eeepc_inithook, 18851 }, 18852 [ALC662_ASUS_EEEPC_EP20] = { 18853 .mixers = { alc662_eeepc_ep20_mixer, 18854 alc662_chmode_mixer }, 18855 .init_verbs = { alc662_init_verbs, 18856 alc662_eeepc_ep20_sue_init_verbs }, 18857 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 18858 .dac_nids = alc662_dac_nids, 18859 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes), 18860 .channel_mode = alc662_3ST_6ch_modes, 18861 .input_mux = &alc662_lenovo_101e_capture_source, 18862 .unsol_event = alc662_eeepc_unsol_event, 18863 .setup = alc662_eeepc_ep20_setup, 18864 .init_hook = alc662_eeepc_ep20_inithook, 18865 }, 18866 [ALC662_ECS] = { 18867 .mixers = { alc662_ecs_mixer }, 18868 .init_verbs = { alc662_init_verbs, 18869 alc662_ecs_init_verbs }, 18870 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 18871 .dac_nids = alc662_dac_nids, 18872 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 18873 .channel_mode = alc662_3ST_2ch_modes, 18874 .unsol_event = alc662_eeepc_unsol_event, 18875 .setup = alc662_eeepc_setup, 18876 .init_hook = alc662_eeepc_inithook, 18877 }, 18878 [ALC663_ASUS_M51VA] = { 18879 .mixers = { alc663_m51va_mixer }, 18880 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs }, 18881 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 18882 .dac_nids = alc662_dac_nids, 18883 .dig_out_nid = ALC662_DIGOUT_NID, 18884 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 18885 .channel_mode = alc662_3ST_2ch_modes, 18886 .unsol_event = alc663_m51va_unsol_event, 18887 .setup = alc663_m51va_setup, 18888 .init_hook = alc663_m51va_inithook, 18889 }, 18890 [ALC663_ASUS_G71V] = { 18891 .mixers = { alc663_g71v_mixer }, 18892 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs }, 18893 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 18894 .dac_nids = alc662_dac_nids, 18895 .dig_out_nid = ALC662_DIGOUT_NID, 18896 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 18897 .channel_mode = alc662_3ST_2ch_modes, 18898 .unsol_event = alc663_g71v_unsol_event, 18899 .setup = alc663_g71v_setup, 18900 .init_hook = alc663_g71v_inithook, 18901 }, 18902 [ALC663_ASUS_H13] = { 18903 .mixers = { alc663_m51va_mixer }, 18904 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs }, 18905 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 18906 .dac_nids = alc662_dac_nids, 18907 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 18908 .channel_mode = alc662_3ST_2ch_modes, 18909 .unsol_event = alc663_m51va_unsol_event, 18910 .init_hook = alc663_m51va_inithook, 18911 }, 18912 [ALC663_ASUS_G50V] = { 18913 .mixers = { alc663_g50v_mixer }, 18914 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs }, 18915 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 18916 .dac_nids = alc662_dac_nids, 18917 .dig_out_nid = ALC662_DIGOUT_NID, 18918 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes), 18919 .channel_mode = alc662_3ST_6ch_modes, 18920 .input_mux = &alc663_capture_source, 18921 .unsol_event = alc663_g50v_unsol_event, 18922 .setup = alc663_g50v_setup, 18923 .init_hook = alc663_g50v_inithook, 18924 }, 18925 [ALC663_ASUS_MODE1] = { 18926 .mixers = { alc663_m51va_mixer }, 18927 .cap_mixer = alc662_auto_capture_mixer, 18928 .init_verbs = { alc662_init_verbs, 18929 alc663_21jd_amic_init_verbs }, 18930 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 18931 .hp_nid = 0x03, 18932 .dac_nids = alc662_dac_nids, 18933 .dig_out_nid = ALC662_DIGOUT_NID, 18934 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 18935 .channel_mode = alc662_3ST_2ch_modes, 18936 .unsol_event = alc663_mode1_unsol_event, 18937 .setup = alc663_mode1_setup, 18938 .init_hook = alc663_mode1_inithook, 18939 }, 18940 [ALC662_ASUS_MODE2] = { 18941 .mixers = { alc662_1bjd_mixer }, 18942 .cap_mixer = alc662_auto_capture_mixer, 18943 .init_verbs = { alc662_init_verbs, 18944 alc662_1bjd_amic_init_verbs }, 18945 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 18946 .dac_nids = alc662_dac_nids, 18947 .dig_out_nid = ALC662_DIGOUT_NID, 18948 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 18949 .channel_mode = alc662_3ST_2ch_modes, 18950 .unsol_event = alc662_mode2_unsol_event, 18951 .setup = alc662_mode2_setup, 18952 .init_hook = alc662_mode2_inithook, 18953 }, 18954 [ALC663_ASUS_MODE3] = { 18955 .mixers = { alc663_two_hp_m1_mixer }, 18956 .cap_mixer = alc662_auto_capture_mixer, 18957 .init_verbs = { alc662_init_verbs, 18958 alc663_two_hp_amic_m1_init_verbs }, 18959 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 18960 .hp_nid = 0x03, 18961 .dac_nids = alc662_dac_nids, 18962 .dig_out_nid = ALC662_DIGOUT_NID, 18963 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 18964 .channel_mode = alc662_3ST_2ch_modes, 18965 .unsol_event = alc663_mode3_unsol_event, 18966 .setup = alc663_mode3_setup, 18967 .init_hook = alc663_mode3_inithook, 18968 }, 18969 [ALC663_ASUS_MODE4] = { 18970 .mixers = { alc663_asus_21jd_clfe_mixer }, 18971 .cap_mixer = alc662_auto_capture_mixer, 18972 .init_verbs = { alc662_init_verbs, 18973 alc663_21jd_amic_init_verbs}, 18974 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 18975 .hp_nid = 0x03, 18976 .dac_nids = alc662_dac_nids, 18977 .dig_out_nid = ALC662_DIGOUT_NID, 18978 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 18979 .channel_mode = alc662_3ST_2ch_modes, 18980 .unsol_event = alc663_mode4_unsol_event, 18981 .setup = alc663_mode4_setup, 18982 .init_hook = alc663_mode4_inithook, 18983 }, 18984 [ALC663_ASUS_MODE5] = { 18985 .mixers = { alc663_asus_15jd_clfe_mixer }, 18986 .cap_mixer = alc662_auto_capture_mixer, 18987 .init_verbs = { alc662_init_verbs, 18988 alc663_15jd_amic_init_verbs }, 18989 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 18990 .hp_nid = 0x03, 18991 .dac_nids = alc662_dac_nids, 18992 .dig_out_nid = ALC662_DIGOUT_NID, 18993 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 18994 .channel_mode = alc662_3ST_2ch_modes, 18995 .unsol_event = alc663_mode5_unsol_event, 18996 .setup = alc663_mode5_setup, 18997 .init_hook = alc663_mode5_inithook, 18998 }, 18999 [ALC663_ASUS_MODE6] = { 19000 .mixers = { alc663_two_hp_m2_mixer }, 19001 .cap_mixer = alc662_auto_capture_mixer, 19002 .init_verbs = { alc662_init_verbs, 19003 alc663_two_hp_amic_m2_init_verbs }, 19004 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 19005 .hp_nid = 0x03, 19006 .dac_nids = alc662_dac_nids, 19007 .dig_out_nid = ALC662_DIGOUT_NID, 19008 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 19009 .channel_mode = alc662_3ST_2ch_modes, 19010 .unsol_event = alc663_mode6_unsol_event, 19011 .setup = alc663_mode6_setup, 19012 .init_hook = alc663_mode6_inithook, 19013 }, 19014 [ALC663_ASUS_MODE7] = { 19015 .mixers = { alc663_mode7_mixer }, 19016 .cap_mixer = alc662_auto_capture_mixer, 19017 .init_verbs = { alc662_init_verbs, 19018 alc663_mode7_init_verbs }, 19019 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 19020 .hp_nid = 0x03, 19021 .dac_nids = alc662_dac_nids, 19022 .dig_out_nid = ALC662_DIGOUT_NID, 19023 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 19024 .channel_mode = alc662_3ST_2ch_modes, 19025 .unsol_event = alc663_mode7_unsol_event, 19026 .setup = alc663_mode7_setup, 19027 .init_hook = alc663_mode7_inithook, 19028 }, 19029 [ALC663_ASUS_MODE8] = { 19030 .mixers = { alc663_mode8_mixer }, 19031 .cap_mixer = alc662_auto_capture_mixer, 19032 .init_verbs = { alc662_init_verbs, 19033 alc663_mode8_init_verbs }, 19034 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 19035 .hp_nid = 0x03, 19036 .dac_nids = alc662_dac_nids, 19037 .dig_out_nid = ALC662_DIGOUT_NID, 19038 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 19039 .channel_mode = alc662_3ST_2ch_modes, 19040 .unsol_event = alc663_mode8_unsol_event, 19041 .setup = alc663_mode8_setup, 19042 .init_hook = alc663_mode8_inithook, 19043 }, 19044 [ALC272_DELL] = { 19045 .mixers = { alc663_m51va_mixer }, 19046 .cap_mixer = alc272_auto_capture_mixer, 19047 .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs }, 19048 .num_dacs = ARRAY_SIZE(alc272_dac_nids), 19049 .dac_nids = alc662_dac_nids, 19050 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 19051 .adc_nids = alc272_adc_nids, 19052 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids), 19053 .capsrc_nids = alc272_capsrc_nids, 19054 .channel_mode = alc662_3ST_2ch_modes, 19055 .unsol_event = alc663_m51va_unsol_event, 19056 .setup = alc663_m51va_setup, 19057 .init_hook = alc663_m51va_inithook, 19058 }, 19059 [ALC272_DELL_ZM1] = { 19060 .mixers = { alc663_m51va_mixer }, 19061 .cap_mixer = alc662_auto_capture_mixer, 19062 .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs }, 19063 .num_dacs = ARRAY_SIZE(alc272_dac_nids), 19064 .dac_nids = alc662_dac_nids, 19065 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 19066 .adc_nids = alc662_adc_nids, 19067 .num_adc_nids = 1, 19068 .capsrc_nids = alc662_capsrc_nids, 19069 .channel_mode = alc662_3ST_2ch_modes, 19070 .unsol_event = alc663_m51va_unsol_event, 19071 .setup = alc663_m51va_setup, 19072 .init_hook = alc663_m51va_inithook, 19073 }, 19074 [ALC272_SAMSUNG_NC10] = { 19075 .mixers = { alc272_nc10_mixer }, 19076 .init_verbs = { alc662_init_verbs, 19077 alc663_21jd_amic_init_verbs }, 19078 .num_dacs = ARRAY_SIZE(alc272_dac_nids), 19079 .dac_nids = alc272_dac_nids, 19080 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 19081 .channel_mode = alc662_3ST_2ch_modes, 19082 /*.input_mux = &alc272_nc10_capture_source,*/ 19083 .unsol_event = alc663_mode4_unsol_event, 19084 .setup = alc663_mode4_setup, 19085 .init_hook = alc663_mode4_inithook, 19086 }, 19087}; 19088 19089 19090/* 19091 * BIOS auto configuration 19092 */ 19093 19094/* convert from MIX nid to DAC */ 19095static inline hda_nid_t alc662_mix_to_dac(hda_nid_t nid) 19096{ 19097 if (nid == 0x0f) 19098 return 0x02; 19099 else if (nid >= 0x0c && nid <= 0x0e) 19100 return nid - 0x0c + 0x02; 19101 else if (nid == 0x26) /* ALC887-VD has this DAC too */ 19102 return 0x25; 19103 else 19104 return 0; 19105} 19106 19107/* get MIX nid connected to the given pin targeted to DAC */ 19108static hda_nid_t alc662_dac_to_mix(struct hda_codec *codec, hda_nid_t pin, 19109 hda_nid_t dac) 19110{ 19111 hda_nid_t mix[5]; 19112 int i, num; 19113 19114 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix)); 19115 for (i = 0; i < num; i++) { 19116 if (alc662_mix_to_dac(mix[i]) == dac) 19117 return mix[i]; 19118 } 19119 return 0; 19120} 19121 19122/* look for an empty DAC slot */ 19123static hda_nid_t alc662_look_for_dac(struct hda_codec *codec, hda_nid_t pin) 19124{ 19125 struct alc_spec *spec = codec->spec; 19126 hda_nid_t srcs[5]; 19127 int i, j, num; 19128 19129 num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs)); 19130 if (num < 0) 19131 return 0; 19132 for (i = 0; i < num; i++) { 19133 hda_nid_t nid = alc662_mix_to_dac(srcs[i]); 19134 if (!nid) 19135 continue; 19136 for (j = 0; j < spec->multiout.num_dacs; j++) 19137 if (spec->multiout.dac_nids[j] == nid) 19138 break; 19139 if (j >= spec->multiout.num_dacs) 19140 return nid; 19141 } 19142 return 0; 19143} 19144 19145/* fill in the dac_nids table from the parsed pin configuration */ 19146static int alc662_auto_fill_dac_nids(struct hda_codec *codec, 19147 const struct auto_pin_cfg *cfg) 19148{ 19149 struct alc_spec *spec = codec->spec; 19150 int i; 19151 hda_nid_t dac; 19152 19153 spec->multiout.dac_nids = spec->private_dac_nids; 19154 for (i = 0; i < cfg->line_outs; i++) { 19155 dac = alc662_look_for_dac(codec, cfg->line_out_pins[i]); 19156 if (!dac) 19157 continue; 19158 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac; 19159 } 19160 return 0; 19161} 19162 19163static inline int __alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx, 19164 hda_nid_t nid, int idx, unsigned int chs) 19165{ 19166 return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx, 19167 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT)); 19168} 19169 19170static inline int __alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx, 19171 hda_nid_t nid, int idx, unsigned int chs) 19172{ 19173 return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx, 19174 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT)); 19175} 19176 19177#define alc662_add_vol_ctl(spec, pfx, nid, chs) \ 19178 __alc662_add_vol_ctl(spec, pfx, nid, 0, chs) 19179#define alc662_add_sw_ctl(spec, pfx, nid, chs) \ 19180 __alc662_add_sw_ctl(spec, pfx, nid, 0, chs) 19181#define alc662_add_stereo_vol(spec, pfx, nid) \ 19182 alc662_add_vol_ctl(spec, pfx, nid, 3) 19183#define alc662_add_stereo_sw(spec, pfx, nid) \ 19184 alc662_add_sw_ctl(spec, pfx, nid, 3) 19185 19186/* add playback controls from the parsed DAC table */ 19187static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec, 19188 const struct auto_pin_cfg *cfg) 19189{ 19190 struct alc_spec *spec = codec->spec; 19191 static const char * const chname[4] = { 19192 "Front", "Surround", NULL /*CLFE*/, "Side" 19193 }; 19194 const char *pfx = alc_get_line_out_pfx(cfg, true); 19195 hda_nid_t nid, mix; 19196 int i, err; 19197 19198 for (i = 0; i < cfg->line_outs; i++) { 19199 nid = spec->multiout.dac_nids[i]; 19200 if (!nid) 19201 continue; 19202 mix = alc662_dac_to_mix(codec, cfg->line_out_pins[i], nid); 19203 if (!mix) 19204 continue; 19205 if (!pfx && i == 2) { 19206 /* Center/LFE */ 19207 err = alc662_add_vol_ctl(spec, "Center", nid, 1); 19208 if (err < 0) 19209 return err; 19210 err = alc662_add_vol_ctl(spec, "LFE", nid, 2); 19211 if (err < 0) 19212 return err; 19213 err = alc662_add_sw_ctl(spec, "Center", mix, 1); 19214 if (err < 0) 19215 return err; 19216 err = alc662_add_sw_ctl(spec, "LFE", mix, 2); 19217 if (err < 0) 19218 return err; 19219 } else { 19220 const char *name = pfx; 19221 if (!name) 19222 name = chname[i]; 19223 err = __alc662_add_vol_ctl(spec, name, nid, i, 3); 19224 if (err < 0) 19225 return err; 19226 err = __alc662_add_sw_ctl(spec, name, mix, i, 3); 19227 if (err < 0) 19228 return err; 19229 } 19230 } 19231 return 0; 19232} 19233 19234/* add playback controls for speaker and HP outputs */ 19235/* return DAC nid if any new DAC is assigned */ 19236static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin, 19237 const char *pfx) 19238{ 19239 struct alc_spec *spec = codec->spec; 19240 hda_nid_t nid, mix; 19241 int err; 19242 19243 if (!pin) 19244 return 0; 19245 nid = alc662_look_for_dac(codec, pin); 19246 if (!nid) { 19247 /* the corresponding DAC is already occupied */ 19248 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP)) 19249 return 0; /* no way */ 19250 /* create a switch only */ 19251 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, 19252 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 19253 } 19254 19255 mix = alc662_dac_to_mix(codec, pin, nid); 19256 if (!mix) 19257 return 0; 19258 err = alc662_add_vol_ctl(spec, pfx, nid, 3); 19259 if (err < 0) 19260 return err; 19261 err = alc662_add_sw_ctl(spec, pfx, mix, 3); 19262 if (err < 0) 19263 return err; 19264 return nid; 19265} 19266 19267/* create playback/capture controls for input pins */ 19268#define alc662_auto_create_input_ctls \ 19269 alc882_auto_create_input_ctls 19270 19271static void alc662_auto_set_output_and_unmute(struct hda_codec *codec, 19272 hda_nid_t nid, int pin_type, 19273 hda_nid_t dac) 19274{ 19275 int i, num; 19276 hda_nid_t srcs[HDA_MAX_CONNECTIONS]; 19277 19278 alc_set_pin_output(codec, nid, pin_type); 19279 /* need the manual connection? */ 19280 num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs)); 19281 if (num <= 1) 19282 return; 19283 for (i = 0; i < num; i++) { 19284 if (alc662_mix_to_dac(srcs[i]) != dac) 19285 continue; 19286 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i); 19287 return; 19288 } 19289} 19290 19291static void alc662_auto_init_multi_out(struct hda_codec *codec) 19292{ 19293 struct alc_spec *spec = codec->spec; 19294 int pin_type = get_pin_type(spec->autocfg.line_out_type); 19295 int i; 19296 19297 for (i = 0; i <= HDA_SIDE; i++) { 19298 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 19299 if (nid) 19300 alc662_auto_set_output_and_unmute(codec, nid, pin_type, 19301 spec->multiout.dac_nids[i]); 19302 } 19303} 19304 19305static void alc662_auto_init_hp_out(struct hda_codec *codec) 19306{ 19307 struct alc_spec *spec = codec->spec; 19308 hda_nid_t pin; 19309 19310 pin = spec->autocfg.hp_pins[0]; 19311 if (pin) 19312 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 19313 spec->multiout.hp_nid); 19314 pin = spec->autocfg.speaker_pins[0]; 19315 if (pin) 19316 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 19317 spec->multiout.extra_out_nid[0]); 19318} 19319 19320#define ALC662_PIN_CD_NID ALC880_PIN_CD_NID 19321 19322static void alc662_auto_init_analog_input(struct hda_codec *codec) 19323{ 19324 struct alc_spec *spec = codec->spec; 19325 struct auto_pin_cfg *cfg = &spec->autocfg; 19326 int i; 19327 19328 for (i = 0; i < cfg->num_inputs; i++) { 19329 hda_nid_t nid = cfg->inputs[i].pin; 19330 if (alc_is_input_pin(codec, nid)) { 19331 alc_set_input_pin(codec, nid, cfg->inputs[i].type); 19332 if (nid != ALC662_PIN_CD_NID && 19333 (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)) 19334 snd_hda_codec_write(codec, nid, 0, 19335 AC_VERB_SET_AMP_GAIN_MUTE, 19336 AMP_OUT_MUTE); 19337 } 19338 } 19339} 19340 19341#define alc662_auto_init_input_src alc882_auto_init_input_src 19342 19343static int alc662_parse_auto_config(struct hda_codec *codec) 19344{ 19345 struct alc_spec *spec = codec->spec; 19346 int err; 19347 static hda_nid_t alc662_ignore[] = { 0x1d, 0 }; 19348 19349 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 19350 alc662_ignore); 19351 if (err < 0) 19352 return err; 19353 if (!spec->autocfg.line_outs) 19354 return 0; /* can't find valid BIOS pin config */ 19355 19356 err = alc662_auto_fill_dac_nids(codec, &spec->autocfg); 19357 if (err < 0) 19358 return err; 19359 err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg); 19360 if (err < 0) 19361 return err; 19362 err = alc662_auto_create_extra_out(codec, 19363 spec->autocfg.speaker_pins[0], 19364 "Speaker"); 19365 if (err < 0) 19366 return err; 19367 if (err) 19368 spec->multiout.extra_out_nid[0] = err; 19369 err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0], 19370 "Headphone"); 19371 if (err < 0) 19372 return err; 19373 if (err) 19374 spec->multiout.hp_nid = err; 19375 err = alc662_auto_create_input_ctls(codec, &spec->autocfg); 19376 if (err < 0) 19377 return err; 19378 19379 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 19380 19381 alc_auto_parse_digital(codec); 19382 19383 if (spec->kctls.list) 19384 add_mixer(spec, spec->kctls.list); 19385 19386 spec->num_mux_defs = 1; 19387 spec->input_mux = &spec->private_imux[0]; 19388 19389 add_verb(spec, alc662_init_verbs); 19390 if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 || 19391 codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670) 19392 add_verb(spec, alc663_init_verbs); 19393 19394 if (codec->vendor_id == 0x10ec0272) 19395 add_verb(spec, alc272_init_verbs); 19396 19397 err = alc_auto_add_mic_boost(codec); 19398 if (err < 0) 19399 return err; 19400 19401 if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 || 19402 codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670) 19403 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0x21); 19404 else 19405 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0); 19406 19407 return 1; 19408} 19409 19410/* additional initialization for auto-configuration model */ 19411static void alc662_auto_init(struct hda_codec *codec) 19412{ 19413 struct alc_spec *spec = codec->spec; 19414 alc662_auto_init_multi_out(codec); 19415 alc662_auto_init_hp_out(codec); 19416 alc662_auto_init_analog_input(codec); 19417 alc662_auto_init_input_src(codec); 19418 alc_auto_init_digital(codec); 19419 if (spec->unsol_event) 19420 alc_inithook(codec); 19421} 19422 19423static void alc272_fixup_mario(struct hda_codec *codec, 19424 const struct alc_fixup *fix, int action) 19425{ 19426 if (action != ALC_FIXUP_ACT_PROBE) 19427 return; 19428 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT, 19429 (0x3b << AC_AMPCAP_OFFSET_SHIFT) | 19430 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) | 19431 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) | 19432 (0 << AC_AMPCAP_MUTE_SHIFT))) 19433 printk(KERN_WARNING 19434 "hda_codec: failed to override amp caps for NID 0x2\n"); 19435} 19436 19437enum { 19438 ALC662_FIXUP_ASPIRE, 19439 ALC662_FIXUP_IDEAPAD, 19440 ALC272_FIXUP_MARIO, 19441 ALC662_FIXUP_CZC_P10T, 19442}; 19443 19444static const struct alc_fixup alc662_fixups[] = { 19445 [ALC662_FIXUP_ASPIRE] = { 19446 .type = ALC_FIXUP_PINS, 19447 .v.pins = (const struct alc_pincfg[]) { 19448 { 0x15, 0x99130112 }, /* subwoofer */ 19449 { } 19450 } 19451 }, 19452 [ALC662_FIXUP_IDEAPAD] = { 19453 .type = ALC_FIXUP_PINS, 19454 .v.pins = (const struct alc_pincfg[]) { 19455 { 0x17, 0x99130112 }, /* subwoofer */ 19456 { } 19457 } 19458 }, 19459 [ALC272_FIXUP_MARIO] = { 19460 .type = ALC_FIXUP_FUNC, 19461 .v.func = alc272_fixup_mario, 19462 }, 19463 [ALC662_FIXUP_CZC_P10T] = { 19464 .type = ALC_FIXUP_VERBS, 19465 .v.verbs = (const struct hda_verb[]) { 19466 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0}, 19467 {} 19468 } 19469 }, 19470}; 19471 19472static struct snd_pci_quirk alc662_fixup_tbl[] = { 19473 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE), 19474 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE), 19475 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD), 19476 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD), 19477 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD), 19478 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T), 19479 {} 19480}; 19481 19482static const struct alc_model_fixup alc662_fixup_models[] = { 19483 {.id = ALC272_FIXUP_MARIO, .name = "mario"}, 19484 {} 19485}; 19486 19487 19488static int patch_alc662(struct hda_codec *codec) 19489{ 19490 struct alc_spec *spec; 19491 int err, board_config; 19492 int coef; 19493 19494 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 19495 if (!spec) 19496 return -ENOMEM; 19497 19498 codec->spec = spec; 19499 19500 alc_auto_parse_customize_define(codec); 19501 19502 alc_fix_pll_init(codec, 0x20, 0x04, 15); 19503 19504 coef = alc_read_coef_idx(codec, 0); 19505 if (coef == 0x8020 || coef == 0x8011) 19506 alc_codec_rename(codec, "ALC661"); 19507 else if (coef & (1 << 14) && 19508 codec->bus->pci->subsystem_vendor == 0x1025 && 19509 spec->cdefine.platform_type == 1) 19510 alc_codec_rename(codec, "ALC272X"); 19511 else if (coef == 0x4011) 19512 alc_codec_rename(codec, "ALC656"); 19513 19514 board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST, 19515 alc662_models, 19516 alc662_cfg_tbl); 19517 if (board_config < 0) { 19518 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 19519 codec->chip_name); 19520 board_config = ALC662_AUTO; 19521 } 19522 19523 if (board_config == ALC662_AUTO) { 19524 alc_pick_fixup(codec, alc662_fixup_models, 19525 alc662_fixup_tbl, alc662_fixups); 19526 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE); 19527 /* automatic parse from the BIOS config */ 19528 err = alc662_parse_auto_config(codec); 19529 if (err < 0) { 19530 alc_free(codec); 19531 return err; 19532 } else if (!err) { 19533 printk(KERN_INFO 19534 "hda_codec: Cannot set up configuration " 19535 "from BIOS. Using base mode...\n"); 19536 board_config = ALC662_3ST_2ch_DIG; 19537 } 19538 } 19539 19540 if (has_cdefine_beep(codec)) { 19541 err = snd_hda_attach_beep_device(codec, 0x1); 19542 if (err < 0) { 19543 alc_free(codec); 19544 return err; 19545 } 19546 } 19547 19548 if (board_config != ALC662_AUTO) 19549 setup_preset(codec, &alc662_presets[board_config]); 19550 19551 spec->stream_analog_playback = &alc662_pcm_analog_playback; 19552 spec->stream_analog_capture = &alc662_pcm_analog_capture; 19553 19554 spec->stream_digital_playback = &alc662_pcm_digital_playback; 19555 spec->stream_digital_capture = &alc662_pcm_digital_capture; 19556 19557 if (!spec->adc_nids) { 19558 spec->adc_nids = alc662_adc_nids; 19559 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids); 19560 } 19561 if (!spec->capsrc_nids) 19562 spec->capsrc_nids = alc662_capsrc_nids; 19563 19564 if (!spec->cap_mixer) 19565 set_capture_mixer(codec); 19566 19567 if (has_cdefine_beep(codec)) { 19568 switch (codec->vendor_id) { 19569 case 0x10ec0662: 19570 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 19571 break; 19572 case 0x10ec0272: 19573 case 0x10ec0663: 19574 case 0x10ec0665: 19575 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT); 19576 break; 19577 case 0x10ec0273: 19578 set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT); 19579 break; 19580 } 19581 } 19582 spec->vmaster_nid = 0x02; 19583 19584 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE); 19585 19586 codec->patch_ops = alc_patch_ops; 19587 if (board_config == ALC662_AUTO) 19588 spec->init_hook = alc662_auto_init; 19589 19590 alc_init_jacks(codec); 19591 19592#ifdef CONFIG_SND_HDA_POWER_SAVE 19593 if (!spec->loopback.amplist) 19594 spec->loopback.amplist = alc662_loopbacks; 19595#endif 19596 19597 return 0; 19598} 19599 19600static int patch_alc888(struct hda_codec *codec) 19601{ 19602 if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){ 19603 kfree(codec->chip_name); 19604 if (codec->vendor_id == 0x10ec0887) 19605 codec->chip_name = kstrdup("ALC887-VD", GFP_KERNEL); 19606 else 19607 codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL); 19608 if (!codec->chip_name) { 19609 alc_free(codec); 19610 return -ENOMEM; 19611 } 19612 return patch_alc662(codec); 19613 } 19614 return patch_alc882(codec); 19615} 19616 19617/* 19618 * ALC680 support 19619 */ 19620#define ALC680_DIGIN_NID ALC880_DIGIN_NID 19621#define ALC680_DIGOUT_NID ALC880_DIGOUT_NID 19622#define alc680_modes alc260_modes 19623 19624static hda_nid_t alc680_dac_nids[3] = { 19625 /* Lout1, Lout2, hp */ 19626 0x02, 0x03, 0x04 19627}; 19628 19629static hda_nid_t alc680_adc_nids[3] = { 19630 /* ADC0-2 */ 19631 /* DMIC, MIC, Line-in*/ 19632 0x07, 0x08, 0x09 19633}; 19634 19635/* 19636 * Analog capture ADC cgange 19637 */ 19638static void alc680_rec_autoswitch(struct hda_codec *codec) 19639{ 19640 struct alc_spec *spec = codec->spec; 19641 struct auto_pin_cfg *cfg = &spec->autocfg; 19642 int pin_found = 0; 19643 int type_found = AUTO_PIN_LAST; 19644 hda_nid_t nid; 19645 int i; 19646 19647 for (i = 0; i < cfg->num_inputs; i++) { 19648 nid = cfg->inputs[i].pin; 19649 if (!(snd_hda_query_pin_caps(codec, nid) & 19650 AC_PINCAP_PRES_DETECT)) 19651 continue; 19652 if (snd_hda_jack_detect(codec, nid)) { 19653 if (cfg->inputs[i].type < type_found) { 19654 type_found = cfg->inputs[i].type; 19655 pin_found = nid; 19656 } 19657 } 19658 } 19659 19660 nid = 0x07; 19661 if (pin_found) 19662 snd_hda_get_connections(codec, pin_found, &nid, 1); 19663 19664 if (nid != spec->cur_adc) 19665 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1); 19666 spec->cur_adc = nid; 19667 snd_hda_codec_setup_stream(codec, nid, spec->cur_adc_stream_tag, 0, 19668 spec->cur_adc_format); 19669} 19670 19671static int alc680_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 19672 struct hda_codec *codec, 19673 unsigned int stream_tag, 19674 unsigned int format, 19675 struct snd_pcm_substream *substream) 19676{ 19677 struct alc_spec *spec = codec->spec; 19678 19679 spec->cur_adc = 0x07; 19680 spec->cur_adc_stream_tag = stream_tag; 19681 spec->cur_adc_format = format; 19682 19683 alc680_rec_autoswitch(codec); 19684 return 0; 19685} 19686 19687static int alc680_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 19688 struct hda_codec *codec, 19689 struct snd_pcm_substream *substream) 19690{ 19691 snd_hda_codec_cleanup_stream(codec, 0x07); 19692 snd_hda_codec_cleanup_stream(codec, 0x08); 19693 snd_hda_codec_cleanup_stream(codec, 0x09); 19694 return 0; 19695} 19696 19697static struct hda_pcm_stream alc680_pcm_analog_auto_capture = { 19698 .substreams = 1, /* can be overridden */ 19699 .channels_min = 2, 19700 .channels_max = 2, 19701 /* NID is set in alc_build_pcms */ 19702 .ops = { 19703 .prepare = alc680_capture_pcm_prepare, 19704 .cleanup = alc680_capture_pcm_cleanup 19705 }, 19706}; 19707 19708static struct snd_kcontrol_new alc680_base_mixer[] = { 19709 /* output mixer control */ 19710 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT), 19711 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 19712 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x4, 0x0, HDA_OUTPUT), 19713 HDA_CODEC_MUTE("Headphone Playback Switch", 0x16, 0x0, HDA_OUTPUT), 19714 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x12, 0, HDA_INPUT), 19715 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT), 19716 HDA_CODEC_VOLUME("Line In Boost Volume", 0x19, 0, HDA_INPUT), 19717 { } 19718}; 19719 19720static struct hda_bind_ctls alc680_bind_cap_vol = { 19721 .ops = &snd_hda_bind_vol, 19722 .values = { 19723 HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT), 19724 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT), 19725 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT), 19726 0 19727 }, 19728}; 19729 19730static struct hda_bind_ctls alc680_bind_cap_switch = { 19731 .ops = &snd_hda_bind_sw, 19732 .values = { 19733 HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT), 19734 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT), 19735 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT), 19736 0 19737 }, 19738}; 19739 19740static struct snd_kcontrol_new alc680_master_capture_mixer[] = { 19741 HDA_BIND_VOL("Capture Volume", &alc680_bind_cap_vol), 19742 HDA_BIND_SW("Capture Switch", &alc680_bind_cap_switch), 19743 { } /* end */ 19744}; 19745 19746/* 19747 * generic initialization of ADC, input mixers and output mixers 19748 */ 19749static struct hda_verb alc680_init_verbs[] = { 19750 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 19751 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 19752 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 19753 19754 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 19755 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 19756 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 19757 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 19758 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 19759 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 19760 19761 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 19762 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 19763 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 19764 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 19765 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 19766 19767 {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 19768 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, 19769 {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, 19770 19771 { } 19772}; 19773 19774/* toggle speaker-output according to the hp-jack state */ 19775static void alc680_base_setup(struct hda_codec *codec) 19776{ 19777 struct alc_spec *spec = codec->spec; 19778 19779 spec->autocfg.hp_pins[0] = 0x16; 19780 spec->autocfg.speaker_pins[0] = 0x14; 19781 spec->autocfg.speaker_pins[1] = 0x15; 19782 spec->autocfg.num_inputs = 2; 19783 spec->autocfg.inputs[0].pin = 0x18; 19784 spec->autocfg.inputs[0].type = AUTO_PIN_MIC; 19785 spec->autocfg.inputs[1].pin = 0x19; 19786 spec->autocfg.inputs[1].type = AUTO_PIN_LINE_IN; 19787} 19788 19789static void alc680_unsol_event(struct hda_codec *codec, 19790 unsigned int res) 19791{ 19792 if ((res >> 26) == ALC880_HP_EVENT) 19793 alc_automute_amp(codec); 19794 if ((res >> 26) == ALC880_MIC_EVENT) 19795 alc680_rec_autoswitch(codec); 19796} 19797 19798static void alc680_inithook(struct hda_codec *codec) 19799{ 19800 alc_automute_amp(codec); 19801 alc680_rec_autoswitch(codec); 19802} 19803 19804/* create input playback/capture controls for the given pin */ 19805static int alc680_new_analog_output(struct alc_spec *spec, hda_nid_t nid, 19806 const char *ctlname, int idx) 19807{ 19808 hda_nid_t dac; 19809 int err; 19810 19811 switch (nid) { 19812 case 0x14: 19813 dac = 0x02; 19814 break; 19815 case 0x15: 19816 dac = 0x03; 19817 break; 19818 case 0x16: 19819 dac = 0x04; 19820 break; 19821 default: 19822 return 0; 19823 } 19824 if (spec->multiout.dac_nids[0] != dac && 19825 spec->multiout.dac_nids[1] != dac) { 19826 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, 19827 HDA_COMPOSE_AMP_VAL(dac, 3, idx, 19828 HDA_OUTPUT)); 19829 if (err < 0) 19830 return err; 19831 19832 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, 19833 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT)); 19834 19835 if (err < 0) 19836 return err; 19837 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac; 19838 } 19839 19840 return 0; 19841} 19842 19843/* add playback controls from the parsed DAC table */ 19844static int alc680_auto_create_multi_out_ctls(struct alc_spec *spec, 19845 const struct auto_pin_cfg *cfg) 19846{ 19847 hda_nid_t nid; 19848 int err; 19849 19850 spec->multiout.dac_nids = spec->private_dac_nids; 19851 19852 nid = cfg->line_out_pins[0]; 19853 if (nid) { 19854 const char *name; 19855 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) 19856 name = "Speaker"; 19857 else 19858 name = "Front"; 19859 err = alc680_new_analog_output(spec, nid, name, 0); 19860 if (err < 0) 19861 return err; 19862 } 19863 19864 nid = cfg->speaker_pins[0]; 19865 if (nid) { 19866 err = alc680_new_analog_output(spec, nid, "Speaker", 0); 19867 if (err < 0) 19868 return err; 19869 } 19870 nid = cfg->hp_pins[0]; 19871 if (nid) { 19872 err = alc680_new_analog_output(spec, nid, "Headphone", 0); 19873 if (err < 0) 19874 return err; 19875 } 19876 19877 return 0; 19878} 19879 19880static void alc680_auto_set_output_and_unmute(struct hda_codec *codec, 19881 hda_nid_t nid, int pin_type) 19882{ 19883 alc_set_pin_output(codec, nid, pin_type); 19884} 19885 19886static void alc680_auto_init_multi_out(struct hda_codec *codec) 19887{ 19888 struct alc_spec *spec = codec->spec; 19889 hda_nid_t nid = spec->autocfg.line_out_pins[0]; 19890 if (nid) { 19891 int pin_type = get_pin_type(spec->autocfg.line_out_type); 19892 alc680_auto_set_output_and_unmute(codec, nid, pin_type); 19893 } 19894} 19895 19896static void alc680_auto_init_hp_out(struct hda_codec *codec) 19897{ 19898 struct alc_spec *spec = codec->spec; 19899 hda_nid_t pin; 19900 19901 pin = spec->autocfg.hp_pins[0]; 19902 if (pin) 19903 alc680_auto_set_output_and_unmute(codec, pin, PIN_HP); 19904 pin = spec->autocfg.speaker_pins[0]; 19905 if (pin) 19906 alc680_auto_set_output_and_unmute(codec, pin, PIN_OUT); 19907} 19908 19909/* pcm configuration: identical with ALC880 */ 19910#define alc680_pcm_analog_playback alc880_pcm_analog_playback 19911#define alc680_pcm_analog_capture alc880_pcm_analog_capture 19912#define alc680_pcm_analog_alt_capture alc880_pcm_analog_alt_capture 19913#define alc680_pcm_digital_playback alc880_pcm_digital_playback 19914#define alc680_pcm_digital_capture alc880_pcm_digital_capture 19915 19916/* 19917 * BIOS auto configuration 19918 */ 19919static int alc680_parse_auto_config(struct hda_codec *codec) 19920{ 19921 struct alc_spec *spec = codec->spec; 19922 int err; 19923 static hda_nid_t alc680_ignore[] = { 0 }; 19924 19925 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 19926 alc680_ignore); 19927 if (err < 0) 19928 return err; 19929 19930 if (!spec->autocfg.line_outs) { 19931 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) { 19932 spec->multiout.max_channels = 2; 19933 spec->no_analog = 1; 19934 goto dig_only; 19935 } 19936 return 0; /* can't find valid BIOS pin config */ 19937 } 19938 err = alc680_auto_create_multi_out_ctls(spec, &spec->autocfg); 19939 if (err < 0) 19940 return err; 19941 19942 spec->multiout.max_channels = 2; 19943 19944 dig_only: 19945 /* digital only support output */ 19946 alc_auto_parse_digital(codec); 19947 if (spec->kctls.list) 19948 add_mixer(spec, spec->kctls.list); 19949 19950 add_verb(spec, alc680_init_verbs); 19951 19952 err = alc_auto_add_mic_boost(codec); 19953 if (err < 0) 19954 return err; 19955 19956 return 1; 19957} 19958 19959#define alc680_auto_init_analog_input alc882_auto_init_analog_input 19960 19961/* init callback for auto-configuration model -- overriding the default init */ 19962static void alc680_auto_init(struct hda_codec *codec) 19963{ 19964 struct alc_spec *spec = codec->spec; 19965 alc680_auto_init_multi_out(codec); 19966 alc680_auto_init_hp_out(codec); 19967 alc680_auto_init_analog_input(codec); 19968 alc_auto_init_digital(codec); 19969 if (spec->unsol_event) 19970 alc_inithook(codec); 19971} 19972 19973/* 19974 * configuration and preset 19975 */ 19976static const char * const alc680_models[ALC680_MODEL_LAST] = { 19977 [ALC680_BASE] = "base", 19978 [ALC680_AUTO] = "auto", 19979}; 19980 19981static struct snd_pci_quirk alc680_cfg_tbl[] = { 19982 SND_PCI_QUIRK(0x1043, 0x12f3, "ASUS NX90", ALC680_BASE), 19983 {} 19984}; 19985 19986static struct alc_config_preset alc680_presets[] = { 19987 [ALC680_BASE] = { 19988 .mixers = { alc680_base_mixer }, 19989 .cap_mixer = alc680_master_capture_mixer, 19990 .init_verbs = { alc680_init_verbs }, 19991 .num_dacs = ARRAY_SIZE(alc680_dac_nids), 19992 .dac_nids = alc680_dac_nids, 19993 .dig_out_nid = ALC680_DIGOUT_NID, 19994 .num_channel_mode = ARRAY_SIZE(alc680_modes), 19995 .channel_mode = alc680_modes, 19996 .unsol_event = alc680_unsol_event, 19997 .setup = alc680_base_setup, 19998 .init_hook = alc680_inithook, 19999 20000 }, 20001}; 20002 20003static int patch_alc680(struct hda_codec *codec) 20004{ 20005 struct alc_spec *spec; 20006 int board_config; 20007 int err; 20008 20009 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 20010 if (spec == NULL) 20011 return -ENOMEM; 20012 20013 codec->spec = spec; 20014 20015 board_config = snd_hda_check_board_config(codec, ALC680_MODEL_LAST, 20016 alc680_models, 20017 alc680_cfg_tbl); 20018 20019 if (board_config < 0 || board_config >= ALC680_MODEL_LAST) { 20020 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 20021 codec->chip_name); 20022 board_config = ALC680_AUTO; 20023 } 20024 20025 if (board_config == ALC680_AUTO) { 20026 /* automatic parse from the BIOS config */ 20027 err = alc680_parse_auto_config(codec); 20028 if (err < 0) { 20029 alc_free(codec); 20030 return err; 20031 } else if (!err) { 20032 printk(KERN_INFO 20033 "hda_codec: Cannot set up configuration " 20034 "from BIOS. Using base mode...\n"); 20035 board_config = ALC680_BASE; 20036 } 20037 } 20038 20039 if (board_config != ALC680_AUTO) 20040 setup_preset(codec, &alc680_presets[board_config]); 20041 20042 spec->stream_analog_playback = &alc680_pcm_analog_playback; 20043 spec->stream_analog_capture = &alc680_pcm_analog_auto_capture; 20044 spec->stream_digital_playback = &alc680_pcm_digital_playback; 20045 spec->stream_digital_capture = &alc680_pcm_digital_capture; 20046 20047 if (!spec->adc_nids) { 20048 spec->adc_nids = alc680_adc_nids; 20049 spec->num_adc_nids = ARRAY_SIZE(alc680_adc_nids); 20050 } 20051 20052 if (!spec->cap_mixer) 20053 set_capture_mixer(codec); 20054 20055 spec->vmaster_nid = 0x02; 20056 20057 codec->patch_ops = alc_patch_ops; 20058 if (board_config == ALC680_AUTO) 20059 spec->init_hook = alc680_auto_init; 20060 20061 return 0; 20062} 20063 20064/* 20065 * patch entries 20066 */ 20067static struct hda_codec_preset snd_hda_preset_realtek[] = { 20068 { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 }, 20069 { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 }, 20070 { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 }, 20071 { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 }, 20072 { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 }, 20073 { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 }, 20074 { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 }, 20075 { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 }, 20076 { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660", 20077 .patch = patch_alc861 }, 20078 { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd }, 20079 { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 }, 20080 { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd }, 20081 { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2", 20082 .patch = patch_alc882 }, 20083 { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1", 20084 .patch = patch_alc662 }, 20085 { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 }, 20086 { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 }, 20087 { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 }, 20088 { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 }, 20089 { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 }, 20090 { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 }, 20091 { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 }, 20092 { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A", 20093 .patch = patch_alc882 }, 20094 { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A", 20095 .patch = patch_alc882 }, 20096 { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 }, 20097 { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc888 }, 20098 { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200", 20099 .patch = patch_alc882 }, 20100 { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 }, 20101 { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 }, 20102 { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 }, 20103 {} /* terminator */ 20104}; 20105 20106MODULE_ALIAS("snd-hda-codec-id:10ec*"); 20107 20108MODULE_LICENSE("GPL"); 20109MODULE_DESCRIPTION("Realtek HD-audio codec"); 20110 20111static struct hda_codec_preset_list realtek_list = { 20112 .preset = snd_hda_preset_realtek, 20113 .owner = THIS_MODULE, 20114}; 20115 20116static int __init patch_realtek_init(void) 20117{ 20118 return snd_hda_add_codec_preset(&realtek_list); 20119} 20120 20121static void __exit patch_realtek_exit(void) 20122{ 20123 snd_hda_delete_codec_preset(&realtek_list); 20124} 20125 20126module_init(patch_realtek_init) 20127module_exit(patch_realtek_exit) 20128