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 "hda_codec.h" 32 #include "hda_local.h" 33 #include "hda_patch.h" 34 35 #define ALC880_FRONT_EVENT 0x01 36 #define ALC880_DCVOL_EVENT 0x02 37 #define ALC880_HP_EVENT 0x04 38 #define ALC880_MIC_EVENT 0x08 39 40 /* ALC880 board config type */ 41 enum { 42 ALC880_3ST, 43 ALC880_3ST_DIG, 44 ALC880_5ST, 45 ALC880_5ST_DIG, 46 ALC880_W810, 47 ALC880_Z71V, 48 ALC880_6ST, 49 ALC880_6ST_DIG, 50 ALC880_F1734, 51 ALC880_ASUS, 52 ALC880_ASUS_DIG, 53 ALC880_ASUS_W1V, 54 ALC880_ASUS_DIG2, 55 ALC880_FUJITSU, 56 ALC880_UNIWILL_DIG, 57 ALC880_UNIWILL, 58 ALC880_UNIWILL_P53, 59 ALC880_CLEVO, 60 ALC880_TCL_S700, 61 ALC880_LG, 62 ALC880_LG_LW, 63 ALC880_MEDION_RIM, 64 #ifdef CONFIG_SND_DEBUG 65 ALC880_TEST, 66 #endif 67 ALC880_AUTO, 68 ALC880_MODEL_LAST /* last tag */ 69 }; 70 71 /* ALC260 models */ 72 enum { 73 ALC260_BASIC, 74 ALC260_HP, 75 ALC260_HP_3013, 76 ALC260_FUJITSU_S702X, 77 ALC260_ACER, 78 ALC260_WILL, 79 ALC260_REPLACER_672V, 80 #ifdef CONFIG_SND_DEBUG 81 ALC260_TEST, 82 #endif 83 ALC260_AUTO, 84 ALC260_MODEL_LAST /* last tag */ 85 }; 86 87 /* ALC262 models */ 88 enum { 89 ALC262_BASIC, 90 ALC262_HIPPO, 91 ALC262_HIPPO_1, 92 ALC262_FUJITSU, 93 ALC262_HP_BPC, 94 ALC262_HP_BPC_D7000_WL, 95 ALC262_HP_BPC_D7000_WF, 96 ALC262_HP_TC_T5735, 97 ALC262_HP_RP5700, 98 ALC262_BENQ_ED8, 99 ALC262_SONY_ASSAMD, 100 ALC262_BENQ_T31, 101 ALC262_ULTRA, 102 ALC262_LENOVO_3000, 103 ALC262_AUTO, 104 ALC262_MODEL_LAST /* last tag */ 105 }; 106 107 /* ALC268 models */ 108 enum { 109 ALC267_QUANTA_IL1, 110 ALC268_3ST, 111 ALC268_TOSHIBA, 112 ALC268_ACER, 113 ALC268_DELL, 114 ALC268_ZEPTO, 115 #ifdef CONFIG_SND_DEBUG 116 ALC268_TEST, 117 #endif 118 ALC268_AUTO, 119 ALC268_MODEL_LAST /* last tag */ 120 }; 121 122 /* ALC269 models */ 123 enum { 124 ALC269_BASIC, 125 ALC269_ASUS_EEEPC_P703, 126 ALC269_ASUS_EEEPC_P901, 127 ALC269_AUTO, 128 ALC269_MODEL_LAST /* last tag */ 129 }; 130 131 /* ALC861 models */ 132 enum { 133 ALC861_3ST, 134 ALC660_3ST, 135 ALC861_3ST_DIG, 136 ALC861_6ST_DIG, 137 ALC861_UNIWILL_M31, 138 ALC861_TOSHIBA, 139 ALC861_ASUS, 140 ALC861_ASUS_LAPTOP, 141 ALC861_AUTO, 142 ALC861_MODEL_LAST, 143 }; 144 145 /* ALC861-VD models */ 146 enum { 147 ALC660VD_3ST, 148 ALC660VD_3ST_DIG, 149 ALC861VD_3ST, 150 ALC861VD_3ST_DIG, 151 ALC861VD_6ST_DIG, 152 ALC861VD_LENOVO, 153 ALC861VD_DALLAS, 154 ALC861VD_HP, 155 ALC861VD_AUTO, 156 ALC861VD_MODEL_LAST, 157 }; 158 159 /* ALC662 models */ 160 enum { 161 ALC662_3ST_2ch_DIG, 162 ALC662_3ST_6ch_DIG, 163 ALC662_3ST_6ch, 164 ALC662_5ST_DIG, 165 ALC662_LENOVO_101E, 166 ALC662_ASUS_EEEPC_P701, 167 ALC662_ASUS_EEEPC_EP20, 168 ALC663_ASUS_M51VA, 169 ALC663_ASUS_G71V, 170 ALC663_ASUS_H13, 171 ALC663_ASUS_G50V, 172 ALC662_AUTO, 173 ALC662_MODEL_LAST, 174 }; 175 176 /* ALC882 models */ 177 enum { 178 ALC882_3ST_DIG, 179 ALC882_6ST_DIG, 180 ALC882_ARIMA, 181 ALC882_W2JC, 182 ALC882_TARGA, 183 ALC882_ASUS_A7J, 184 ALC882_ASUS_A7M, 185 ALC885_MACPRO, 186 ALC885_MBP3, 187 ALC885_IMAC24, 188 ALC882_AUTO, 189 ALC882_MODEL_LAST, 190 }; 191 192 /* ALC883 models */ 193 enum { 194 ALC883_3ST_2ch_DIG, 195 ALC883_3ST_6ch_DIG, 196 ALC883_3ST_6ch, 197 ALC883_6ST_DIG, 198 ALC883_TARGA_DIG, 199 ALC883_TARGA_2ch_DIG, 200 ALC883_ACER, 201 ALC883_ACER_ASPIRE, 202 ALC883_MEDION, 203 ALC883_MEDION_MD2, 204 ALC883_LAPTOP_EAPD, 205 ALC883_LENOVO_101E_2ch, 206 ALC883_LENOVO_NB0763, 207 ALC888_LENOVO_MS7195_DIG, 208 ALC883_HAIER_W66, 209 ALC888_3ST_HP, 210 ALC888_6ST_DELL, 211 ALC883_MITAC, 212 ALC883_CLEVO_M720, 213 ALC883_FUJITSU_PI2515, 214 ALC883_3ST_6ch_INTEL, 215 ALC883_AUTO, 216 ALC883_MODEL_LAST, 217 }; 218 219 /* for GPIO Poll */ 220 #define GPIO_MASK 0x03 221 222 struct alc_spec { 223 /* codec parameterization */ 224 struct snd_kcontrol_new *mixers[5]; /* mixer arrays */ 225 unsigned int num_mixers; 226 227 const struct hda_verb *init_verbs[5]; /* initialization verbs 228 * don't forget NULL 229 * termination! 230 */ 231 unsigned int num_init_verbs; 232 233 char *stream_name_analog; /* analog PCM stream */ 234 struct hda_pcm_stream *stream_analog_playback; 235 struct hda_pcm_stream *stream_analog_capture; 236 struct hda_pcm_stream *stream_analog_alt_playback; 237 struct hda_pcm_stream *stream_analog_alt_capture; 238 239 char *stream_name_digital; /* digital PCM stream */ 240 struct hda_pcm_stream *stream_digital_playback; 241 struct hda_pcm_stream *stream_digital_capture; 242 243 /* playback */ 244 struct hda_multi_out multiout; /* playback set-up 245 * max_channels, dacs must be set 246 * dig_out_nid and hp_nid are optional 247 */ 248 hda_nid_t alt_dac_nid; 249 250 /* capture */ 251 unsigned int num_adc_nids; 252 hda_nid_t *adc_nids; 253 hda_nid_t *capsrc_nids; 254 hda_nid_t dig_in_nid; /* digital-in NID; optional */ 255 256 /* capture source */ 257 unsigned int num_mux_defs; 258 const struct hda_input_mux *input_mux; 259 unsigned int cur_mux[3]; 260 261 /* channel model */ 262 const struct hda_channel_mode *channel_mode; 263 int num_channel_mode; 264 int need_dac_fix; 265 266 /* PCM information */ 267 struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */ 268 269 /* dynamic controls, init_verbs and input_mux */ 270 struct auto_pin_cfg autocfg; 271 unsigned int num_kctl_alloc, num_kctl_used; 272 struct snd_kcontrol_new *kctl_alloc; 273 struct hda_input_mux private_imux; 274 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS]; 275 276 /* hooks */ 277 void (*init_hook)(struct hda_codec *codec); 278 void (*unsol_event)(struct hda_codec *codec, unsigned int res); 279 280 /* for pin sensing */ 281 unsigned int sense_updated: 1; 282 unsigned int jack_present: 1; 283 unsigned int master_sw: 1; 284 285 /* for virtual master */ 286 hda_nid_t vmaster_nid; 287 #ifdef CONFIG_SND_HDA_POWER_SAVE 288 struct hda_loopback_check loopback; 289 #endif 290 291 /* for PLL fix */ 292 hda_nid_t pll_nid; 293 unsigned int pll_coef_idx, pll_coef_bit; 294 }; 295 296 /* 297 * configuration template - to be copied to the spec instance 298 */ 299 struct alc_config_preset { 300 struct snd_kcontrol_new *mixers[5]; /* should be identical size 301 * with spec 302 */ 303 const struct hda_verb *init_verbs[5]; 304 unsigned int num_dacs; 305 hda_nid_t *dac_nids; 306 hda_nid_t dig_out_nid; /* optional */ 307 hda_nid_t hp_nid; /* optional */ 308 unsigned int num_adc_nids; 309 hda_nid_t *adc_nids; 310 hda_nid_t *capsrc_nids; 311 hda_nid_t dig_in_nid; 312 unsigned int num_channel_mode; 313 const struct hda_channel_mode *channel_mode; 314 int need_dac_fix; 315 unsigned int num_mux_defs; 316 const struct hda_input_mux *input_mux; 317 void (*unsol_event)(struct hda_codec *, unsigned int); 318 void (*init_hook)(struct hda_codec *); 319 #ifdef CONFIG_SND_HDA_POWER_SAVE 320 struct hda_amp_list *loopbacks; 321 #endif 322 }; 323 324 325 /* 326 * input MUX handling 327 */ 328 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol, 329 struct snd_ctl_elem_info *uinfo) 330 { 331 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 332 struct alc_spec *spec = codec->spec; 333 unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id); 334 if (mux_idx >= spec->num_mux_defs) 335 mux_idx = 0; 336 return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo); 337 } 338 339 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol, 340 struct snd_ctl_elem_value *ucontrol) 341 { 342 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 343 struct alc_spec *spec = codec->spec; 344 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 345 346 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx]; 347 return 0; 348 } 349 350 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol, 351 struct snd_ctl_elem_value *ucontrol) 352 { 353 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 354 struct alc_spec *spec = codec->spec; 355 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 356 unsigned int mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx; 357 hda_nid_t nid = spec->capsrc_nids ? 358 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx]; 359 return snd_hda_input_mux_put(codec, &spec->input_mux[mux_idx], ucontrol, 360 nid, &spec->cur_mux[adc_idx]); 361 } 362 363 364 /* 365 * channel mode setting 366 */ 367 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol, 368 struct snd_ctl_elem_info *uinfo) 369 { 370 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 371 struct alc_spec *spec = codec->spec; 372 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode, 373 spec->num_channel_mode); 374 } 375 376 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol, 377 struct snd_ctl_elem_value *ucontrol) 378 { 379 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 380 struct alc_spec *spec = codec->spec; 381 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode, 382 spec->num_channel_mode, 383 spec->multiout.max_channels); 384 } 385 386 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol, 387 struct snd_ctl_elem_value *ucontrol) 388 { 389 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 390 struct alc_spec *spec = codec->spec; 391 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode, 392 spec->num_channel_mode, 393 &spec->multiout.max_channels); 394 if (err >= 0 && spec->need_dac_fix) 395 spec->multiout.num_dacs = spec->multiout.max_channels / 2; 396 return err; 397 } 398 399 /* 400 * Control the mode of pin widget settings via the mixer. "pc" is used 401 * instead of "%" to avoid consequences of accidently treating the % as 402 * being part of a format specifier. Maximum allowed length of a value is 403 * 63 characters plus NULL terminator. 404 * 405 * Note: some retasking pin complexes seem to ignore requests for input 406 * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these 407 * are requested. Therefore order this list so that this behaviour will not 408 * cause problems when mixer clients move through the enum sequentially. 409 * NIDs 0x0f and 0x10 have been observed to have this behaviour as of 410 * March 2006. 411 */ 412 static char *alc_pin_mode_names[] = { 413 "Mic 50pc bias", "Mic 80pc bias", 414 "Line in", "Line out", "Headphone out", 415 }; 416 static unsigned char alc_pin_mode_values[] = { 417 PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP, 418 }; 419 /* The control can present all 5 options, or it can limit the options based 420 * in the pin being assumed to be exclusively an input or an output pin. In 421 * addition, "input" pins may or may not process the mic bias option 422 * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to 423 * accept requests for bias as of chip versions up to March 2006) and/or 424 * wiring in the computer. 425 */ 426 #define ALC_PIN_DIR_IN 0x00 427 #define ALC_PIN_DIR_OUT 0x01 428 #define ALC_PIN_DIR_INOUT 0x02 429 #define ALC_PIN_DIR_IN_NOMICBIAS 0x03 430 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04 431 432 /* Info about the pin modes supported by the different pin direction modes. 433 * For each direction the minimum and maximum values are given. 434 */ 435 static signed char alc_pin_mode_dir_info[5][2] = { 436 { 0, 2 }, /* ALC_PIN_DIR_IN */ 437 { 3, 4 }, /* ALC_PIN_DIR_OUT */ 438 { 0, 4 }, /* ALC_PIN_DIR_INOUT */ 439 { 2, 2 }, /* ALC_PIN_DIR_IN_NOMICBIAS */ 440 { 2, 4 }, /* ALC_PIN_DIR_INOUT_NOMICBIAS */ 441 }; 442 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0]) 443 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1]) 444 #define alc_pin_mode_n_items(_dir) \ 445 (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1) 446 447 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol, 448 struct snd_ctl_elem_info *uinfo) 449 { 450 unsigned int item_num = uinfo->value.enumerated.item; 451 unsigned char dir = (kcontrol->private_value >> 16) & 0xff; 452 453 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 454 uinfo->count = 1; 455 uinfo->value.enumerated.items = alc_pin_mode_n_items(dir); 456 457 if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir)) 458 item_num = alc_pin_mode_min(dir); 459 strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]); 460 return 0; 461 } 462 463 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol, 464 struct snd_ctl_elem_value *ucontrol) 465 { 466 unsigned int i; 467 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 468 hda_nid_t nid = kcontrol->private_value & 0xffff; 469 unsigned char dir = (kcontrol->private_value >> 16) & 0xff; 470 long *valp = ucontrol->value.integer.value; 471 unsigned int pinctl = snd_hda_codec_read(codec, nid, 0, 472 AC_VERB_GET_PIN_WIDGET_CONTROL, 473 0x00); 474 475 /* Find enumerated value for current pinctl setting */ 476 i = alc_pin_mode_min(dir); 477 while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir)) 478 i++; 479 *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir); 480 return 0; 481 } 482 483 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol, 484 struct snd_ctl_elem_value *ucontrol) 485 { 486 signed int change; 487 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 488 hda_nid_t nid = kcontrol->private_value & 0xffff; 489 unsigned char dir = (kcontrol->private_value >> 16) & 0xff; 490 long val = *ucontrol->value.integer.value; 491 unsigned int pinctl = snd_hda_codec_read(codec, nid, 0, 492 AC_VERB_GET_PIN_WIDGET_CONTROL, 493 0x00); 494 495 if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir)) 496 val = alc_pin_mode_min(dir); 497 498 change = pinctl != alc_pin_mode_values[val]; 499 if (change) { 500 /* Set pin mode to that requested */ 501 snd_hda_codec_write_cache(codec, nid, 0, 502 AC_VERB_SET_PIN_WIDGET_CONTROL, 503 alc_pin_mode_values[val]); 504 505 /* Also enable the retasking pin's input/output as required 506 * for the requested pin mode. Enum values of 2 or less are 507 * input modes. 508 * 509 * Dynamically switching the input/output buffers probably 510 * reduces noise slightly (particularly on input) so we'll 511 * do it. However, having both input and output buffers 512 * enabled simultaneously doesn't seem to be problematic if 513 * this turns out to be necessary in the future. 514 */ 515 if (val <= 2) { 516 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 517 HDA_AMP_MUTE, HDA_AMP_MUTE); 518 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0, 519 HDA_AMP_MUTE, 0); 520 } else { 521 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0, 522 HDA_AMP_MUTE, HDA_AMP_MUTE); 523 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 524 HDA_AMP_MUTE, 0); 525 } 526 } 527 return change; 528 } 529 530 #define ALC_PIN_MODE(xname, nid, dir) \ 531 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 532 .info = alc_pin_mode_info, \ 533 .get = alc_pin_mode_get, \ 534 .put = alc_pin_mode_put, \ 535 .private_value = nid | (dir<<16) } 536 537 /* A switch control for ALC260 GPIO pins. Multiple GPIOs can be ganged 538 * together using a mask with more than one bit set. This control is 539 * currently used only by the ALC260 test model. At this stage they are not 540 * needed for any "production" models. 541 */ 542 #ifdef CONFIG_SND_DEBUG 543 #define alc_gpio_data_info snd_ctl_boolean_mono_info 544 545 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol, 546 struct snd_ctl_elem_value *ucontrol) 547 { 548 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 549 hda_nid_t nid = kcontrol->private_value & 0xffff; 550 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 551 long *valp = ucontrol->value.integer.value; 552 unsigned int val = snd_hda_codec_read(codec, nid, 0, 553 AC_VERB_GET_GPIO_DATA, 0x00); 554 555 *valp = (val & mask) != 0; 556 return 0; 557 } 558 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol, 559 struct snd_ctl_elem_value *ucontrol) 560 { 561 signed int change; 562 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 563 hda_nid_t nid = kcontrol->private_value & 0xffff; 564 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 565 long val = *ucontrol->value.integer.value; 566 unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0, 567 AC_VERB_GET_GPIO_DATA, 568 0x00); 569 570 /* Set/unset the masked GPIO bit(s) as needed */ 571 change = (val == 0 ? 0 : mask) != (gpio_data & mask); 572 if (val == 0) 573 gpio_data &= ~mask; 574 else 575 gpio_data |= mask; 576 snd_hda_codec_write_cache(codec, nid, 0, 577 AC_VERB_SET_GPIO_DATA, gpio_data); 578 579 return change; 580 } 581 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \ 582 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 583 .info = alc_gpio_data_info, \ 584 .get = alc_gpio_data_get, \ 585 .put = alc_gpio_data_put, \ 586 .private_value = nid | (mask<<16) } 587 #endif /* CONFIG_SND_DEBUG */ 588 589 /* A switch control to allow the enabling of the digital IO pins on the 590 * ALC260. This is incredibly simplistic; the intention of this control is 591 * to provide something in the test model allowing digital outputs to be 592 * identified if present. If models are found which can utilise these 593 * outputs a more complete mixer control can be devised for those models if 594 * necessary. 595 */ 596 #ifdef CONFIG_SND_DEBUG 597 #define alc_spdif_ctrl_info snd_ctl_boolean_mono_info 598 599 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol, 600 struct snd_ctl_elem_value *ucontrol) 601 { 602 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 603 hda_nid_t nid = kcontrol->private_value & 0xffff; 604 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 605 long *valp = ucontrol->value.integer.value; 606 unsigned int val = snd_hda_codec_read(codec, nid, 0, 607 AC_VERB_GET_DIGI_CONVERT_1, 0x00); 608 609 *valp = (val & mask) != 0; 610 return 0; 611 } 612 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol, 613 struct snd_ctl_elem_value *ucontrol) 614 { 615 signed int change; 616 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 617 hda_nid_t nid = kcontrol->private_value & 0xffff; 618 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 619 long val = *ucontrol->value.integer.value; 620 unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0, 621 AC_VERB_GET_DIGI_CONVERT_1, 622 0x00); 623 624 /* Set/unset the masked control bit(s) as needed */ 625 change = (val == 0 ? 0 : mask) != (ctrl_data & mask); 626 if (val==0) 627 ctrl_data &= ~mask; 628 else 629 ctrl_data |= mask; 630 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1, 631 ctrl_data); 632 633 return change; 634 } 635 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \ 636 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 637 .info = alc_spdif_ctrl_info, \ 638 .get = alc_spdif_ctrl_get, \ 639 .put = alc_spdif_ctrl_put, \ 640 .private_value = nid | (mask<<16) } 641 #endif /* CONFIG_SND_DEBUG */ 642 643 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x. 644 * Again, this is only used in the ALC26x test models to help identify when 645 * the EAPD line must be asserted for features to work. 646 */ 647 #ifdef CONFIG_SND_DEBUG 648 #define alc_eapd_ctrl_info snd_ctl_boolean_mono_info 649 650 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol, 651 struct snd_ctl_elem_value *ucontrol) 652 { 653 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 654 hda_nid_t nid = kcontrol->private_value & 0xffff; 655 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 656 long *valp = ucontrol->value.integer.value; 657 unsigned int val = snd_hda_codec_read(codec, nid, 0, 658 AC_VERB_GET_EAPD_BTLENABLE, 0x00); 659 660 *valp = (val & mask) != 0; 661 return 0; 662 } 663 664 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol, 665 struct snd_ctl_elem_value *ucontrol) 666 { 667 int change; 668 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 669 hda_nid_t nid = kcontrol->private_value & 0xffff; 670 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 671 long val = *ucontrol->value.integer.value; 672 unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0, 673 AC_VERB_GET_EAPD_BTLENABLE, 674 0x00); 675 676 /* Set/unset the masked control bit(s) as needed */ 677 change = (!val ? 0 : mask) != (ctrl_data & mask); 678 if (!val) 679 ctrl_data &= ~mask; 680 else 681 ctrl_data |= mask; 682 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE, 683 ctrl_data); 684 685 return change; 686 } 687 688 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \ 689 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 690 .info = alc_eapd_ctrl_info, \ 691 .get = alc_eapd_ctrl_get, \ 692 .put = alc_eapd_ctrl_put, \ 693 .private_value = nid | (mask<<16) } 694 #endif /* CONFIG_SND_DEBUG */ 695 696 /* 697 * set up from the preset table 698 */ 699 static void setup_preset(struct alc_spec *spec, 700 const struct alc_config_preset *preset) 701 { 702 int i; 703 704 for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++) 705 spec->mixers[spec->num_mixers++] = preset->mixers[i]; 706 for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i]; 707 i++) 708 spec->init_verbs[spec->num_init_verbs++] = 709 preset->init_verbs[i]; 710 711 spec->channel_mode = preset->channel_mode; 712 spec->num_channel_mode = preset->num_channel_mode; 713 spec->need_dac_fix = preset->need_dac_fix; 714 715 spec->multiout.max_channels = spec->channel_mode[0].channels; 716 717 spec->multiout.num_dacs = preset->num_dacs; 718 spec->multiout.dac_nids = preset->dac_nids; 719 spec->multiout.dig_out_nid = preset->dig_out_nid; 720 spec->multiout.hp_nid = preset->hp_nid; 721 722 spec->num_mux_defs = preset->num_mux_defs; 723 if (!spec->num_mux_defs) 724 spec->num_mux_defs = 1; 725 spec->input_mux = preset->input_mux; 726 727 spec->num_adc_nids = preset->num_adc_nids; 728 spec->adc_nids = preset->adc_nids; 729 spec->capsrc_nids = preset->capsrc_nids; 730 spec->dig_in_nid = preset->dig_in_nid; 731 732 spec->unsol_event = preset->unsol_event; 733 spec->init_hook = preset->init_hook; 734 #ifdef CONFIG_SND_HDA_POWER_SAVE 735 spec->loopback.amplist = preset->loopbacks; 736 #endif 737 } 738 739 /* Enable GPIO mask and set output */ 740 static struct hda_verb alc_gpio1_init_verbs[] = { 741 {0x01, AC_VERB_SET_GPIO_MASK, 0x01}, 742 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, 743 {0x01, AC_VERB_SET_GPIO_DATA, 0x01}, 744 { } 745 }; 746 747 static struct hda_verb alc_gpio2_init_verbs[] = { 748 {0x01, AC_VERB_SET_GPIO_MASK, 0x02}, 749 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02}, 750 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, 751 { } 752 }; 753 754 static struct hda_verb alc_gpio3_init_verbs[] = { 755 {0x01, AC_VERB_SET_GPIO_MASK, 0x03}, 756 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03}, 757 {0x01, AC_VERB_SET_GPIO_DATA, 0x03}, 758 { } 759 }; 760 761 /* 762 * Fix hardware PLL issue 763 * On some codecs, the analog PLL gating control must be off while 764 * the default value is 1. 765 */ 766 static void alc_fix_pll(struct hda_codec *codec) 767 { 768 struct alc_spec *spec = codec->spec; 769 unsigned int val; 770 771 if (!spec->pll_nid) 772 return; 773 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX, 774 spec->pll_coef_idx); 775 val = snd_hda_codec_read(codec, spec->pll_nid, 0, 776 AC_VERB_GET_PROC_COEF, 0); 777 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX, 778 spec->pll_coef_idx); 779 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF, 780 val & ~(1 << spec->pll_coef_bit)); 781 } 782 783 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid, 784 unsigned int coef_idx, unsigned int coef_bit) 785 { 786 struct alc_spec *spec = codec->spec; 787 spec->pll_nid = nid; 788 spec->pll_coef_idx = coef_idx; 789 spec->pll_coef_bit = coef_bit; 790 alc_fix_pll(codec); 791 } 792 793 static void alc_sku_automute(struct hda_codec *codec) 794 { 795 struct alc_spec *spec = codec->spec; 796 unsigned int present; 797 unsigned int hp_nid = spec->autocfg.hp_pins[0]; 798 unsigned int sp_nid = spec->autocfg.speaker_pins[0]; 799 800 /* need to execute and sync at first */ 801 snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0); 802 present = snd_hda_codec_read(codec, hp_nid, 0, 803 AC_VERB_GET_PIN_SENSE, 0); 804 spec->jack_present = (present & 0x80000000) != 0; 805 snd_hda_codec_write(codec, sp_nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 806 spec->jack_present ? 0 : PIN_OUT); 807 } 808 809 /* unsolicited event for HP jack sensing */ 810 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res) 811 { 812 if (codec->vendor_id == 0x10ec0880) 813 res >>= 28; 814 else 815 res >>= 26; 816 if (res != ALC880_HP_EVENT) 817 return; 818 819 alc_sku_automute(codec); 820 } 821 822 /* additional initialization for ALC888 variants */ 823 static void alc888_coef_init(struct hda_codec *codec) 824 { 825 unsigned int tmp; 826 827 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0); 828 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0); 829 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7); 830 if ((tmp & 0xf0) == 2) 831 /* alc888S-VC */ 832 snd_hda_codec_read(codec, 0x20, 0, 833 AC_VERB_SET_PROC_COEF, 0x830); 834 else 835 /* alc888-VB */ 836 snd_hda_codec_read(codec, 0x20, 0, 837 AC_VERB_SET_PROC_COEF, 0x3030); 838 } 839 840 /* 32-bit subsystem ID for BIOS loading in HD Audio codec. 841 * 31 ~ 16 : Manufacture ID 842 * 15 ~ 8 : SKU ID 843 * 7 ~ 0 : Assembly ID 844 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36 845 */ 846 static void alc_subsystem_id(struct hda_codec *codec, 847 unsigned int porta, unsigned int porte, 848 unsigned int portd) 849 { 850 unsigned int ass, tmp, i; 851 unsigned nid; 852 struct alc_spec *spec = codec->spec; 853 854 ass = codec->subsystem_id & 0xffff; 855 if ((ass != codec->bus->pci->subsystem_device) && (ass & 1)) 856 goto do_sku; 857 858 /* 859 * 31~30 : port conetcivity 860 * 29~21 : reserve 861 * 20 : PCBEEP input 862 * 19~16 : Check sum (15:1) 863 * 15~1 : Custom 864 * 0 : override 865 */ 866 nid = 0x1d; 867 if (codec->vendor_id == 0x10ec0260) 868 nid = 0x17; 869 ass = snd_hda_codec_read(codec, nid, 0, 870 AC_VERB_GET_CONFIG_DEFAULT, 0); 871 if (!(ass & 1) && !(ass & 0x100000)) 872 return; 873 if ((ass >> 30) != 1) /* no physical connection */ 874 return; 875 876 /* check sum */ 877 tmp = 0; 878 for (i = 1; i < 16; i++) { 879 if ((ass >> i) & 1) 880 tmp++; 881 } 882 if (((ass >> 16) & 0xf) != tmp) 883 return; 884 do_sku: 885 /* 886 * 0 : override 887 * 1 : Swap Jack 888 * 2 : 0 --> Desktop, 1 --> Laptop 889 * 3~5 : External Amplifier control 890 * 7~6 : Reserved 891 */ 892 tmp = (ass & 0x38) >> 3; /* external Amp control */ 893 switch (tmp) { 894 case 1: 895 snd_hda_sequence_write(codec, alc_gpio1_init_verbs); 896 break; 897 case 3: 898 snd_hda_sequence_write(codec, alc_gpio2_init_verbs); 899 break; 900 case 7: 901 snd_hda_sequence_write(codec, alc_gpio3_init_verbs); 902 break; 903 case 5: /* set EAPD output high */ 904 switch (codec->vendor_id) { 905 case 0x10ec0260: 906 snd_hda_codec_write(codec, 0x0f, 0, 907 AC_VERB_SET_EAPD_BTLENABLE, 2); 908 snd_hda_codec_write(codec, 0x10, 0, 909 AC_VERB_SET_EAPD_BTLENABLE, 2); 910 break; 911 case 0x10ec0262: 912 case 0x10ec0267: 913 case 0x10ec0268: 914 case 0x10ec0269: 915 case 0x10ec0660: 916 case 0x10ec0662: 917 case 0x10ec0663: 918 case 0x10ec0862: 919 case 0x10ec0889: 920 snd_hda_codec_write(codec, 0x14, 0, 921 AC_VERB_SET_EAPD_BTLENABLE, 2); 922 snd_hda_codec_write(codec, 0x15, 0, 923 AC_VERB_SET_EAPD_BTLENABLE, 2); 924 break; 925 } 926 switch (codec->vendor_id) { 927 case 0x10ec0260: 928 snd_hda_codec_write(codec, 0x1a, 0, 929 AC_VERB_SET_COEF_INDEX, 7); 930 tmp = snd_hda_codec_read(codec, 0x1a, 0, 931 AC_VERB_GET_PROC_COEF, 0); 932 snd_hda_codec_write(codec, 0x1a, 0, 933 AC_VERB_SET_COEF_INDEX, 7); 934 snd_hda_codec_write(codec, 0x1a, 0, 935 AC_VERB_SET_PROC_COEF, 936 tmp | 0x2010); 937 break; 938 case 0x10ec0262: 939 case 0x10ec0880: 940 case 0x10ec0882: 941 case 0x10ec0883: 942 case 0x10ec0885: 943 case 0x10ec0889: 944 snd_hda_codec_write(codec, 0x20, 0, 945 AC_VERB_SET_COEF_INDEX, 7); 946 tmp = snd_hda_codec_read(codec, 0x20, 0, 947 AC_VERB_GET_PROC_COEF, 0); 948 snd_hda_codec_write(codec, 0x20, 0, 949 AC_VERB_SET_COEF_INDEX, 7); 950 snd_hda_codec_write(codec, 0x20, 0, 951 AC_VERB_SET_PROC_COEF, 952 tmp | 0x2010); 953 break; 954 case 0x10ec0888: 955 alc888_coef_init(codec); 956 break; 957 case 0x10ec0267: 958 case 0x10ec0268: 959 snd_hda_codec_write(codec, 0x20, 0, 960 AC_VERB_SET_COEF_INDEX, 7); 961 tmp = snd_hda_codec_read(codec, 0x20, 0, 962 AC_VERB_GET_PROC_COEF, 0); 963 snd_hda_codec_write(codec, 0x20, 0, 964 AC_VERB_SET_COEF_INDEX, 7); 965 snd_hda_codec_write(codec, 0x20, 0, 966 AC_VERB_SET_PROC_COEF, 967 tmp | 0x3000); 968 break; 969 } 970 default: 971 break; 972 } 973 974 /* is laptop or Desktop and enable the function "Mute internal speaker 975 * when the external headphone out jack is plugged" 976 */ 977 if (!(ass & 0x8000)) 978 return; 979 /* 980 * 10~8 : Jack location 981 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered 982 * 14~13: Resvered 983 * 15 : 1 --> enable the function "Mute internal speaker 984 * when the external headphone out jack is plugged" 985 */ 986 if (!spec->autocfg.speaker_pins[0]) { 987 if (spec->autocfg.line_out_pins[0]) 988 spec->autocfg.speaker_pins[0] = 989 spec->autocfg.line_out_pins[0]; 990 else 991 return; 992 } 993 994 if (!spec->autocfg.hp_pins[0]) { 995 tmp = (ass >> 11) & 0x3; /* HP to chassis */ 996 if (tmp == 0) 997 spec->autocfg.hp_pins[0] = porta; 998 else if (tmp == 1) 999 spec->autocfg.hp_pins[0] = porte; 1000 else if (tmp == 2) 1001 spec->autocfg.hp_pins[0] = portd; 1002 else 1003 return; 1004 } 1005 1006 snd_hda_codec_write(codec, spec->autocfg.hp_pins[0], 0, 1007 AC_VERB_SET_UNSOLICITED_ENABLE, 1008 AC_USRSP_EN | ALC880_HP_EVENT); 1009 spec->unsol_event = alc_sku_unsol_event; 1010 } 1011 1012 /* 1013 * Fix-up pin default configurations 1014 */ 1015 1016 struct alc_pincfg { 1017 hda_nid_t nid; 1018 u32 val; 1019 }; 1020 1021 static void alc_fix_pincfg(struct hda_codec *codec, 1022 const struct snd_pci_quirk *quirk, 1023 const struct alc_pincfg **pinfix) 1024 { 1025 const struct alc_pincfg *cfg; 1026 1027 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk); 1028 if (!quirk) 1029 return; 1030 1031 cfg = pinfix[quirk->value]; 1032 for (; cfg->nid; cfg++) { 1033 int i; 1034 u32 val = cfg->val; 1035 for (i = 0; i < 4; i++) { 1036 snd_hda_codec_write(codec, cfg->nid, 0, 1037 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i, 1038 val & 0xff); 1039 val >>= 8; 1040 } 1041 } 1042 } 1043 1044 /* 1045 * ALC880 3-stack model 1046 * 1047 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e) 1048 * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18, 1049 * F-Mic = 0x1b, HP = 0x19 1050 */ 1051 1052 static hda_nid_t alc880_dac_nids[4] = { 1053 /* front, rear, clfe, rear_surr */ 1054 0x02, 0x05, 0x04, 0x03 1055 }; 1056 1057 static hda_nid_t alc880_adc_nids[3] = { 1058 /* ADC0-2 */ 1059 0x07, 0x08, 0x09, 1060 }; 1061 1062 /* The datasheet says the node 0x07 is connected from inputs, 1063 * but it shows zero connection in the real implementation on some devices. 1064 * Note: this is a 915GAV bug, fixed on 915GLV 1065 */ 1066 static hda_nid_t alc880_adc_nids_alt[2] = { 1067 /* ADC1-2 */ 1068 0x08, 0x09, 1069 }; 1070 1071 #define ALC880_DIGOUT_NID 0x06 1072 #define ALC880_DIGIN_NID 0x0a 1073 1074 static struct hda_input_mux alc880_capture_source = { 1075 .num_items = 4, 1076 .items = { 1077 { "Mic", 0x0 }, 1078 { "Front Mic", 0x3 }, 1079 { "Line", 0x2 }, 1080 { "CD", 0x4 }, 1081 }, 1082 }; 1083 1084 /* channel source setting (2/6 channel selection for 3-stack) */ 1085 /* 2ch mode */ 1086 static struct hda_verb alc880_threestack_ch2_init[] = { 1087 /* set line-in to input, mute it */ 1088 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 1089 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 1090 /* set mic-in to input vref 80%, mute it */ 1091 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 1092 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 1093 { } /* end */ 1094 }; 1095 1096 /* 6ch mode */ 1097 static struct hda_verb alc880_threestack_ch6_init[] = { 1098 /* set line-in to output, unmute it */ 1099 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1100 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1101 /* set mic-in to output, unmute it */ 1102 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1103 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1104 { } /* end */ 1105 }; 1106 1107 static struct hda_channel_mode alc880_threestack_modes[2] = { 1108 { 2, alc880_threestack_ch2_init }, 1109 { 6, alc880_threestack_ch6_init }, 1110 }; 1111 1112 static struct snd_kcontrol_new alc880_three_stack_mixer[] = { 1113 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1114 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 1115 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 1116 HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT), 1117 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 1118 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 1119 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 1120 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 1121 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1122 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1123 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 1124 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 1125 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1126 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1127 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT), 1128 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT), 1129 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 1130 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 1131 HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT), 1132 { 1133 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1134 .name = "Channel Mode", 1135 .info = alc_ch_mode_info, 1136 .get = alc_ch_mode_get, 1137 .put = alc_ch_mode_put, 1138 }, 1139 { } /* end */ 1140 }; 1141 1142 /* capture mixer elements */ 1143 static struct snd_kcontrol_new alc880_capture_mixer[] = { 1144 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT), 1145 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT), 1146 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT), 1147 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT), 1148 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT), 1149 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT), 1150 { 1151 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1152 /* The multiple "Capture Source" controls confuse alsamixer 1153 * So call somewhat different.. 1154 */ 1155 /* .name = "Capture Source", */ 1156 .name = "Input Source", 1157 .count = 3, 1158 .info = alc_mux_enum_info, 1159 .get = alc_mux_enum_get, 1160 .put = alc_mux_enum_put, 1161 }, 1162 { } /* end */ 1163 }; 1164 1165 /* capture mixer elements (in case NID 0x07 not available) */ 1166 static struct snd_kcontrol_new alc880_capture_alt_mixer[] = { 1167 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 1168 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 1169 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 1170 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 1171 { 1172 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1173 /* The multiple "Capture Source" controls confuse alsamixer 1174 * So call somewhat different.. 1175 */ 1176 /* .name = "Capture Source", */ 1177 .name = "Input Source", 1178 .count = 2, 1179 .info = alc_mux_enum_info, 1180 .get = alc_mux_enum_get, 1181 .put = alc_mux_enum_put, 1182 }, 1183 { } /* end */ 1184 }; 1185 1186 1187 1188 /* 1189 * ALC880 5-stack model 1190 * 1191 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d), 1192 * Side = 0x02 (0xd) 1193 * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16 1194 * Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19 1195 */ 1196 1197 /* additional mixers to alc880_three_stack_mixer */ 1198 static struct snd_kcontrol_new alc880_five_stack_mixer[] = { 1199 HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1200 HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT), 1201 { } /* end */ 1202 }; 1203 1204 /* channel source setting (6/8 channel selection for 5-stack) */ 1205 /* 6ch mode */ 1206 static struct hda_verb alc880_fivestack_ch6_init[] = { 1207 /* set line-in to input, mute it */ 1208 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 1209 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 1210 { } /* end */ 1211 }; 1212 1213 /* 8ch mode */ 1214 static struct hda_verb alc880_fivestack_ch8_init[] = { 1215 /* set line-in to output, unmute it */ 1216 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1217 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1218 { } /* end */ 1219 }; 1220 1221 static struct hda_channel_mode alc880_fivestack_modes[2] = { 1222 { 6, alc880_fivestack_ch6_init }, 1223 { 8, alc880_fivestack_ch8_init }, 1224 }; 1225 1226 1227 /* 1228 * ALC880 6-stack model 1229 * 1230 * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e), 1231 * Side = 0x05 (0x0f) 1232 * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17, 1233 * Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b 1234 */ 1235 1236 static hda_nid_t alc880_6st_dac_nids[4] = { 1237 /* front, rear, clfe, rear_surr */ 1238 0x02, 0x03, 0x04, 0x05 1239 }; 1240 1241 static struct hda_input_mux alc880_6stack_capture_source = { 1242 .num_items = 4, 1243 .items = { 1244 { "Mic", 0x0 }, 1245 { "Front Mic", 0x1 }, 1246 { "Line", 0x2 }, 1247 { "CD", 0x4 }, 1248 }, 1249 }; 1250 1251 /* fixed 8-channels */ 1252 static struct hda_channel_mode alc880_sixstack_modes[1] = { 1253 { 8, NULL }, 1254 }; 1255 1256 static struct snd_kcontrol_new alc880_six_stack_mixer[] = { 1257 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1258 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 1259 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1260 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 1261 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 1262 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 1263 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 1264 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 1265 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 1266 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 1267 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1268 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1269 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 1270 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 1271 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1272 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1273 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 1274 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 1275 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 1276 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 1277 { 1278 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1279 .name = "Channel Mode", 1280 .info = alc_ch_mode_info, 1281 .get = alc_ch_mode_get, 1282 .put = alc_ch_mode_put, 1283 }, 1284 { } /* end */ 1285 }; 1286 1287 1288 /* 1289 * ALC880 W810 model 1290 * 1291 * W810 has rear IO for: 1292 * Front (DAC 02) 1293 * Surround (DAC 03) 1294 * Center/LFE (DAC 04) 1295 * Digital out (06) 1296 * 1297 * The system also has a pair of internal speakers, and a headphone jack. 1298 * These are both connected to Line2 on the codec, hence to DAC 02. 1299 * 1300 * There is a variable resistor to control the speaker or headphone 1301 * volume. This is a hardware-only device without a software API. 1302 * 1303 * Plugging headphones in will disable the internal speakers. This is 1304 * implemented in hardware, not via the driver using jack sense. In 1305 * a similar fashion, plugging into the rear socket marked "front" will 1306 * disable both the speakers and headphones. 1307 * 1308 * For input, there's a microphone jack, and an "audio in" jack. 1309 * These may not do anything useful with this driver yet, because I 1310 * haven't setup any initialization verbs for these yet... 1311 */ 1312 1313 static hda_nid_t alc880_w810_dac_nids[3] = { 1314 /* front, rear/surround, clfe */ 1315 0x02, 0x03, 0x04 1316 }; 1317 1318 /* fixed 6 channels */ 1319 static struct hda_channel_mode alc880_w810_modes[1] = { 1320 { 6, NULL } 1321 }; 1322 1323 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */ 1324 static struct snd_kcontrol_new alc880_w810_base_mixer[] = { 1325 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1326 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 1327 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1328 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 1329 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 1330 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 1331 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 1332 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 1333 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 1334 { } /* end */ 1335 }; 1336 1337 1338 /* 1339 * Z710V model 1340 * 1341 * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d) 1342 * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?), 1343 * Line = 0x1a 1344 */ 1345 1346 static hda_nid_t alc880_z71v_dac_nids[1] = { 1347 0x02 1348 }; 1349 #define ALC880_Z71V_HP_DAC 0x03 1350 1351 /* fixed 2 channels */ 1352 static struct hda_channel_mode alc880_2_jack_modes[1] = { 1353 { 2, NULL } 1354 }; 1355 1356 static struct snd_kcontrol_new alc880_z71v_mixer[] = { 1357 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1358 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 1359 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1360 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT), 1361 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1362 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1363 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1364 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1365 { } /* end */ 1366 }; 1367 1368 1369 /* 1370 * ALC880 F1734 model 1371 * 1372 * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d) 1373 * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18 1374 */ 1375 1376 static hda_nid_t alc880_f1734_dac_nids[1] = { 1377 0x03 1378 }; 1379 #define ALC880_F1734_HP_DAC 0x02 1380 1381 static struct snd_kcontrol_new alc880_f1734_mixer[] = { 1382 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1383 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 1384 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1385 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 1386 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1387 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1388 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 1389 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 1390 { } /* end */ 1391 }; 1392 1393 static struct hda_input_mux alc880_f1734_capture_source = { 1394 .num_items = 2, 1395 .items = { 1396 { "Mic", 0x1 }, 1397 { "CD", 0x4 }, 1398 }, 1399 }; 1400 1401 1402 /* 1403 * ALC880 ASUS model 1404 * 1405 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e) 1406 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16, 1407 * Mic = 0x18, Line = 0x1a 1408 */ 1409 1410 #define alc880_asus_dac_nids alc880_w810_dac_nids /* identical with w810 */ 1411 #define alc880_asus_modes alc880_threestack_modes /* 2/6 channel mode */ 1412 1413 static struct snd_kcontrol_new alc880_asus_mixer[] = { 1414 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1415 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 1416 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1417 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 1418 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 1419 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 1420 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 1421 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 1422 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1423 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1424 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 1425 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 1426 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1427 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1428 { 1429 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1430 .name = "Channel Mode", 1431 .info = alc_ch_mode_info, 1432 .get = alc_ch_mode_get, 1433 .put = alc_ch_mode_put, 1434 }, 1435 { } /* end */ 1436 }; 1437 1438 /* 1439 * ALC880 ASUS W1V model 1440 * 1441 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e) 1442 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16, 1443 * Mic = 0x18, Line = 0x1a, Line2 = 0x1b 1444 */ 1445 1446 /* additional mixers to alc880_asus_mixer */ 1447 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = { 1448 HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT), 1449 HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT), 1450 { } /* end */ 1451 }; 1452 1453 /* additional mixers to alc880_asus_mixer */ 1454 static struct snd_kcontrol_new alc880_pcbeep_mixer[] = { 1455 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 1456 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 1457 { } /* end */ 1458 }; 1459 1460 /* TCL S700 */ 1461 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = { 1462 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1463 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 1464 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 1465 HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT), 1466 HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT), 1467 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT), 1468 HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT), 1469 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 1470 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 1471 { 1472 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1473 /* The multiple "Capture Source" controls confuse alsamixer 1474 * So call somewhat different.. 1475 */ 1476 /* .name = "Capture Source", */ 1477 .name = "Input Source", 1478 .count = 1, 1479 .info = alc_mux_enum_info, 1480 .get = alc_mux_enum_get, 1481 .put = alc_mux_enum_put, 1482 }, 1483 { } /* end */ 1484 }; 1485 1486 /* Uniwill */ 1487 static struct snd_kcontrol_new alc880_uniwill_mixer[] = { 1488 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1489 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 1490 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1491 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 1492 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 1493 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 1494 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 1495 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 1496 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1497 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1498 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 1499 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 1500 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1501 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1502 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 1503 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 1504 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 1505 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 1506 { 1507 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1508 .name = "Channel Mode", 1509 .info = alc_ch_mode_info, 1510 .get = alc_ch_mode_get, 1511 .put = alc_ch_mode_put, 1512 }, 1513 { } /* end */ 1514 }; 1515 1516 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = { 1517 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1518 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 1519 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1520 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 1521 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1522 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1523 HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1524 HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1525 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 1526 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 1527 { } /* end */ 1528 }; 1529 1530 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = { 1531 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1532 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 1533 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1534 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 1535 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1536 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1537 { } /* end */ 1538 }; 1539 1540 /* 1541 * virtual master controls 1542 */ 1543 1544 /* 1545 * slave controls for virtual master 1546 */ 1547 static const char *alc_slave_vols[] = { 1548 "Front Playback Volume", 1549 "Surround Playback Volume", 1550 "Center Playback Volume", 1551 "LFE Playback Volume", 1552 "Side Playback Volume", 1553 "Headphone Playback Volume", 1554 "Speaker Playback Volume", 1555 "Mono Playback Volume", 1556 "Line-Out Playback Volume", 1557 NULL, 1558 }; 1559 1560 static const char *alc_slave_sws[] = { 1561 "Front Playback Switch", 1562 "Surround Playback Switch", 1563 "Center Playback Switch", 1564 "LFE Playback Switch", 1565 "Side Playback Switch", 1566 "Headphone Playback Switch", 1567 "Speaker Playback Switch", 1568 "Mono Playback Switch", 1569 "IEC958 Playback Switch", 1570 NULL, 1571 }; 1572 1573 /* 1574 * build control elements 1575 */ 1576 static int alc_build_controls(struct hda_codec *codec) 1577 { 1578 struct alc_spec *spec = codec->spec; 1579 int err; 1580 int i; 1581 1582 for (i = 0; i < spec->num_mixers; i++) { 1583 err = snd_hda_add_new_ctls(codec, spec->mixers[i]); 1584 if (err < 0) 1585 return err; 1586 } 1587 1588 if (spec->multiout.dig_out_nid) { 1589 err = snd_hda_create_spdif_out_ctls(codec, 1590 spec->multiout.dig_out_nid); 1591 if (err < 0) 1592 return err; 1593 err = snd_hda_create_spdif_share_sw(codec, 1594 &spec->multiout); 1595 if (err < 0) 1596 return err; 1597 spec->multiout.share_spdif = 1; 1598 } 1599 if (spec->dig_in_nid) { 1600 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid); 1601 if (err < 0) 1602 return err; 1603 } 1604 1605 /* if we have no master control, let's create it */ 1606 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) { 1607 unsigned int vmaster_tlv[4]; 1608 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid, 1609 HDA_OUTPUT, vmaster_tlv); 1610 err = snd_hda_add_vmaster(codec, "Master Playback Volume", 1611 vmaster_tlv, alc_slave_vols); 1612 if (err < 0) 1613 return err; 1614 } 1615 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) { 1616 err = snd_hda_add_vmaster(codec, "Master Playback Switch", 1617 NULL, alc_slave_sws); 1618 if (err < 0) 1619 return err; 1620 } 1621 1622 return 0; 1623 } 1624 1625 1626 /* 1627 * initialize the codec volumes, etc 1628 */ 1629 1630 /* 1631 * generic initialization of ADC, input mixers and output mixers 1632 */ 1633 static struct hda_verb alc880_volume_init_verbs[] = { 1634 /* 1635 * Unmute ADC0-2 and set the default input to mic-in 1636 */ 1637 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 1638 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1639 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 1640 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1641 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 1642 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1643 1644 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 1645 * mixer widget 1646 * Note: PASD motherboards uses the Line In 2 as the input for front 1647 * panel mic (mic 2) 1648 */ 1649 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 1650 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 1651 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 1652 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 1653 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 1654 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 1655 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 1656 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 1657 1658 /* 1659 * Set up output mixers (0x0c - 0x0f) 1660 */ 1661 /* set vol=0 to output mixers */ 1662 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1663 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1664 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1665 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1666 /* set up input amps for analog loopback */ 1667 /* Amp Indices: DAC = 0, mixer = 1 */ 1668 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 1669 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 1670 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 1671 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 1672 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 1673 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 1674 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 1675 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 1676 1677 { } 1678 }; 1679 1680 /* 1681 * 3-stack pin configuration: 1682 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b 1683 */ 1684 static struct hda_verb alc880_pin_3stack_init_verbs[] = { 1685 /* 1686 * preset connection lists of input pins 1687 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround 1688 */ 1689 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 1690 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 1691 {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */ 1692 1693 /* 1694 * Set pin mode and muting 1695 */ 1696 /* set front pin widgets 0x14 for output */ 1697 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1698 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1699 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 1700 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1701 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1702 /* Mic2 (as headphone out) for HP output */ 1703 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1704 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1705 /* Line In pin widget for input */ 1706 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1707 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1708 /* Line2 (as front mic) pin widget for input and vref at 80% */ 1709 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1710 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1711 /* CD pin widget for input */ 1712 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1713 1714 { } 1715 }; 1716 1717 /* 1718 * 5-stack pin configuration: 1719 * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19, 1720 * line-in/side = 0x1a, f-mic = 0x1b 1721 */ 1722 static struct hda_verb alc880_pin_5stack_init_verbs[] = { 1723 /* 1724 * preset connection lists of input pins 1725 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround 1726 */ 1727 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 1728 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */ 1729 1730 /* 1731 * Set pin mode and muting 1732 */ 1733 /* set pin widgets 0x14-0x17 for output */ 1734 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1735 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1736 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1737 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1738 /* unmute pins for output (no gain on this amp) */ 1739 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1740 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1741 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1742 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1743 1744 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 1745 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1746 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1747 /* Mic2 (as headphone out) for HP output */ 1748 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1749 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1750 /* Line In pin widget for input */ 1751 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1752 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1753 /* Line2 (as front mic) pin widget for input and vref at 80% */ 1754 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1755 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1756 /* CD pin widget for input */ 1757 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1758 1759 { } 1760 }; 1761 1762 /* 1763 * W810 pin configuration: 1764 * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b 1765 */ 1766 static struct hda_verb alc880_pin_w810_init_verbs[] = { 1767 /* hphone/speaker input selector: front DAC */ 1768 {0x13, AC_VERB_SET_CONNECT_SEL, 0x0}, 1769 1770 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1771 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1772 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1773 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1774 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1775 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1776 1777 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1778 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1779 1780 { } 1781 }; 1782 1783 /* 1784 * Z71V pin configuration: 1785 * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?) 1786 */ 1787 static struct hda_verb alc880_pin_z71v_init_verbs[] = { 1788 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1789 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1790 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1791 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1792 1793 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1794 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1795 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1796 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1797 1798 { } 1799 }; 1800 1801 /* 1802 * 6-stack pin configuration: 1803 * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18, 1804 * f-mic = 0x19, line = 0x1a, HP = 0x1b 1805 */ 1806 static struct hda_verb alc880_pin_6stack_init_verbs[] = { 1807 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 1808 1809 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1810 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1811 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1812 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1813 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1814 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1815 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1816 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1817 1818 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1819 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1820 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1821 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1822 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1823 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1824 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1825 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1826 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1827 1828 { } 1829 }; 1830 1831 /* 1832 * Uniwill pin configuration: 1833 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19, 1834 * line = 0x1a 1835 */ 1836 static struct hda_verb alc880_uniwill_init_verbs[] = { 1837 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 1838 1839 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1840 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1841 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1842 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1843 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1844 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1845 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1846 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1847 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 1848 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 1849 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 1850 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 1851 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 1852 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 1853 1854 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1855 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1856 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1857 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1858 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1859 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1860 /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */ 1861 /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */ 1862 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1863 1864 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 1865 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 1866 1867 { } 1868 }; 1869 1870 /* 1871 * Uniwill P53 1872 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19, 1873 */ 1874 static struct hda_verb alc880_uniwill_p53_init_verbs[] = { 1875 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 1876 1877 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1878 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1879 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1880 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1881 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1882 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1883 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 1884 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 1885 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 1886 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 1887 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 1888 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 1889 1890 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1891 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1892 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1893 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1894 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1895 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1896 1897 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 1898 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT}, 1899 1900 { } 1901 }; 1902 1903 static struct hda_verb alc880_beep_init_verbs[] = { 1904 { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) }, 1905 { } 1906 }; 1907 1908 /* toggle speaker-output according to the hp-jack state */ 1909 static void alc880_uniwill_hp_automute(struct hda_codec *codec) 1910 { 1911 unsigned int present; 1912 unsigned char bits; 1913 1914 present = snd_hda_codec_read(codec, 0x14, 0, 1915 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 1916 bits = present ? HDA_AMP_MUTE : 0; 1917 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 1918 HDA_AMP_MUTE, bits); 1919 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 1920 HDA_AMP_MUTE, bits); 1921 } 1922 1923 /* auto-toggle front mic */ 1924 static void alc880_uniwill_mic_automute(struct hda_codec *codec) 1925 { 1926 unsigned int present; 1927 unsigned char bits; 1928 1929 present = snd_hda_codec_read(codec, 0x18, 0, 1930 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 1931 bits = present ? HDA_AMP_MUTE : 0; 1932 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits); 1933 } 1934 1935 static void alc880_uniwill_automute(struct hda_codec *codec) 1936 { 1937 alc880_uniwill_hp_automute(codec); 1938 alc880_uniwill_mic_automute(codec); 1939 } 1940 1941 static void alc880_uniwill_unsol_event(struct hda_codec *codec, 1942 unsigned int res) 1943 { 1944 /* Looks like the unsol event is incompatible with the standard 1945 * definition. 4bit tag is placed at 28 bit! 1946 */ 1947 switch (res >> 28) { 1948 case ALC880_HP_EVENT: 1949 alc880_uniwill_hp_automute(codec); 1950 break; 1951 case ALC880_MIC_EVENT: 1952 alc880_uniwill_mic_automute(codec); 1953 break; 1954 } 1955 } 1956 1957 static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec) 1958 { 1959 unsigned int present; 1960 unsigned char bits; 1961 1962 present = snd_hda_codec_read(codec, 0x14, 0, 1963 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 1964 bits = present ? HDA_AMP_MUTE : 0; 1965 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, HDA_AMP_MUTE, bits); 1966 } 1967 1968 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec) 1969 { 1970 unsigned int present; 1971 1972 present = snd_hda_codec_read(codec, 0x21, 0, 1973 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0); 1974 present &= HDA_AMP_VOLMASK; 1975 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, 1976 HDA_AMP_VOLMASK, present); 1977 snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0, 1978 HDA_AMP_VOLMASK, present); 1979 } 1980 1981 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec, 1982 unsigned int res) 1983 { 1984 /* Looks like the unsol event is incompatible with the standard 1985 * definition. 4bit tag is placed at 28 bit! 1986 */ 1987 if ((res >> 28) == ALC880_HP_EVENT) 1988 alc880_uniwill_p53_hp_automute(codec); 1989 if ((res >> 28) == ALC880_DCVOL_EVENT) 1990 alc880_uniwill_p53_dcvol_automute(codec); 1991 } 1992 1993 /* 1994 * F1734 pin configuration: 1995 * HP = 0x14, speaker-out = 0x15, mic = 0x18 1996 */ 1997 static struct hda_verb alc880_pin_f1734_init_verbs[] = { 1998 {0x07, AC_VERB_SET_CONNECT_SEL, 0x01}, 1999 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, 2000 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, 2001 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, 2002 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, 2003 2004 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2005 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2006 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2007 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2008 2009 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2010 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2011 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50}, 2012 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2013 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2014 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2015 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2016 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2017 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2018 2019 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT}, 2020 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT}, 2021 2022 { } 2023 }; 2024 2025 /* 2026 * ASUS pin configuration: 2027 * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a 2028 */ 2029 static struct hda_verb alc880_pin_asus_init_verbs[] = { 2030 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, 2031 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, 2032 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, 2033 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, 2034 2035 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2036 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2037 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2038 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2039 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2040 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2041 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2042 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2043 2044 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2045 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2046 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2047 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2048 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2049 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2050 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2051 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2052 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2053 2054 { } 2055 }; 2056 2057 /* Enable GPIO mask and set output */ 2058 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs 2059 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs 2060 2061 /* Clevo m520g init */ 2062 static struct hda_verb alc880_pin_clevo_init_verbs[] = { 2063 /* headphone output */ 2064 {0x11, AC_VERB_SET_CONNECT_SEL, 0x01}, 2065 /* line-out */ 2066 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2067 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2068 /* Line-in */ 2069 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2070 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2071 /* CD */ 2072 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2073 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2074 /* Mic1 (rear panel) */ 2075 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2076 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2077 /* Mic2 (front panel) */ 2078 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2079 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2080 /* headphone */ 2081 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2082 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2083 /* change to EAPD mode */ 2084 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 2085 {0x20, AC_VERB_SET_PROC_COEF, 0x3060}, 2086 2087 { } 2088 }; 2089 2090 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = { 2091 /* change to EAPD mode */ 2092 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 2093 {0x20, AC_VERB_SET_PROC_COEF, 0x3060}, 2094 2095 /* Headphone output */ 2096 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2097 /* Front output*/ 2098 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2099 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 2100 2101 /* Line In pin widget for input */ 2102 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2103 /* CD pin widget for input */ 2104 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2105 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 2106 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2107 2108 /* change to EAPD mode */ 2109 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 2110 {0x20, AC_VERB_SET_PROC_COEF, 0x3070}, 2111 2112 { } 2113 }; 2114 2115 /* 2116 * LG m1 express dual 2117 * 2118 * Pin assignment: 2119 * Rear Line-In/Out (blue): 0x14 2120 * Build-in Mic-In: 0x15 2121 * Speaker-out: 0x17 2122 * HP-Out (green): 0x1b 2123 * Mic-In/Out (red): 0x19 2124 * SPDIF-Out: 0x1e 2125 */ 2126 2127 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */ 2128 static hda_nid_t alc880_lg_dac_nids[3] = { 2129 0x05, 0x02, 0x03 2130 }; 2131 2132 /* seems analog CD is not working */ 2133 static struct hda_input_mux alc880_lg_capture_source = { 2134 .num_items = 3, 2135 .items = { 2136 { "Mic", 0x1 }, 2137 { "Line", 0x5 }, 2138 { "Internal Mic", 0x6 }, 2139 }, 2140 }; 2141 2142 /* 2,4,6 channel modes */ 2143 static struct hda_verb alc880_lg_ch2_init[] = { 2144 /* set line-in and mic-in to input */ 2145 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 2146 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 2147 { } 2148 }; 2149 2150 static struct hda_verb alc880_lg_ch4_init[] = { 2151 /* set line-in to out and mic-in to input */ 2152 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, 2153 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 2154 { } 2155 }; 2156 2157 static struct hda_verb alc880_lg_ch6_init[] = { 2158 /* set line-in and mic-in to output */ 2159 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, 2160 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, 2161 { } 2162 }; 2163 2164 static struct hda_channel_mode alc880_lg_ch_modes[3] = { 2165 { 2, alc880_lg_ch2_init }, 2166 { 4, alc880_lg_ch4_init }, 2167 { 6, alc880_lg_ch6_init }, 2168 }; 2169 2170 static struct snd_kcontrol_new alc880_lg_mixer[] = { 2171 HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 2172 HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT), 2173 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2174 HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT), 2175 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT), 2176 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT), 2177 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT), 2178 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT), 2179 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 2180 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 2181 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT), 2182 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT), 2183 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT), 2184 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT), 2185 { 2186 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2187 .name = "Channel Mode", 2188 .info = alc_ch_mode_info, 2189 .get = alc_ch_mode_get, 2190 .put = alc_ch_mode_put, 2191 }, 2192 { } /* end */ 2193 }; 2194 2195 static struct hda_verb alc880_lg_init_verbs[] = { 2196 /* set capture source to mic-in */ 2197 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2198 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2199 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2200 /* mute all amp mixer inputs */ 2201 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)}, 2202 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 2203 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 2204 /* line-in to input */ 2205 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2206 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2207 /* built-in mic */ 2208 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2209 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2210 /* speaker-out */ 2211 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2212 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2213 /* mic-in to input */ 2214 {0x11, AC_VERB_SET_CONNECT_SEL, 0x01}, 2215 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2216 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2217 /* HP-out */ 2218 {0x13, AC_VERB_SET_CONNECT_SEL, 0x03}, 2219 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2220 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2221 /* jack sense */ 2222 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1}, 2223 { } 2224 }; 2225 2226 /* toggle speaker-output according to the hp-jack state */ 2227 static void alc880_lg_automute(struct hda_codec *codec) 2228 { 2229 unsigned int present; 2230 unsigned char bits; 2231 2232 present = snd_hda_codec_read(codec, 0x1b, 0, 2233 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 2234 bits = present ? HDA_AMP_MUTE : 0; 2235 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0, 2236 HDA_AMP_MUTE, bits); 2237 } 2238 2239 static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res) 2240 { 2241 /* Looks like the unsol event is incompatible with the standard 2242 * definition. 4bit tag is placed at 28 bit! 2243 */ 2244 if ((res >> 28) == 0x01) 2245 alc880_lg_automute(codec); 2246 } 2247 2248 /* 2249 * LG LW20 2250 * 2251 * Pin assignment: 2252 * Speaker-out: 0x14 2253 * Mic-In: 0x18 2254 * Built-in Mic-In: 0x19 2255 * Line-In: 0x1b 2256 * HP-Out: 0x1a 2257 * SPDIF-Out: 0x1e 2258 */ 2259 2260 static struct hda_input_mux alc880_lg_lw_capture_source = { 2261 .num_items = 3, 2262 .items = { 2263 { "Mic", 0x0 }, 2264 { "Internal Mic", 0x1 }, 2265 { "Line In", 0x2 }, 2266 }, 2267 }; 2268 2269 #define alc880_lg_lw_modes alc880_threestack_modes 2270 2271 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = { 2272 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2273 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 2274 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 2275 HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT), 2276 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 2277 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 2278 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 2279 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 2280 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 2281 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 2282 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 2283 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 2284 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 2285 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 2286 { 2287 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2288 .name = "Channel Mode", 2289 .info = alc_ch_mode_info, 2290 .get = alc_ch_mode_get, 2291 .put = alc_ch_mode_put, 2292 }, 2293 { } /* end */ 2294 }; 2295 2296 static struct hda_verb alc880_lg_lw_init_verbs[] = { 2297 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 2298 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 2299 {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */ 2300 2301 /* set capture source to mic-in */ 2302 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2303 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2304 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2305 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 2306 /* speaker-out */ 2307 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2308 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2309 /* HP-out */ 2310 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2311 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2312 /* mic-in to input */ 2313 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2314 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2315 /* built-in mic */ 2316 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2317 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2318 /* jack sense */ 2319 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1}, 2320 { } 2321 }; 2322 2323 /* toggle speaker-output according to the hp-jack state */ 2324 static void alc880_lg_lw_automute(struct hda_codec *codec) 2325 { 2326 unsigned int present; 2327 unsigned char bits; 2328 2329 present = snd_hda_codec_read(codec, 0x1b, 0, 2330 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 2331 bits = present ? HDA_AMP_MUTE : 0; 2332 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 2333 HDA_AMP_MUTE, bits); 2334 } 2335 2336 static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res) 2337 { 2338 /* Looks like the unsol event is incompatible with the standard 2339 * definition. 4bit tag is placed at 28 bit! 2340 */ 2341 if ((res >> 28) == 0x01) 2342 alc880_lg_lw_automute(codec); 2343 } 2344 2345 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = { 2346 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2347 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT), 2348 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 2349 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 2350 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 2351 HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT), 2352 { } /* end */ 2353 }; 2354 2355 static struct hda_input_mux alc880_medion_rim_capture_source = { 2356 .num_items = 2, 2357 .items = { 2358 { "Mic", 0x0 }, 2359 { "Internal Mic", 0x1 }, 2360 }, 2361 }; 2362 2363 static struct hda_verb alc880_medion_rim_init_verbs[] = { 2364 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 2365 2366 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2367 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2368 2369 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 2370 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2371 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2372 /* Mic2 (as headphone out) for HP output */ 2373 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2374 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2375 /* Internal Speaker */ 2376 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2377 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2378 2379 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 2380 {0x20, AC_VERB_SET_PROC_COEF, 0x3060}, 2381 2382 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 2383 { } 2384 }; 2385 2386 /* toggle speaker-output according to the hp-jack state */ 2387 static void alc880_medion_rim_automute(struct hda_codec *codec) 2388 { 2389 unsigned int present; 2390 unsigned char bits; 2391 2392 present = snd_hda_codec_read(codec, 0x14, 0, 2393 AC_VERB_GET_PIN_SENSE, 0) 2394 & AC_PINSENSE_PRESENCE; 2395 bits = present ? HDA_AMP_MUTE : 0; 2396 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 2397 HDA_AMP_MUTE, bits); 2398 if (present) 2399 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0); 2400 else 2401 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2); 2402 } 2403 2404 static void alc880_medion_rim_unsol_event(struct hda_codec *codec, 2405 unsigned int res) 2406 { 2407 /* Looks like the unsol event is incompatible with the standard 2408 * definition. 4bit tag is placed at 28 bit! 2409 */ 2410 if ((res >> 28) == ALC880_HP_EVENT) 2411 alc880_medion_rim_automute(codec); 2412 } 2413 2414 #ifdef CONFIG_SND_HDA_POWER_SAVE 2415 static struct hda_amp_list alc880_loopbacks[] = { 2416 { 0x0b, HDA_INPUT, 0 }, 2417 { 0x0b, HDA_INPUT, 1 }, 2418 { 0x0b, HDA_INPUT, 2 }, 2419 { 0x0b, HDA_INPUT, 3 }, 2420 { 0x0b, HDA_INPUT, 4 }, 2421 { } /* end */ 2422 }; 2423 2424 static struct hda_amp_list alc880_lg_loopbacks[] = { 2425 { 0x0b, HDA_INPUT, 1 }, 2426 { 0x0b, HDA_INPUT, 6 }, 2427 { 0x0b, HDA_INPUT, 7 }, 2428 { } /* end */ 2429 }; 2430 #endif 2431 2432 /* 2433 * Common callbacks 2434 */ 2435 2436 static int alc_init(struct hda_codec *codec) 2437 { 2438 struct alc_spec *spec = codec->spec; 2439 unsigned int i; 2440 2441 alc_fix_pll(codec); 2442 2443 for (i = 0; i < spec->num_init_verbs; i++) 2444 snd_hda_sequence_write(codec, spec->init_verbs[i]); 2445 2446 if (spec->init_hook) 2447 spec->init_hook(codec); 2448 2449 return 0; 2450 } 2451 2452 static void alc_unsol_event(struct hda_codec *codec, unsigned int res) 2453 { 2454 struct alc_spec *spec = codec->spec; 2455 2456 if (spec->unsol_event) 2457 spec->unsol_event(codec, res); 2458 } 2459 2460 #ifdef CONFIG_SND_HDA_POWER_SAVE 2461 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid) 2462 { 2463 struct alc_spec *spec = codec->spec; 2464 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid); 2465 } 2466 #endif 2467 2468 /* 2469 * Analog playback callbacks 2470 */ 2471 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo, 2472 struct hda_codec *codec, 2473 struct snd_pcm_substream *substream) 2474 { 2475 struct alc_spec *spec = codec->spec; 2476 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, 2477 hinfo); 2478 } 2479 2480 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 2481 struct hda_codec *codec, 2482 unsigned int stream_tag, 2483 unsigned int format, 2484 struct snd_pcm_substream *substream) 2485 { 2486 struct alc_spec *spec = codec->spec; 2487 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, 2488 stream_tag, format, substream); 2489 } 2490 2491 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 2492 struct hda_codec *codec, 2493 struct snd_pcm_substream *substream) 2494 { 2495 struct alc_spec *spec = codec->spec; 2496 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); 2497 } 2498 2499 /* 2500 * Digital out 2501 */ 2502 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, 2503 struct hda_codec *codec, 2504 struct snd_pcm_substream *substream) 2505 { 2506 struct alc_spec *spec = codec->spec; 2507 return snd_hda_multi_out_dig_open(codec, &spec->multiout); 2508 } 2509 2510 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 2511 struct hda_codec *codec, 2512 unsigned int stream_tag, 2513 unsigned int format, 2514 struct snd_pcm_substream *substream) 2515 { 2516 struct alc_spec *spec = codec->spec; 2517 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, 2518 stream_tag, format, substream); 2519 } 2520 2521 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, 2522 struct hda_codec *codec, 2523 struct snd_pcm_substream *substream) 2524 { 2525 struct alc_spec *spec = codec->spec; 2526 return snd_hda_multi_out_dig_close(codec, &spec->multiout); 2527 } 2528 2529 /* 2530 * Analog capture 2531 */ 2532 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 2533 struct hda_codec *codec, 2534 unsigned int stream_tag, 2535 unsigned int format, 2536 struct snd_pcm_substream *substream) 2537 { 2538 struct alc_spec *spec = codec->spec; 2539 2540 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1], 2541 stream_tag, 0, format); 2542 return 0; 2543 } 2544 2545 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 2546 struct hda_codec *codec, 2547 struct snd_pcm_substream *substream) 2548 { 2549 struct alc_spec *spec = codec->spec; 2550 2551 snd_hda_codec_cleanup_stream(codec, 2552 spec->adc_nids[substream->number + 1]); 2553 return 0; 2554 } 2555 2556 2557 /* 2558 */ 2559 static struct hda_pcm_stream alc880_pcm_analog_playback = { 2560 .substreams = 1, 2561 .channels_min = 2, 2562 .channels_max = 8, 2563 /* NID is set in alc_build_pcms */ 2564 .ops = { 2565 .open = alc880_playback_pcm_open, 2566 .prepare = alc880_playback_pcm_prepare, 2567 .cleanup = alc880_playback_pcm_cleanup 2568 }, 2569 }; 2570 2571 static struct hda_pcm_stream alc880_pcm_analog_capture = { 2572 .substreams = 1, 2573 .channels_min = 2, 2574 .channels_max = 2, 2575 /* NID is set in alc_build_pcms */ 2576 }; 2577 2578 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = { 2579 .substreams = 1, 2580 .channels_min = 2, 2581 .channels_max = 2, 2582 /* NID is set in alc_build_pcms */ 2583 }; 2584 2585 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = { 2586 .substreams = 2, /* can be overridden */ 2587 .channels_min = 2, 2588 .channels_max = 2, 2589 /* NID is set in alc_build_pcms */ 2590 .ops = { 2591 .prepare = alc880_alt_capture_pcm_prepare, 2592 .cleanup = alc880_alt_capture_pcm_cleanup 2593 }, 2594 }; 2595 2596 static struct hda_pcm_stream alc880_pcm_digital_playback = { 2597 .substreams = 1, 2598 .channels_min = 2, 2599 .channels_max = 2, 2600 /* NID is set in alc_build_pcms */ 2601 .ops = { 2602 .open = alc880_dig_playback_pcm_open, 2603 .close = alc880_dig_playback_pcm_close, 2604 .prepare = alc880_dig_playback_pcm_prepare 2605 }, 2606 }; 2607 2608 static struct hda_pcm_stream alc880_pcm_digital_capture = { 2609 .substreams = 1, 2610 .channels_min = 2, 2611 .channels_max = 2, 2612 /* NID is set in alc_build_pcms */ 2613 }; 2614 2615 /* Used by alc_build_pcms to flag that a PCM has no playback stream */ 2616 static struct hda_pcm_stream alc_pcm_null_stream = { 2617 .substreams = 0, 2618 .channels_min = 0, 2619 .channels_max = 0, 2620 }; 2621 2622 static int alc_build_pcms(struct hda_codec *codec) 2623 { 2624 struct alc_spec *spec = codec->spec; 2625 struct hda_pcm *info = spec->pcm_rec; 2626 int i; 2627 2628 codec->num_pcms = 1; 2629 codec->pcm_info = info; 2630 2631 info->name = spec->stream_name_analog; 2632 if (spec->stream_analog_playback) { 2633 snd_assert(spec->multiout.dac_nids, return -EINVAL); 2634 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback); 2635 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0]; 2636 } 2637 if (spec->stream_analog_capture) { 2638 snd_assert(spec->adc_nids, return -EINVAL); 2639 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture); 2640 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; 2641 } 2642 2643 if (spec->channel_mode) { 2644 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0; 2645 for (i = 0; i < spec->num_channel_mode; i++) { 2646 if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) { 2647 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels; 2648 } 2649 } 2650 } 2651 2652 /* SPDIF for stream index #1 */ 2653 if (spec->multiout.dig_out_nid || spec->dig_in_nid) { 2654 codec->num_pcms = 2; 2655 info = spec->pcm_rec + 1; 2656 info->name = spec->stream_name_digital; 2657 info->pcm_type = HDA_PCM_TYPE_SPDIF; 2658 if (spec->multiout.dig_out_nid && 2659 spec->stream_digital_playback) { 2660 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback); 2661 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid; 2662 } 2663 if (spec->dig_in_nid && 2664 spec->stream_digital_capture) { 2665 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture); 2666 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid; 2667 } 2668 } 2669 2670 /* If the use of more than one ADC is requested for the current 2671 * model, configure a second analog capture-only PCM. 2672 */ 2673 /* Additional Analaog capture for index #2 */ 2674 if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) || 2675 (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) { 2676 codec->num_pcms = 3; 2677 info = spec->pcm_rec + 2; 2678 info->name = spec->stream_name_analog; 2679 if (spec->alt_dac_nid) { 2680 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 2681 *spec->stream_analog_alt_playback; 2682 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 2683 spec->alt_dac_nid; 2684 } else { 2685 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 2686 alc_pcm_null_stream; 2687 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0; 2688 } 2689 if (spec->num_adc_nids > 1) { 2690 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 2691 *spec->stream_analog_alt_capture; 2692 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 2693 spec->adc_nids[1]; 2694 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 2695 spec->num_adc_nids - 1; 2696 } else { 2697 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 2698 alc_pcm_null_stream; 2699 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0; 2700 } 2701 } 2702 2703 return 0; 2704 } 2705 2706 static void alc_free(struct hda_codec *codec) 2707 { 2708 struct alc_spec *spec = codec->spec; 2709 unsigned int i; 2710 2711 if (!spec) 2712 return; 2713 2714 if (spec->kctl_alloc) { 2715 for (i = 0; i < spec->num_kctl_used; i++) 2716 kfree(spec->kctl_alloc[i].name); 2717 kfree(spec->kctl_alloc); 2718 } 2719 kfree(spec); 2720 codec->spec = NULL; /* to be sure */ 2721 } 2722 2723 /* 2724 */ 2725 static struct hda_codec_ops alc_patch_ops = { 2726 .build_controls = alc_build_controls, 2727 .build_pcms = alc_build_pcms, 2728 .init = alc_init, 2729 .free = alc_free, 2730 .unsol_event = alc_unsol_event, 2731 #ifdef CONFIG_SND_HDA_POWER_SAVE 2732 .check_power_status = alc_check_power_status, 2733 #endif 2734 }; 2735 2736 2737 /* 2738 * Test configuration for debugging 2739 * 2740 * Almost all inputs/outputs are enabled. I/O pins can be configured via 2741 * enum controls. 2742 */ 2743 #ifdef CONFIG_SND_DEBUG 2744 static hda_nid_t alc880_test_dac_nids[4] = { 2745 0x02, 0x03, 0x04, 0x05 2746 }; 2747 2748 static struct hda_input_mux alc880_test_capture_source = { 2749 .num_items = 7, 2750 .items = { 2751 { "In-1", 0x0 }, 2752 { "In-2", 0x1 }, 2753 { "In-3", 0x2 }, 2754 { "In-4", 0x3 }, 2755 { "CD", 0x4 }, 2756 { "Front", 0x5 }, 2757 { "Surround", 0x6 }, 2758 }, 2759 }; 2760 2761 static struct hda_channel_mode alc880_test_modes[4] = { 2762 { 2, NULL }, 2763 { 4, NULL }, 2764 { 6, NULL }, 2765 { 8, NULL }, 2766 }; 2767 2768 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol, 2769 struct snd_ctl_elem_info *uinfo) 2770 { 2771 static char *texts[] = { 2772 "N/A", "Line Out", "HP Out", 2773 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%" 2774 }; 2775 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 2776 uinfo->count = 1; 2777 uinfo->value.enumerated.items = 8; 2778 if (uinfo->value.enumerated.item >= 8) 2779 uinfo->value.enumerated.item = 7; 2780 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 2781 return 0; 2782 } 2783 2784 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol, 2785 struct snd_ctl_elem_value *ucontrol) 2786 { 2787 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2788 hda_nid_t nid = (hda_nid_t)kcontrol->private_value; 2789 unsigned int pin_ctl, item = 0; 2790 2791 pin_ctl = snd_hda_codec_read(codec, nid, 0, 2792 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 2793 if (pin_ctl & AC_PINCTL_OUT_EN) { 2794 if (pin_ctl & AC_PINCTL_HP_EN) 2795 item = 2; 2796 else 2797 item = 1; 2798 } else if (pin_ctl & AC_PINCTL_IN_EN) { 2799 switch (pin_ctl & AC_PINCTL_VREFEN) { 2800 case AC_PINCTL_VREF_HIZ: item = 3; break; 2801 case AC_PINCTL_VREF_50: item = 4; break; 2802 case AC_PINCTL_VREF_GRD: item = 5; break; 2803 case AC_PINCTL_VREF_80: item = 6; break; 2804 case AC_PINCTL_VREF_100: item = 7; break; 2805 } 2806 } 2807 ucontrol->value.enumerated.item[0] = item; 2808 return 0; 2809 } 2810 2811 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol, 2812 struct snd_ctl_elem_value *ucontrol) 2813 { 2814 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2815 hda_nid_t nid = (hda_nid_t)kcontrol->private_value; 2816 static unsigned int ctls[] = { 2817 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN, 2818 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ, 2819 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50, 2820 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD, 2821 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80, 2822 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100, 2823 }; 2824 unsigned int old_ctl, new_ctl; 2825 2826 old_ctl = snd_hda_codec_read(codec, nid, 0, 2827 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 2828 new_ctl = ctls[ucontrol->value.enumerated.item[0]]; 2829 if (old_ctl != new_ctl) { 2830 int val; 2831 snd_hda_codec_write_cache(codec, nid, 0, 2832 AC_VERB_SET_PIN_WIDGET_CONTROL, 2833 new_ctl); 2834 val = ucontrol->value.enumerated.item[0] >= 3 ? 2835 HDA_AMP_MUTE : 0; 2836 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 2837 HDA_AMP_MUTE, val); 2838 return 1; 2839 } 2840 return 0; 2841 } 2842 2843 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol, 2844 struct snd_ctl_elem_info *uinfo) 2845 { 2846 static char *texts[] = { 2847 "Front", "Surround", "CLFE", "Side" 2848 }; 2849 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 2850 uinfo->count = 1; 2851 uinfo->value.enumerated.items = 4; 2852 if (uinfo->value.enumerated.item >= 4) 2853 uinfo->value.enumerated.item = 3; 2854 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 2855 return 0; 2856 } 2857 2858 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol, 2859 struct snd_ctl_elem_value *ucontrol) 2860 { 2861 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2862 hda_nid_t nid = (hda_nid_t)kcontrol->private_value; 2863 unsigned int sel; 2864 2865 sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0); 2866 ucontrol->value.enumerated.item[0] = sel & 3; 2867 return 0; 2868 } 2869 2870 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol, 2871 struct snd_ctl_elem_value *ucontrol) 2872 { 2873 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2874 hda_nid_t nid = (hda_nid_t)kcontrol->private_value; 2875 unsigned int sel; 2876 2877 sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3; 2878 if (ucontrol->value.enumerated.item[0] != sel) { 2879 sel = ucontrol->value.enumerated.item[0] & 3; 2880 snd_hda_codec_write_cache(codec, nid, 0, 2881 AC_VERB_SET_CONNECT_SEL, sel); 2882 return 1; 2883 } 2884 return 0; 2885 } 2886 2887 #define PIN_CTL_TEST(xname,nid) { \ 2888 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 2889 .name = xname, \ 2890 .info = alc_test_pin_ctl_info, \ 2891 .get = alc_test_pin_ctl_get, \ 2892 .put = alc_test_pin_ctl_put, \ 2893 .private_value = nid \ 2894 } 2895 2896 #define PIN_SRC_TEST(xname,nid) { \ 2897 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 2898 .name = xname, \ 2899 .info = alc_test_pin_src_info, \ 2900 .get = alc_test_pin_src_get, \ 2901 .put = alc_test_pin_src_put, \ 2902 .private_value = nid \ 2903 } 2904 2905 static struct snd_kcontrol_new alc880_test_mixer[] = { 2906 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2907 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 2908 HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT), 2909 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 2910 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 2911 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 2912 HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT), 2913 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 2914 PIN_CTL_TEST("Front Pin Mode", 0x14), 2915 PIN_CTL_TEST("Surround Pin Mode", 0x15), 2916 PIN_CTL_TEST("CLFE Pin Mode", 0x16), 2917 PIN_CTL_TEST("Side Pin Mode", 0x17), 2918 PIN_CTL_TEST("In-1 Pin Mode", 0x18), 2919 PIN_CTL_TEST("In-2 Pin Mode", 0x19), 2920 PIN_CTL_TEST("In-3 Pin Mode", 0x1a), 2921 PIN_CTL_TEST("In-4 Pin Mode", 0x1b), 2922 PIN_SRC_TEST("In-1 Pin Source", 0x18), 2923 PIN_SRC_TEST("In-2 Pin Source", 0x19), 2924 PIN_SRC_TEST("In-3 Pin Source", 0x1a), 2925 PIN_SRC_TEST("In-4 Pin Source", 0x1b), 2926 HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT), 2927 HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT), 2928 HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT), 2929 HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT), 2930 HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT), 2931 HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT), 2932 HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT), 2933 HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT), 2934 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT), 2935 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT), 2936 { 2937 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2938 .name = "Channel Mode", 2939 .info = alc_ch_mode_info, 2940 .get = alc_ch_mode_get, 2941 .put = alc_ch_mode_put, 2942 }, 2943 { } /* end */ 2944 }; 2945 2946 static struct hda_verb alc880_test_init_verbs[] = { 2947 /* Unmute inputs of 0x0c - 0x0f */ 2948 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2949 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2950 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2951 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2952 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2953 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2954 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2955 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2956 /* Vol output for 0x0c-0x0f */ 2957 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2958 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2959 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2960 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2961 /* Set output pins 0x14-0x17 */ 2962 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2963 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2964 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2965 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2966 /* Unmute output pins 0x14-0x17 */ 2967 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2968 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2969 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2970 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2971 /* Set input pins 0x18-0x1c */ 2972 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2973 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2974 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2975 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2976 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2977 /* Mute input pins 0x18-0x1b */ 2978 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2979 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2980 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2981 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2982 /* ADC set up */ 2983 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2984 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 2985 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2986 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 2987 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2988 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 2989 /* Analog input/passthru */ 2990 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2991 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2992 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 2993 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 2994 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 2995 { } 2996 }; 2997 #endif 2998 2999 /* 3000 */ 3001 3002 static const char *alc880_models[ALC880_MODEL_LAST] = { 3003 [ALC880_3ST] = "3stack", 3004 [ALC880_TCL_S700] = "tcl", 3005 [ALC880_3ST_DIG] = "3stack-digout", 3006 [ALC880_CLEVO] = "clevo", 3007 [ALC880_5ST] = "5stack", 3008 [ALC880_5ST_DIG] = "5stack-digout", 3009 [ALC880_W810] = "w810", 3010 [ALC880_Z71V] = "z71v", 3011 [ALC880_6ST] = "6stack", 3012 [ALC880_6ST_DIG] = "6stack-digout", 3013 [ALC880_ASUS] = "asus", 3014 [ALC880_ASUS_W1V] = "asus-w1v", 3015 [ALC880_ASUS_DIG] = "asus-dig", 3016 [ALC880_ASUS_DIG2] = "asus-dig2", 3017 [ALC880_UNIWILL_DIG] = "uniwill", 3018 [ALC880_UNIWILL_P53] = "uniwill-p53", 3019 [ALC880_FUJITSU] = "fujitsu", 3020 [ALC880_F1734] = "F1734", 3021 [ALC880_LG] = "lg", 3022 [ALC880_LG_LW] = "lg-lw", 3023 [ALC880_MEDION_RIM] = "medion", 3024 #ifdef CONFIG_SND_DEBUG 3025 [ALC880_TEST] = "test", 3026 #endif 3027 [ALC880_AUTO] = "auto", 3028 }; 3029 3030 static struct snd_pci_quirk alc880_cfg_tbl[] = { 3031 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810), 3032 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG), 3033 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST), 3034 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG), 3035 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG), 3036 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG), 3037 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG), 3038 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG), 3039 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST), 3040 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG), 3041 SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST), 3042 SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V), 3043 SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG), 3044 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG), 3045 SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG), 3046 SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG), 3047 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG), 3048 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V), 3049 /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */ 3050 SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG), 3051 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG), 3052 SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG), 3053 SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG), 3054 SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST), 3055 SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST), 3056 SND_PCI_QUIRK(0x1043, 0, "ASUS", ALC880_ASUS), /* default ASUS */ 3057 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST), 3058 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST), 3059 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST), 3060 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST), 3061 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST), 3062 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG), 3063 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG), 3064 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG), 3065 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG), 3066 SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO), 3067 SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO), 3068 SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2), 3069 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG), 3070 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG), 3071 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734), 3072 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL), 3073 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53), 3074 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810), 3075 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM), 3076 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG), 3077 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG), 3078 SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734), 3079 SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU), 3080 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL), 3081 SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU), 3082 SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW), 3083 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG), 3084 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG), 3085 SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW), 3086 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700), 3087 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */ 3088 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG), 3089 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG), 3090 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG), 3091 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG), 3092 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG), 3093 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG), 3094 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG), 3095 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG), 3096 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG), 3097 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG), 3098 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG), 3099 SND_PCI_QUIRK(0x8086, 0, "Intel mobo", ALC880_3ST), /* default Intel */ 3100 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG), 3101 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG), 3102 {} 3103 }; 3104 3105 /* 3106 * ALC880 codec presets 3107 */ 3108 static struct alc_config_preset alc880_presets[] = { 3109 [ALC880_3ST] = { 3110 .mixers = { alc880_three_stack_mixer }, 3111 .init_verbs = { alc880_volume_init_verbs, 3112 alc880_pin_3stack_init_verbs }, 3113 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3114 .dac_nids = alc880_dac_nids, 3115 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 3116 .channel_mode = alc880_threestack_modes, 3117 .need_dac_fix = 1, 3118 .input_mux = &alc880_capture_source, 3119 }, 3120 [ALC880_3ST_DIG] = { 3121 .mixers = { alc880_three_stack_mixer }, 3122 .init_verbs = { alc880_volume_init_verbs, 3123 alc880_pin_3stack_init_verbs }, 3124 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3125 .dac_nids = alc880_dac_nids, 3126 .dig_out_nid = ALC880_DIGOUT_NID, 3127 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 3128 .channel_mode = alc880_threestack_modes, 3129 .need_dac_fix = 1, 3130 .input_mux = &alc880_capture_source, 3131 }, 3132 [ALC880_TCL_S700] = { 3133 .mixers = { alc880_tcl_s700_mixer }, 3134 .init_verbs = { alc880_volume_init_verbs, 3135 alc880_pin_tcl_S700_init_verbs, 3136 alc880_gpio2_init_verbs }, 3137 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3138 .dac_nids = alc880_dac_nids, 3139 .hp_nid = 0x03, 3140 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 3141 .channel_mode = alc880_2_jack_modes, 3142 .input_mux = &alc880_capture_source, 3143 }, 3144 [ALC880_5ST] = { 3145 .mixers = { alc880_three_stack_mixer, 3146 alc880_five_stack_mixer}, 3147 .init_verbs = { alc880_volume_init_verbs, 3148 alc880_pin_5stack_init_verbs }, 3149 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3150 .dac_nids = alc880_dac_nids, 3151 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes), 3152 .channel_mode = alc880_fivestack_modes, 3153 .input_mux = &alc880_capture_source, 3154 }, 3155 [ALC880_5ST_DIG] = { 3156 .mixers = { alc880_three_stack_mixer, 3157 alc880_five_stack_mixer }, 3158 .init_verbs = { alc880_volume_init_verbs, 3159 alc880_pin_5stack_init_verbs }, 3160 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3161 .dac_nids = alc880_dac_nids, 3162 .dig_out_nid = ALC880_DIGOUT_NID, 3163 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes), 3164 .channel_mode = alc880_fivestack_modes, 3165 .input_mux = &alc880_capture_source, 3166 }, 3167 [ALC880_6ST] = { 3168 .mixers = { alc880_six_stack_mixer }, 3169 .init_verbs = { alc880_volume_init_verbs, 3170 alc880_pin_6stack_init_verbs }, 3171 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids), 3172 .dac_nids = alc880_6st_dac_nids, 3173 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes), 3174 .channel_mode = alc880_sixstack_modes, 3175 .input_mux = &alc880_6stack_capture_source, 3176 }, 3177 [ALC880_6ST_DIG] = { 3178 .mixers = { alc880_six_stack_mixer }, 3179 .init_verbs = { alc880_volume_init_verbs, 3180 alc880_pin_6stack_init_verbs }, 3181 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids), 3182 .dac_nids = alc880_6st_dac_nids, 3183 .dig_out_nid = ALC880_DIGOUT_NID, 3184 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes), 3185 .channel_mode = alc880_sixstack_modes, 3186 .input_mux = &alc880_6stack_capture_source, 3187 }, 3188 [ALC880_W810] = { 3189 .mixers = { alc880_w810_base_mixer }, 3190 .init_verbs = { alc880_volume_init_verbs, 3191 alc880_pin_w810_init_verbs, 3192 alc880_gpio2_init_verbs }, 3193 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids), 3194 .dac_nids = alc880_w810_dac_nids, 3195 .dig_out_nid = ALC880_DIGOUT_NID, 3196 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes), 3197 .channel_mode = alc880_w810_modes, 3198 .input_mux = &alc880_capture_source, 3199 }, 3200 [ALC880_Z71V] = { 3201 .mixers = { alc880_z71v_mixer }, 3202 .init_verbs = { alc880_volume_init_verbs, 3203 alc880_pin_z71v_init_verbs }, 3204 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids), 3205 .dac_nids = alc880_z71v_dac_nids, 3206 .dig_out_nid = ALC880_DIGOUT_NID, 3207 .hp_nid = 0x03, 3208 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 3209 .channel_mode = alc880_2_jack_modes, 3210 .input_mux = &alc880_capture_source, 3211 }, 3212 [ALC880_F1734] = { 3213 .mixers = { alc880_f1734_mixer }, 3214 .init_verbs = { alc880_volume_init_verbs, 3215 alc880_pin_f1734_init_verbs }, 3216 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids), 3217 .dac_nids = alc880_f1734_dac_nids, 3218 .hp_nid = 0x02, 3219 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 3220 .channel_mode = alc880_2_jack_modes, 3221 .input_mux = &alc880_f1734_capture_source, 3222 .unsol_event = alc880_uniwill_p53_unsol_event, 3223 .init_hook = alc880_uniwill_p53_hp_automute, 3224 }, 3225 [ALC880_ASUS] = { 3226 .mixers = { alc880_asus_mixer }, 3227 .init_verbs = { alc880_volume_init_verbs, 3228 alc880_pin_asus_init_verbs, 3229 alc880_gpio1_init_verbs }, 3230 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3231 .dac_nids = alc880_asus_dac_nids, 3232 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 3233 .channel_mode = alc880_asus_modes, 3234 .need_dac_fix = 1, 3235 .input_mux = &alc880_capture_source, 3236 }, 3237 [ALC880_ASUS_DIG] = { 3238 .mixers = { alc880_asus_mixer }, 3239 .init_verbs = { alc880_volume_init_verbs, 3240 alc880_pin_asus_init_verbs, 3241 alc880_gpio1_init_verbs }, 3242 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3243 .dac_nids = alc880_asus_dac_nids, 3244 .dig_out_nid = ALC880_DIGOUT_NID, 3245 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 3246 .channel_mode = alc880_asus_modes, 3247 .need_dac_fix = 1, 3248 .input_mux = &alc880_capture_source, 3249 }, 3250 [ALC880_ASUS_DIG2] = { 3251 .mixers = { alc880_asus_mixer }, 3252 .init_verbs = { alc880_volume_init_verbs, 3253 alc880_pin_asus_init_verbs, 3254 alc880_gpio2_init_verbs }, /* use GPIO2 */ 3255 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3256 .dac_nids = alc880_asus_dac_nids, 3257 .dig_out_nid = ALC880_DIGOUT_NID, 3258 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 3259 .channel_mode = alc880_asus_modes, 3260 .need_dac_fix = 1, 3261 .input_mux = &alc880_capture_source, 3262 }, 3263 [ALC880_ASUS_W1V] = { 3264 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer }, 3265 .init_verbs = { alc880_volume_init_verbs, 3266 alc880_pin_asus_init_verbs, 3267 alc880_gpio1_init_verbs }, 3268 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3269 .dac_nids = alc880_asus_dac_nids, 3270 .dig_out_nid = ALC880_DIGOUT_NID, 3271 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 3272 .channel_mode = alc880_asus_modes, 3273 .need_dac_fix = 1, 3274 .input_mux = &alc880_capture_source, 3275 }, 3276 [ALC880_UNIWILL_DIG] = { 3277 .mixers = { alc880_asus_mixer, alc880_pcbeep_mixer }, 3278 .init_verbs = { alc880_volume_init_verbs, 3279 alc880_pin_asus_init_verbs }, 3280 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3281 .dac_nids = alc880_asus_dac_nids, 3282 .dig_out_nid = ALC880_DIGOUT_NID, 3283 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 3284 .channel_mode = alc880_asus_modes, 3285 .need_dac_fix = 1, 3286 .input_mux = &alc880_capture_source, 3287 }, 3288 [ALC880_UNIWILL] = { 3289 .mixers = { alc880_uniwill_mixer }, 3290 .init_verbs = { alc880_volume_init_verbs, 3291 alc880_uniwill_init_verbs }, 3292 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3293 .dac_nids = alc880_asus_dac_nids, 3294 .dig_out_nid = ALC880_DIGOUT_NID, 3295 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 3296 .channel_mode = alc880_threestack_modes, 3297 .need_dac_fix = 1, 3298 .input_mux = &alc880_capture_source, 3299 .unsol_event = alc880_uniwill_unsol_event, 3300 .init_hook = alc880_uniwill_automute, 3301 }, 3302 [ALC880_UNIWILL_P53] = { 3303 .mixers = { alc880_uniwill_p53_mixer }, 3304 .init_verbs = { alc880_volume_init_verbs, 3305 alc880_uniwill_p53_init_verbs }, 3306 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3307 .dac_nids = alc880_asus_dac_nids, 3308 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes), 3309 .channel_mode = alc880_threestack_modes, 3310 .input_mux = &alc880_capture_source, 3311 .unsol_event = alc880_uniwill_p53_unsol_event, 3312 .init_hook = alc880_uniwill_p53_hp_automute, 3313 }, 3314 [ALC880_FUJITSU] = { 3315 .mixers = { alc880_fujitsu_mixer, 3316 alc880_pcbeep_mixer, }, 3317 .init_verbs = { alc880_volume_init_verbs, 3318 alc880_uniwill_p53_init_verbs, 3319 alc880_beep_init_verbs }, 3320 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3321 .dac_nids = alc880_dac_nids, 3322 .dig_out_nid = ALC880_DIGOUT_NID, 3323 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 3324 .channel_mode = alc880_2_jack_modes, 3325 .input_mux = &alc880_capture_source, 3326 .unsol_event = alc880_uniwill_p53_unsol_event, 3327 .init_hook = alc880_uniwill_p53_hp_automute, 3328 }, 3329 [ALC880_CLEVO] = { 3330 .mixers = { alc880_three_stack_mixer }, 3331 .init_verbs = { alc880_volume_init_verbs, 3332 alc880_pin_clevo_init_verbs }, 3333 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3334 .dac_nids = alc880_dac_nids, 3335 .hp_nid = 0x03, 3336 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 3337 .channel_mode = alc880_threestack_modes, 3338 .need_dac_fix = 1, 3339 .input_mux = &alc880_capture_source, 3340 }, 3341 [ALC880_LG] = { 3342 .mixers = { alc880_lg_mixer }, 3343 .init_verbs = { alc880_volume_init_verbs, 3344 alc880_lg_init_verbs }, 3345 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids), 3346 .dac_nids = alc880_lg_dac_nids, 3347 .dig_out_nid = ALC880_DIGOUT_NID, 3348 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes), 3349 .channel_mode = alc880_lg_ch_modes, 3350 .need_dac_fix = 1, 3351 .input_mux = &alc880_lg_capture_source, 3352 .unsol_event = alc880_lg_unsol_event, 3353 .init_hook = alc880_lg_automute, 3354 #ifdef CONFIG_SND_HDA_POWER_SAVE 3355 .loopbacks = alc880_lg_loopbacks, 3356 #endif 3357 }, 3358 [ALC880_LG_LW] = { 3359 .mixers = { alc880_lg_lw_mixer }, 3360 .init_verbs = { alc880_volume_init_verbs, 3361 alc880_lg_lw_init_verbs }, 3362 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3363 .dac_nids = alc880_dac_nids, 3364 .dig_out_nid = ALC880_DIGOUT_NID, 3365 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes), 3366 .channel_mode = alc880_lg_lw_modes, 3367 .input_mux = &alc880_lg_lw_capture_source, 3368 .unsol_event = alc880_lg_lw_unsol_event, 3369 .init_hook = alc880_lg_lw_automute, 3370 }, 3371 [ALC880_MEDION_RIM] = { 3372 .mixers = { alc880_medion_rim_mixer }, 3373 .init_verbs = { alc880_volume_init_verbs, 3374 alc880_medion_rim_init_verbs, 3375 alc_gpio2_init_verbs }, 3376 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3377 .dac_nids = alc880_dac_nids, 3378 .dig_out_nid = ALC880_DIGOUT_NID, 3379 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 3380 .channel_mode = alc880_2_jack_modes, 3381 .input_mux = &alc880_medion_rim_capture_source, 3382 .unsol_event = alc880_medion_rim_unsol_event, 3383 .init_hook = alc880_medion_rim_automute, 3384 }, 3385 #ifdef CONFIG_SND_DEBUG 3386 [ALC880_TEST] = { 3387 .mixers = { alc880_test_mixer }, 3388 .init_verbs = { alc880_test_init_verbs }, 3389 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids), 3390 .dac_nids = alc880_test_dac_nids, 3391 .dig_out_nid = ALC880_DIGOUT_NID, 3392 .num_channel_mode = ARRAY_SIZE(alc880_test_modes), 3393 .channel_mode = alc880_test_modes, 3394 .input_mux = &alc880_test_capture_source, 3395 }, 3396 #endif 3397 }; 3398 3399 /* 3400 * Automatic parse of I/O pins from the BIOS configuration 3401 */ 3402 3403 #define NUM_CONTROL_ALLOC 32 3404 #define NUM_VERB_ALLOC 32 3405 3406 enum { 3407 ALC_CTL_WIDGET_VOL, 3408 ALC_CTL_WIDGET_MUTE, 3409 ALC_CTL_BIND_MUTE, 3410 }; 3411 static struct snd_kcontrol_new alc880_control_templates[] = { 3412 HDA_CODEC_VOLUME(NULL, 0, 0, 0), 3413 HDA_CODEC_MUTE(NULL, 0, 0, 0), 3414 HDA_BIND_MUTE(NULL, 0, 0, 0), 3415 }; 3416 3417 /* add dynamic controls */ 3418 static int add_control(struct alc_spec *spec, int type, const char *name, 3419 unsigned long val) 3420 { 3421 struct snd_kcontrol_new *knew; 3422 3423 if (spec->num_kctl_used >= spec->num_kctl_alloc) { 3424 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC; 3425 3426 /* array + terminator */ 3427 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); 3428 if (!knew) 3429 return -ENOMEM; 3430 if (spec->kctl_alloc) { 3431 memcpy(knew, spec->kctl_alloc, 3432 sizeof(*knew) * spec->num_kctl_alloc); 3433 kfree(spec->kctl_alloc); 3434 } 3435 spec->kctl_alloc = knew; 3436 spec->num_kctl_alloc = num; 3437 } 3438 3439 knew = &spec->kctl_alloc[spec->num_kctl_used]; 3440 *knew = alc880_control_templates[type]; 3441 knew->name = kstrdup(name, GFP_KERNEL); 3442 if (!knew->name) 3443 return -ENOMEM; 3444 knew->private_value = val; 3445 spec->num_kctl_used++; 3446 return 0; 3447 } 3448 3449 #define alc880_is_fixed_pin(nid) ((nid) >= 0x14 && (nid) <= 0x17) 3450 #define alc880_fixed_pin_idx(nid) ((nid) - 0x14) 3451 #define alc880_is_multi_pin(nid) ((nid) >= 0x18) 3452 #define alc880_multi_pin_idx(nid) ((nid) - 0x18) 3453 #define alc880_is_input_pin(nid) ((nid) >= 0x18) 3454 #define alc880_input_pin_idx(nid) ((nid) - 0x18) 3455 #define alc880_idx_to_dac(nid) ((nid) + 0x02) 3456 #define alc880_dac_to_idx(nid) ((nid) - 0x02) 3457 #define alc880_idx_to_mixer(nid) ((nid) + 0x0c) 3458 #define alc880_idx_to_selector(nid) ((nid) + 0x10) 3459 #define ALC880_PIN_CD_NID 0x1c 3460 3461 /* fill in the dac_nids table from the parsed pin configuration */ 3462 static int alc880_auto_fill_dac_nids(struct alc_spec *spec, 3463 const struct auto_pin_cfg *cfg) 3464 { 3465 hda_nid_t nid; 3466 int assigned[4]; 3467 int i, j; 3468 3469 memset(assigned, 0, sizeof(assigned)); 3470 spec->multiout.dac_nids = spec->private_dac_nids; 3471 3472 /* check the pins hardwired to audio widget */ 3473 for (i = 0; i < cfg->line_outs; i++) { 3474 nid = cfg->line_out_pins[i]; 3475 if (alc880_is_fixed_pin(nid)) { 3476 int idx = alc880_fixed_pin_idx(nid); 3477 spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx); 3478 assigned[idx] = 1; 3479 } 3480 } 3481 /* left pins can be connect to any audio widget */ 3482 for (i = 0; i < cfg->line_outs; i++) { 3483 nid = cfg->line_out_pins[i]; 3484 if (alc880_is_fixed_pin(nid)) 3485 continue; 3486 /* search for an empty channel */ 3487 for (j = 0; j < cfg->line_outs; j++) { 3488 if (!assigned[j]) { 3489 spec->multiout.dac_nids[i] = 3490 alc880_idx_to_dac(j); 3491 assigned[j] = 1; 3492 break; 3493 } 3494 } 3495 } 3496 spec->multiout.num_dacs = cfg->line_outs; 3497 return 0; 3498 } 3499 3500 /* add playback controls from the parsed DAC table */ 3501 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec, 3502 const struct auto_pin_cfg *cfg) 3503 { 3504 char name[32]; 3505 static const char *chname[4] = { 3506 "Front", "Surround", NULL /*CLFE*/, "Side" 3507 }; 3508 hda_nid_t nid; 3509 int i, err; 3510 3511 for (i = 0; i < cfg->line_outs; i++) { 3512 if (!spec->multiout.dac_nids[i]) 3513 continue; 3514 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i])); 3515 if (i == 2) { 3516 /* Center/LFE */ 3517 err = add_control(spec, ALC_CTL_WIDGET_VOL, 3518 "Center Playback Volume", 3519 HDA_COMPOSE_AMP_VAL(nid, 1, 0, 3520 HDA_OUTPUT)); 3521 if (err < 0) 3522 return err; 3523 err = add_control(spec, ALC_CTL_WIDGET_VOL, 3524 "LFE Playback Volume", 3525 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 3526 HDA_OUTPUT)); 3527 if (err < 0) 3528 return err; 3529 err = add_control(spec, ALC_CTL_BIND_MUTE, 3530 "Center Playback Switch", 3531 HDA_COMPOSE_AMP_VAL(nid, 1, 2, 3532 HDA_INPUT)); 3533 if (err < 0) 3534 return err; 3535 err = add_control(spec, ALC_CTL_BIND_MUTE, 3536 "LFE Playback Switch", 3537 HDA_COMPOSE_AMP_VAL(nid, 2, 2, 3538 HDA_INPUT)); 3539 if (err < 0) 3540 return err; 3541 } else { 3542 sprintf(name, "%s Playback Volume", chname[i]); 3543 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 3544 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 3545 HDA_OUTPUT)); 3546 if (err < 0) 3547 return err; 3548 sprintf(name, "%s Playback Switch", chname[i]); 3549 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 3550 HDA_COMPOSE_AMP_VAL(nid, 3, 2, 3551 HDA_INPUT)); 3552 if (err < 0) 3553 return err; 3554 } 3555 } 3556 return 0; 3557 } 3558 3559 /* add playback controls for speaker and HP outputs */ 3560 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin, 3561 const char *pfx) 3562 { 3563 hda_nid_t nid; 3564 int err; 3565 char name[32]; 3566 3567 if (!pin) 3568 return 0; 3569 3570 if (alc880_is_fixed_pin(pin)) { 3571 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin)); 3572 /* specify the DAC as the extra output */ 3573 if (!spec->multiout.hp_nid) 3574 spec->multiout.hp_nid = nid; 3575 else 3576 spec->multiout.extra_out_nid[0] = nid; 3577 /* control HP volume/switch on the output mixer amp */ 3578 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin)); 3579 sprintf(name, "%s Playback Volume", pfx); 3580 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 3581 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 3582 if (err < 0) 3583 return err; 3584 sprintf(name, "%s Playback Switch", pfx); 3585 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 3586 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT)); 3587 if (err < 0) 3588 return err; 3589 } else if (alc880_is_multi_pin(pin)) { 3590 /* set manual connection */ 3591 /* we have only a switch on HP-out PIN */ 3592 sprintf(name, "%s Playback Switch", pfx); 3593 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 3594 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 3595 if (err < 0) 3596 return err; 3597 } 3598 return 0; 3599 } 3600 3601 /* create input playback/capture controls for the given pin */ 3602 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin, 3603 const char *ctlname, 3604 int idx, hda_nid_t mix_nid) 3605 { 3606 char name[32]; 3607 int err; 3608 3609 sprintf(name, "%s Playback Volume", ctlname); 3610 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 3611 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); 3612 if (err < 0) 3613 return err; 3614 sprintf(name, "%s Playback Switch", ctlname); 3615 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 3616 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); 3617 if (err < 0) 3618 return err; 3619 return 0; 3620 } 3621 3622 /* create playback/capture controls for input pins */ 3623 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec, 3624 const struct auto_pin_cfg *cfg) 3625 { 3626 struct hda_input_mux *imux = &spec->private_imux; 3627 int i, err, idx; 3628 3629 for (i = 0; i < AUTO_PIN_LAST; i++) { 3630 if (alc880_is_input_pin(cfg->input_pins[i])) { 3631 idx = alc880_input_pin_idx(cfg->input_pins[i]); 3632 err = new_analog_input(spec, cfg->input_pins[i], 3633 auto_pin_cfg_labels[i], 3634 idx, 0x0b); 3635 if (err < 0) 3636 return err; 3637 imux->items[imux->num_items].label = 3638 auto_pin_cfg_labels[i]; 3639 imux->items[imux->num_items].index = 3640 alc880_input_pin_idx(cfg->input_pins[i]); 3641 imux->num_items++; 3642 } 3643 } 3644 return 0; 3645 } 3646 3647 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid, 3648 unsigned int pin_type) 3649 { 3650 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 3651 pin_type); 3652 /* unmute pin */ 3653 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, 3654 AMP_OUT_UNMUTE); 3655 } 3656 3657 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec, 3658 hda_nid_t nid, int pin_type, 3659 int dac_idx) 3660 { 3661 alc_set_pin_output(codec, nid, pin_type); 3662 /* need the manual connection? */ 3663 if (alc880_is_multi_pin(nid)) { 3664 struct alc_spec *spec = codec->spec; 3665 int idx = alc880_multi_pin_idx(nid); 3666 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0, 3667 AC_VERB_SET_CONNECT_SEL, 3668 alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx])); 3669 } 3670 } 3671 3672 static int get_pin_type(int line_out_type) 3673 { 3674 if (line_out_type == AUTO_PIN_HP_OUT) 3675 return PIN_HP; 3676 else 3677 return PIN_OUT; 3678 } 3679 3680 static void alc880_auto_init_multi_out(struct hda_codec *codec) 3681 { 3682 struct alc_spec *spec = codec->spec; 3683 int i; 3684 3685 alc_subsystem_id(codec, 0x15, 0x1b, 0x14); 3686 for (i = 0; i < spec->autocfg.line_outs; i++) { 3687 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 3688 int pin_type = get_pin_type(spec->autocfg.line_out_type); 3689 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i); 3690 } 3691 } 3692 3693 static void alc880_auto_init_extra_out(struct hda_codec *codec) 3694 { 3695 struct alc_spec *spec = codec->spec; 3696 hda_nid_t pin; 3697 3698 pin = spec->autocfg.speaker_pins[0]; 3699 if (pin) /* connect to front */ 3700 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 3701 pin = spec->autocfg.hp_pins[0]; 3702 if (pin) /* connect to front */ 3703 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 3704 } 3705 3706 static void alc880_auto_init_analog_input(struct hda_codec *codec) 3707 { 3708 struct alc_spec *spec = codec->spec; 3709 int i; 3710 3711 for (i = 0; i < AUTO_PIN_LAST; i++) { 3712 hda_nid_t nid = spec->autocfg.input_pins[i]; 3713 if (alc880_is_input_pin(nid)) { 3714 snd_hda_codec_write(codec, nid, 0, 3715 AC_VERB_SET_PIN_WIDGET_CONTROL, 3716 i <= AUTO_PIN_FRONT_MIC ? 3717 PIN_VREF80 : PIN_IN); 3718 if (nid != ALC880_PIN_CD_NID) 3719 snd_hda_codec_write(codec, nid, 0, 3720 AC_VERB_SET_AMP_GAIN_MUTE, 3721 AMP_OUT_MUTE); 3722 } 3723 } 3724 } 3725 3726 /* parse the BIOS configuration and set up the alc_spec */ 3727 /* return 1 if successful, 0 if the proper config is not found, 3728 * or a negative error code 3729 */ 3730 static int alc880_parse_auto_config(struct hda_codec *codec) 3731 { 3732 struct alc_spec *spec = codec->spec; 3733 int err; 3734 static hda_nid_t alc880_ignore[] = { 0x1d, 0 }; 3735 3736 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 3737 alc880_ignore); 3738 if (err < 0) 3739 return err; 3740 if (!spec->autocfg.line_outs) 3741 return 0; /* can't find valid BIOS pin config */ 3742 3743 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg); 3744 if (err < 0) 3745 return err; 3746 err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg); 3747 if (err < 0) 3748 return err; 3749 err = alc880_auto_create_extra_out(spec, 3750 spec->autocfg.speaker_pins[0], 3751 "Speaker"); 3752 if (err < 0) 3753 return err; 3754 err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0], 3755 "Headphone"); 3756 if (err < 0) 3757 return err; 3758 err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg); 3759 if (err < 0) 3760 return err; 3761 3762 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 3763 3764 if (spec->autocfg.dig_out_pin) 3765 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID; 3766 if (spec->autocfg.dig_in_pin) 3767 spec->dig_in_nid = ALC880_DIGIN_NID; 3768 3769 if (spec->kctl_alloc) 3770 spec->mixers[spec->num_mixers++] = spec->kctl_alloc; 3771 3772 spec->init_verbs[spec->num_init_verbs++] = alc880_volume_init_verbs; 3773 3774 spec->num_mux_defs = 1; 3775 spec->input_mux = &spec->private_imux; 3776 3777 return 1; 3778 } 3779 3780 /* additional initialization for auto-configuration model */ 3781 static void alc880_auto_init(struct hda_codec *codec) 3782 { 3783 struct alc_spec *spec = codec->spec; 3784 alc880_auto_init_multi_out(codec); 3785 alc880_auto_init_extra_out(codec); 3786 alc880_auto_init_analog_input(codec); 3787 if (spec->unsol_event) 3788 alc_sku_automute(codec); 3789 } 3790 3791 /* 3792 * OK, here we have finally the patch for ALC880 3793 */ 3794 3795 static int patch_alc880(struct hda_codec *codec) 3796 { 3797 struct alc_spec *spec; 3798 int board_config; 3799 int err; 3800 3801 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 3802 if (spec == NULL) 3803 return -ENOMEM; 3804 3805 codec->spec = spec; 3806 3807 board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST, 3808 alc880_models, 3809 alc880_cfg_tbl); 3810 if (board_config < 0) { 3811 printk(KERN_INFO "hda_codec: Unknown model for ALC880, " 3812 "trying auto-probe from BIOS...\n"); 3813 board_config = ALC880_AUTO; 3814 } 3815 3816 if (board_config == ALC880_AUTO) { 3817 /* automatic parse from the BIOS config */ 3818 err = alc880_parse_auto_config(codec); 3819 if (err < 0) { 3820 alc_free(codec); 3821 return err; 3822 } else if (!err) { 3823 printk(KERN_INFO 3824 "hda_codec: Cannot set up configuration " 3825 "from BIOS. Using 3-stack mode...\n"); 3826 board_config = ALC880_3ST; 3827 } 3828 } 3829 3830 if (board_config != ALC880_AUTO) 3831 setup_preset(spec, &alc880_presets[board_config]); 3832 3833 spec->stream_name_analog = "ALC880 Analog"; 3834 spec->stream_analog_playback = &alc880_pcm_analog_playback; 3835 spec->stream_analog_capture = &alc880_pcm_analog_capture; 3836 spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture; 3837 3838 spec->stream_name_digital = "ALC880 Digital"; 3839 spec->stream_digital_playback = &alc880_pcm_digital_playback; 3840 spec->stream_digital_capture = &alc880_pcm_digital_capture; 3841 3842 if (!spec->adc_nids && spec->input_mux) { 3843 /* check whether NID 0x07 is valid */ 3844 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]); 3845 /* get type */ 3846 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 3847 if (wcap != AC_WID_AUD_IN) { 3848 spec->adc_nids = alc880_adc_nids_alt; 3849 spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt); 3850 spec->mixers[spec->num_mixers] = 3851 alc880_capture_alt_mixer; 3852 spec->num_mixers++; 3853 } else { 3854 spec->adc_nids = alc880_adc_nids; 3855 spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids); 3856 spec->mixers[spec->num_mixers] = alc880_capture_mixer; 3857 spec->num_mixers++; 3858 } 3859 } 3860 3861 spec->vmaster_nid = 0x0c; 3862 3863 codec->patch_ops = alc_patch_ops; 3864 if (board_config == ALC880_AUTO) 3865 spec->init_hook = alc880_auto_init; 3866 #ifdef CONFIG_SND_HDA_POWER_SAVE 3867 if (!spec->loopback.amplist) 3868 spec->loopback.amplist = alc880_loopbacks; 3869 #endif 3870 3871 return 0; 3872 } 3873 3874 3875 /* 3876 * ALC260 support 3877 */ 3878 3879 static hda_nid_t alc260_dac_nids[1] = { 3880 /* front */ 3881 0x02, 3882 }; 3883 3884 static hda_nid_t alc260_adc_nids[1] = { 3885 /* ADC0 */ 3886 0x04, 3887 }; 3888 3889 static hda_nid_t alc260_adc_nids_alt[1] = { 3890 /* ADC1 */ 3891 0x05, 3892 }; 3893 3894 static hda_nid_t alc260_hp_adc_nids[2] = { 3895 /* ADC1, 0 */ 3896 0x05, 0x04 3897 }; 3898 3899 /* NIDs used when simultaneous access to both ADCs makes sense. Note that 3900 * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC. 3901 */ 3902 static hda_nid_t alc260_dual_adc_nids[2] = { 3903 /* ADC0, ADC1 */ 3904 0x04, 0x05 3905 }; 3906 3907 #define ALC260_DIGOUT_NID 0x03 3908 #define ALC260_DIGIN_NID 0x06 3909 3910 static struct hda_input_mux alc260_capture_source = { 3911 .num_items = 4, 3912 .items = { 3913 { "Mic", 0x0 }, 3914 { "Front Mic", 0x1 }, 3915 { "Line", 0x2 }, 3916 { "CD", 0x4 }, 3917 }, 3918 }; 3919 3920 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack, 3921 * headphone jack and the internal CD lines since these are the only pins at 3922 * which audio can appear. For flexibility, also allow the option of 3923 * recording the mixer output on the second ADC (ADC0 doesn't have a 3924 * connection to the mixer output). 3925 */ 3926 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = { 3927 { 3928 .num_items = 3, 3929 .items = { 3930 { "Mic/Line", 0x0 }, 3931 { "CD", 0x4 }, 3932 { "Headphone", 0x2 }, 3933 }, 3934 }, 3935 { 3936 .num_items = 4, 3937 .items = { 3938 { "Mic/Line", 0x0 }, 3939 { "CD", 0x4 }, 3940 { "Headphone", 0x2 }, 3941 { "Mixer", 0x5 }, 3942 }, 3943 }, 3944 3945 }; 3946 3947 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to 3948 * the Fujitsu S702x, but jacks are marked differently. 3949 */ 3950 static struct hda_input_mux alc260_acer_capture_sources[2] = { 3951 { 3952 .num_items = 4, 3953 .items = { 3954 { "Mic", 0x0 }, 3955 { "Line", 0x2 }, 3956 { "CD", 0x4 }, 3957 { "Headphone", 0x5 }, 3958 }, 3959 }, 3960 { 3961 .num_items = 5, 3962 .items = { 3963 { "Mic", 0x0 }, 3964 { "Line", 0x2 }, 3965 { "CD", 0x4 }, 3966 { "Headphone", 0x6 }, 3967 { "Mixer", 0x5 }, 3968 }, 3969 }, 3970 }; 3971 /* 3972 * This is just place-holder, so there's something for alc_build_pcms to look 3973 * at when it calculates the maximum number of channels. ALC260 has no mixer 3974 * element which allows changing the channel mode, so the verb list is 3975 * never used. 3976 */ 3977 static struct hda_channel_mode alc260_modes[1] = { 3978 { 2, NULL }, 3979 }; 3980 3981 3982 /* Mixer combinations 3983 * 3984 * basic: base_output + input + pc_beep + capture 3985 * HP: base_output + input + capture_alt 3986 * HP_3013: hp_3013 + input + capture 3987 * fujitsu: fujitsu + capture 3988 * acer: acer + capture 3989 */ 3990 3991 static struct snd_kcontrol_new alc260_base_output_mixer[] = { 3992 HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT), 3993 HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT), 3994 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT), 3995 HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT), 3996 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT), 3997 HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT), 3998 { } /* end */ 3999 }; 4000 4001 static struct snd_kcontrol_new alc260_input_mixer[] = { 4002 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 4003 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 4004 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT), 4005 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT), 4006 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT), 4007 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT), 4008 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT), 4009 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT), 4010 { } /* end */ 4011 }; 4012 4013 static struct snd_kcontrol_new alc260_pc_beep_mixer[] = { 4014 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x07, 0x05, HDA_INPUT), 4015 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x07, 0x05, HDA_INPUT), 4016 { } /* end */ 4017 }; 4018 4019 /* update HP, line and mono out pins according to the master switch */ 4020 static void alc260_hp_master_update(struct hda_codec *codec, 4021 hda_nid_t hp, hda_nid_t line, 4022 hda_nid_t mono) 4023 { 4024 struct alc_spec *spec = codec->spec; 4025 unsigned int val = spec->master_sw ? PIN_HP : 0; 4026 /* change HP and line-out pins */ 4027 snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4028 val); 4029 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4030 val); 4031 /* mono (speaker) depending on the HP jack sense */ 4032 val = (val && !spec->jack_present) ? PIN_OUT : 0; 4033 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4034 val); 4035 } 4036 4037 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol, 4038 struct snd_ctl_elem_value *ucontrol) 4039 { 4040 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 4041 struct alc_spec *spec = codec->spec; 4042 *ucontrol->value.integer.value = spec->master_sw; 4043 return 0; 4044 } 4045 4046 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol, 4047 struct snd_ctl_elem_value *ucontrol) 4048 { 4049 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 4050 struct alc_spec *spec = codec->spec; 4051 int val = !!*ucontrol->value.integer.value; 4052 hda_nid_t hp, line, mono; 4053 4054 if (val == spec->master_sw) 4055 return 0; 4056 spec->master_sw = val; 4057 hp = (kcontrol->private_value >> 16) & 0xff; 4058 line = (kcontrol->private_value >> 8) & 0xff; 4059 mono = kcontrol->private_value & 0xff; 4060 alc260_hp_master_update(codec, hp, line, mono); 4061 return 1; 4062 } 4063 4064 static struct snd_kcontrol_new alc260_hp_output_mixer[] = { 4065 { 4066 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4067 .name = "Master Playback Switch", 4068 .info = snd_ctl_boolean_mono_info, 4069 .get = alc260_hp_master_sw_get, 4070 .put = alc260_hp_master_sw_put, 4071 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11 4072 }, 4073 HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4074 HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT), 4075 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT), 4076 HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT), 4077 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, 4078 HDA_OUTPUT), 4079 HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT), 4080 { } /* end */ 4081 }; 4082 4083 static struct hda_verb alc260_hp_unsol_verbs[] = { 4084 {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 4085 {}, 4086 }; 4087 4088 static void alc260_hp_automute(struct hda_codec *codec) 4089 { 4090 struct alc_spec *spec = codec->spec; 4091 unsigned int present; 4092 4093 present = snd_hda_codec_read(codec, 0x10, 0, 4094 AC_VERB_GET_PIN_SENSE, 0); 4095 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0; 4096 alc260_hp_master_update(codec, 0x0f, 0x10, 0x11); 4097 } 4098 4099 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res) 4100 { 4101 if ((res >> 26) == ALC880_HP_EVENT) 4102 alc260_hp_automute(codec); 4103 } 4104 4105 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = { 4106 { 4107 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4108 .name = "Master Playback Switch", 4109 .info = snd_ctl_boolean_mono_info, 4110 .get = alc260_hp_master_sw_get, 4111 .put = alc260_hp_master_sw_put, 4112 .private_value = (0x10 << 16) | (0x15 << 8) | 0x11 4113 }, 4114 HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT), 4115 HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT), 4116 HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT), 4117 HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT), 4118 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4119 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 4120 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT), 4121 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT), 4122 { } /* end */ 4123 }; 4124 4125 static struct hda_verb alc260_hp_3013_unsol_verbs[] = { 4126 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 4127 {}, 4128 }; 4129 4130 static void alc260_hp_3013_automute(struct hda_codec *codec) 4131 { 4132 struct alc_spec *spec = codec->spec; 4133 unsigned int present; 4134 4135 present = snd_hda_codec_read(codec, 0x15, 0, 4136 AC_VERB_GET_PIN_SENSE, 0); 4137 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0; 4138 alc260_hp_master_update(codec, 0x10, 0x15, 0x11); 4139 } 4140 4141 static void alc260_hp_3013_unsol_event(struct hda_codec *codec, 4142 unsigned int res) 4143 { 4144 if ((res >> 26) == ALC880_HP_EVENT) 4145 alc260_hp_3013_automute(codec); 4146 } 4147 4148 /* Fujitsu S702x series laptops. ALC260 pin usage: Mic/Line jack = 0x12, 4149 * HP jack = 0x14, CD audio = 0x16, internal speaker = 0x10. 4150 */ 4151 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = { 4152 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4153 HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT), 4154 ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT), 4155 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 4156 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 4157 HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT), 4158 HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT), 4159 ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN), 4160 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT), 4161 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT), 4162 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT), 4163 HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT), 4164 { } /* end */ 4165 }; 4166 4167 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks. Note that current 4168 * versions of the ALC260 don't act on requests to enable mic bias from NID 4169 * 0x0f (used to drive the headphone jack in these laptops). The ALC260 4170 * datasheet doesn't mention this restriction. At this stage it's not clear 4171 * whether this behaviour is intentional or is a hardware bug in chip 4172 * revisions available in early 2006. Therefore for now allow the 4173 * "Headphone Jack Mode" control to span all choices, but if it turns out 4174 * that the lack of mic bias for this NID is intentional we could change the 4175 * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS. 4176 * 4177 * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006 4178 * don't appear to make the mic bias available from the "line" jack, even 4179 * though the NID used for this jack (0x14) can supply it. The theory is 4180 * that perhaps Acer have included blocking capacitors between the ALC260 4181 * and the output jack. If this turns out to be the case for all such 4182 * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT 4183 * to ALC_PIN_DIR_INOUT_NOMICBIAS. 4184 * 4185 * The C20x Tablet series have a mono internal speaker which is controlled 4186 * via the chip's Mono sum widget and pin complex, so include the necessary 4187 * controls for such models. On models without a "mono speaker" the control 4188 * won't do anything. 4189 */ 4190 static struct snd_kcontrol_new alc260_acer_mixer[] = { 4191 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4192 HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT), 4193 ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT), 4194 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, 4195 HDA_OUTPUT), 4196 HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, 4197 HDA_INPUT), 4198 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 4199 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 4200 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT), 4201 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT), 4202 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN), 4203 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT), 4204 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT), 4205 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT), 4206 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT), 4207 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT), 4208 { } /* end */ 4209 }; 4210 4211 /* Packard bell V7900 ALC260 pin usage: HP = 0x0f, Mic jack = 0x12, 4212 * Line In jack = 0x14, CD audio = 0x16, pc beep = 0x17. 4213 */ 4214 static struct snd_kcontrol_new alc260_will_mixer[] = { 4215 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4216 HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT), 4217 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT), 4218 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT), 4219 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN), 4220 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT), 4221 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT), 4222 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT), 4223 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 4224 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 4225 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT), 4226 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT), 4227 { } /* end */ 4228 }; 4229 4230 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12, 4231 * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f. 4232 */ 4233 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = { 4234 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4235 HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT), 4236 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT), 4237 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT), 4238 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN), 4239 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT), 4240 HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT), 4241 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT), 4242 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT), 4243 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT), 4244 { } /* end */ 4245 }; 4246 4247 /* capture mixer elements */ 4248 static struct snd_kcontrol_new alc260_capture_mixer[] = { 4249 HDA_CODEC_VOLUME("Capture Volume", 0x04, 0x0, HDA_INPUT), 4250 HDA_CODEC_MUTE("Capture Switch", 0x04, 0x0, HDA_INPUT), 4251 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x05, 0x0, HDA_INPUT), 4252 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x05, 0x0, HDA_INPUT), 4253 { 4254 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4255 /* The multiple "Capture Source" controls confuse alsamixer 4256 * So call somewhat different.. 4257 */ 4258 /* .name = "Capture Source", */ 4259 .name = "Input Source", 4260 .count = 2, 4261 .info = alc_mux_enum_info, 4262 .get = alc_mux_enum_get, 4263 .put = alc_mux_enum_put, 4264 }, 4265 { } /* end */ 4266 }; 4267 4268 static struct snd_kcontrol_new alc260_capture_alt_mixer[] = { 4269 HDA_CODEC_VOLUME("Capture Volume", 0x05, 0x0, HDA_INPUT), 4270 HDA_CODEC_MUTE("Capture Switch", 0x05, 0x0, HDA_INPUT), 4271 { 4272 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4273 /* The multiple "Capture Source" controls confuse alsamixer 4274 * So call somewhat different.. 4275 */ 4276 /* .name = "Capture Source", */ 4277 .name = "Input Source", 4278 .count = 1, 4279 .info = alc_mux_enum_info, 4280 .get = alc_mux_enum_get, 4281 .put = alc_mux_enum_put, 4282 }, 4283 { } /* end */ 4284 }; 4285 4286 /* 4287 * initialization verbs 4288 */ 4289 static struct hda_verb alc260_init_verbs[] = { 4290 /* Line In pin widget for input */ 4291 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 4292 /* CD pin widget for input */ 4293 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 4294 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 4295 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 4296 /* Mic2 (front panel) pin widget for input and vref at 80% */ 4297 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 4298 /* LINE-2 is used for line-out in rear */ 4299 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4300 /* select line-out */ 4301 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00}, 4302 /* LINE-OUT pin */ 4303 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4304 /* enable HP */ 4305 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 4306 /* enable Mono */ 4307 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4308 /* mute capture amp left and right */ 4309 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4310 /* set connection select to line in (default select for this ADC) */ 4311 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02}, 4312 /* mute capture amp left and right */ 4313 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4314 /* set connection select to line in (default select for this ADC) */ 4315 {0x05, AC_VERB_SET_CONNECT_SEL, 0x02}, 4316 /* set vol=0 Line-Out mixer amp left and right */ 4317 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4318 /* unmute pin widget amp left and right (no gain on this amp) */ 4319 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4320 /* set vol=0 HP mixer amp left and right */ 4321 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4322 /* unmute pin widget amp left and right (no gain on this amp) */ 4323 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4324 /* set vol=0 Mono mixer amp left and right */ 4325 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4326 /* unmute pin widget amp left and right (no gain on this amp) */ 4327 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4328 /* unmute LINE-2 out pin */ 4329 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4330 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & 4331 * Line In 2 = 0x03 4332 */ 4333 /* mute analog inputs */ 4334 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4335 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4336 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 4337 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 4338 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 4339 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */ 4340 /* mute Front out path */ 4341 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4342 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4343 /* mute Headphone out path */ 4344 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4345 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4346 /* mute Mono out path */ 4347 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4348 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4349 { } 4350 }; 4351 4352 #if 0 /* should be identical with alc260_init_verbs? */ 4353 static struct hda_verb alc260_hp_init_verbs[] = { 4354 /* Headphone and output */ 4355 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 4356 /* mono output */ 4357 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 4358 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 4359 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 4360 /* Mic2 (front panel) pin widget for input and vref at 80% */ 4361 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 4362 /* Line In pin widget for input */ 4363 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 4364 /* Line-2 pin widget for output */ 4365 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 4366 /* CD pin widget for input */ 4367 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 4368 /* unmute amp left and right */ 4369 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000}, 4370 /* set connection select to line in (default select for this ADC) */ 4371 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02}, 4372 /* unmute Line-Out mixer amp left and right (volume = 0) */ 4373 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 4374 /* mute pin widget amp left and right (no gain on this amp) */ 4375 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 4376 /* unmute HP mixer amp left and right (volume = 0) */ 4377 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 4378 /* mute pin widget amp left and right (no gain on this amp) */ 4379 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 4380 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & 4381 * Line In 2 = 0x03 4382 */ 4383 /* mute analog inputs */ 4384 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4385 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4386 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 4387 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 4388 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 4389 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */ 4390 /* Unmute Front out path */ 4391 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4392 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4393 /* Unmute Headphone out path */ 4394 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4395 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4396 /* Unmute Mono out path */ 4397 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4398 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4399 { } 4400 }; 4401 #endif 4402 4403 static struct hda_verb alc260_hp_3013_init_verbs[] = { 4404 /* Line out and output */ 4405 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 4406 /* mono output */ 4407 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 4408 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 4409 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 4410 /* Mic2 (front panel) pin widget for input and vref at 80% */ 4411 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 4412 /* Line In pin widget for input */ 4413 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 4414 /* Headphone pin widget for output */ 4415 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 4416 /* CD pin widget for input */ 4417 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 4418 /* unmute amp left and right */ 4419 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000}, 4420 /* set connection select to line in (default select for this ADC) */ 4421 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02}, 4422 /* unmute Line-Out mixer amp left and right (volume = 0) */ 4423 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 4424 /* mute pin widget amp left and right (no gain on this amp) */ 4425 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 4426 /* unmute HP mixer amp left and right (volume = 0) */ 4427 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 4428 /* mute pin widget amp left and right (no gain on this amp) */ 4429 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 4430 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & 4431 * Line In 2 = 0x03 4432 */ 4433 /* mute analog inputs */ 4434 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4435 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4436 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 4437 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 4438 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 4439 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */ 4440 /* Unmute Front out path */ 4441 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4442 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4443 /* Unmute Headphone out path */ 4444 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4445 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4446 /* Unmute Mono out path */ 4447 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4448 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4449 { } 4450 }; 4451 4452 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x 4453 * laptops. ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD 4454 * audio = 0x16, internal speaker = 0x10. 4455 */ 4456 static struct hda_verb alc260_fujitsu_init_verbs[] = { 4457 /* Disable all GPIOs */ 4458 {0x01, AC_VERB_SET_GPIO_MASK, 0}, 4459 /* Internal speaker is connected to headphone pin */ 4460 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 4461 /* Headphone/Line-out jack connects to Line1 pin; make it an output */ 4462 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4463 /* Mic/Line-in jack is connected to mic1 pin, so make it an input */ 4464 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 4465 /* Ensure all other unused pins are disabled and muted. */ 4466 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 4467 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4468 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 4469 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4470 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 4471 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4472 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 4473 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4474 4475 /* Disable digital (SPDIF) pins */ 4476 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0}, 4477 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0}, 4478 4479 /* Ensure Line1 pin widget takes its input from the OUT1 sum bus 4480 * when acting as an output. 4481 */ 4482 {0x0d, AC_VERB_SET_CONNECT_SEL, 0}, 4483 4484 /* Start with output sum widgets muted and their output gains at min */ 4485 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4486 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4487 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4488 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4489 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4490 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4491 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4492 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4493 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4494 4495 /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */ 4496 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4497 /* Unmute Line1 pin widget output buffer since it starts as an output. 4498 * If the pin mode is changed by the user the pin mode control will 4499 * take care of enabling the pin's input/output buffers as needed. 4500 * Therefore there's no need to enable the input buffer at this 4501 * stage. 4502 */ 4503 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4504 /* Unmute input buffer of pin widget used for Line-in (no equiv 4505 * mixer ctrl) 4506 */ 4507 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4508 4509 /* Mute capture amp left and right */ 4510 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4511 /* Set ADC connection select to match default mixer setting - line 4512 * in (on mic1 pin) 4513 */ 4514 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00}, 4515 4516 /* Do the same for the second ADC: mute capture input amp and 4517 * set ADC connection to line in (on mic1 pin) 4518 */ 4519 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4520 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00}, 4521 4522 /* Mute all inputs to mixer widget (even unconnected ones) */ 4523 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */ 4524 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */ 4525 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */ 4526 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */ 4527 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */ 4528 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */ 4529 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */ 4530 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */ 4531 4532 { } 4533 }; 4534 4535 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and 4536 * similar laptops (adapted from Fujitsu init verbs). 4537 */ 4538 static struct hda_verb alc260_acer_init_verbs[] = { 4539 /* On TravelMate laptops, GPIO 0 enables the internal speaker and 4540 * the headphone jack. Turn this on and rely on the standard mute 4541 * methods whenever the user wants to turn these outputs off. 4542 */ 4543 {0x01, AC_VERB_SET_GPIO_MASK, 0x01}, 4544 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, 4545 {0x01, AC_VERB_SET_GPIO_DATA, 0x01}, 4546 /* Internal speaker/Headphone jack is connected to Line-out pin */ 4547 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 4548 /* Internal microphone/Mic jack is connected to Mic1 pin */ 4549 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50}, 4550 /* Line In jack is connected to Line1 pin */ 4551 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 4552 /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */ 4553 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 4554 /* Ensure all other unused pins are disabled and muted. */ 4555 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 4556 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4557 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 4558 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4559 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 4560 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4561 /* Disable digital (SPDIF) pins */ 4562 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0}, 4563 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0}, 4564 4565 /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum 4566 * bus when acting as outputs. 4567 */ 4568 {0x0b, AC_VERB_SET_CONNECT_SEL, 0}, 4569 {0x0d, AC_VERB_SET_CONNECT_SEL, 0}, 4570 4571 /* Start with output sum widgets muted and their output gains at min */ 4572 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4573 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4574 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4575 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4576 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4577 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4578 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4579 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4580 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4581 4582 /* Unmute Line-out pin widget amp left and right 4583 * (no equiv mixer ctrl) 4584 */ 4585 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4586 /* Unmute mono pin widget amp output (no equiv mixer ctrl) */ 4587 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4588 /* Unmute Mic1 and Line1 pin widget input buffers since they start as 4589 * inputs. If the pin mode is changed by the user the pin mode control 4590 * will take care of enabling the pin's input/output buffers as needed. 4591 * Therefore there's no need to enable the input buffer at this 4592 * stage. 4593 */ 4594 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4595 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4596 4597 /* Mute capture amp left and right */ 4598 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4599 /* Set ADC connection select to match default mixer setting - mic 4600 * (on mic1 pin) 4601 */ 4602 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00}, 4603 4604 /* Do similar with the second ADC: mute capture input amp and 4605 * set ADC connection to mic to match ALSA's default state. 4606 */ 4607 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4608 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00}, 4609 4610 /* Mute all inputs to mixer widget (even unconnected ones) */ 4611 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */ 4612 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */ 4613 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */ 4614 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */ 4615 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */ 4616 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */ 4617 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */ 4618 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */ 4619 4620 { } 4621 }; 4622 4623 static struct hda_verb alc260_will_verbs[] = { 4624 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 4625 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00}, 4626 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00}, 4627 {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02}, 4628 {0x1a, AC_VERB_SET_COEF_INDEX, 0x07}, 4629 {0x1a, AC_VERB_SET_PROC_COEF, 0x3040}, 4630 {} 4631 }; 4632 4633 static struct hda_verb alc260_replacer_672v_verbs[] = { 4634 {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02}, 4635 {0x1a, AC_VERB_SET_COEF_INDEX, 0x07}, 4636 {0x1a, AC_VERB_SET_PROC_COEF, 0x3050}, 4637 4638 {0x01, AC_VERB_SET_GPIO_MASK, 0x01}, 4639 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, 4640 {0x01, AC_VERB_SET_GPIO_DATA, 0x00}, 4641 4642 {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 4643 {} 4644 }; 4645 4646 /* toggle speaker-output according to the hp-jack state */ 4647 static void alc260_replacer_672v_automute(struct hda_codec *codec) 4648 { 4649 unsigned int present; 4650 4651 /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */ 4652 present = snd_hda_codec_read(codec, 0x0f, 0, 4653 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 4654 if (present) { 4655 snd_hda_codec_write_cache(codec, 0x01, 0, 4656 AC_VERB_SET_GPIO_DATA, 1); 4657 snd_hda_codec_write_cache(codec, 0x0f, 0, 4658 AC_VERB_SET_PIN_WIDGET_CONTROL, 4659 PIN_HP); 4660 } else { 4661 snd_hda_codec_write_cache(codec, 0x01, 0, 4662 AC_VERB_SET_GPIO_DATA, 0); 4663 snd_hda_codec_write_cache(codec, 0x0f, 0, 4664 AC_VERB_SET_PIN_WIDGET_CONTROL, 4665 PIN_OUT); 4666 } 4667 } 4668 4669 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec, 4670 unsigned int res) 4671 { 4672 if ((res >> 26) == ALC880_HP_EVENT) 4673 alc260_replacer_672v_automute(codec); 4674 } 4675 4676 /* Test configuration for debugging, modelled after the ALC880 test 4677 * configuration. 4678 */ 4679 #ifdef CONFIG_SND_DEBUG 4680 static hda_nid_t alc260_test_dac_nids[1] = { 4681 0x02, 4682 }; 4683 static hda_nid_t alc260_test_adc_nids[2] = { 4684 0x04, 0x05, 4685 }; 4686 /* For testing the ALC260, each input MUX needs its own definition since 4687 * the signal assignments are different. This assumes that the first ADC 4688 * is NID 0x04. 4689 */ 4690 static struct hda_input_mux alc260_test_capture_sources[2] = { 4691 { 4692 .num_items = 7, 4693 .items = { 4694 { "MIC1 pin", 0x0 }, 4695 { "MIC2 pin", 0x1 }, 4696 { "LINE1 pin", 0x2 }, 4697 { "LINE2 pin", 0x3 }, 4698 { "CD pin", 0x4 }, 4699 { "LINE-OUT pin", 0x5 }, 4700 { "HP-OUT pin", 0x6 }, 4701 }, 4702 }, 4703 { 4704 .num_items = 8, 4705 .items = { 4706 { "MIC1 pin", 0x0 }, 4707 { "MIC2 pin", 0x1 }, 4708 { "LINE1 pin", 0x2 }, 4709 { "LINE2 pin", 0x3 }, 4710 { "CD pin", 0x4 }, 4711 { "Mixer", 0x5 }, 4712 { "LINE-OUT pin", 0x6 }, 4713 { "HP-OUT pin", 0x7 }, 4714 }, 4715 }, 4716 }; 4717 static struct snd_kcontrol_new alc260_test_mixer[] = { 4718 /* Output driver widgets */ 4719 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT), 4720 HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT), 4721 HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT), 4722 HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT), 4723 HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4724 HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT), 4725 4726 /* Modes for retasking pin widgets 4727 * Note: the ALC260 doesn't seem to act on requests to enable mic 4728 * bias from NIDs 0x0f and 0x10. The ALC260 datasheet doesn't 4729 * mention this restriction. At this stage it's not clear whether 4730 * this behaviour is intentional or is a hardware bug in chip 4731 * revisions available at least up until early 2006. Therefore for 4732 * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all 4733 * choices, but if it turns out that the lack of mic bias for these 4734 * NIDs is intentional we could change their modes from 4735 * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS. 4736 */ 4737 ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT), 4738 ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT), 4739 ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT), 4740 ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT), 4741 ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT), 4742 ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT), 4743 4744 /* Loopback mixer controls */ 4745 HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT), 4746 HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT), 4747 HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT), 4748 HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT), 4749 HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT), 4750 HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT), 4751 HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT), 4752 HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT), 4753 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 4754 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 4755 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT), 4756 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT), 4757 HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT), 4758 HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT), 4759 HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT), 4760 HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT), 4761 4762 /* Controls for GPIO pins, assuming they are configured as outputs */ 4763 ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01), 4764 ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02), 4765 ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04), 4766 ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08), 4767 4768 /* Switches to allow the digital IO pins to be enabled. The datasheet 4769 * is ambigious as to which NID is which; testing on laptops which 4770 * make this output available should provide clarification. 4771 */ 4772 ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01), 4773 ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01), 4774 4775 /* A switch allowing EAPD to be enabled. Some laptops seem to use 4776 * this output to turn on an external amplifier. 4777 */ 4778 ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02), 4779 ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02), 4780 4781 { } /* end */ 4782 }; 4783 static struct hda_verb alc260_test_init_verbs[] = { 4784 /* Enable all GPIOs as outputs with an initial value of 0 */ 4785 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f}, 4786 {0x01, AC_VERB_SET_GPIO_DATA, 0x00}, 4787 {0x01, AC_VERB_SET_GPIO_MASK, 0x0f}, 4788 4789 /* Enable retasking pins as output, initially without power amp */ 4790 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4791 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4792 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4793 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4794 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4795 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4796 4797 /* Disable digital (SPDIF) pins initially, but users can enable 4798 * them via a mixer switch. In the case of SPDIF-out, this initverb 4799 * payload also sets the generation to 0, output to be in "consumer" 4800 * PCM format, copyright asserted, no pre-emphasis and no validity 4801 * control. 4802 */ 4803 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0}, 4804 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0}, 4805 4806 /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the 4807 * OUT1 sum bus when acting as an output. 4808 */ 4809 {0x0b, AC_VERB_SET_CONNECT_SEL, 0}, 4810 {0x0c, AC_VERB_SET_CONNECT_SEL, 0}, 4811 {0x0d, AC_VERB_SET_CONNECT_SEL, 0}, 4812 {0x0e, AC_VERB_SET_CONNECT_SEL, 0}, 4813 4814 /* Start with output sum widgets muted and their output gains at min */ 4815 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4816 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4817 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4818 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4819 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4820 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4821 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4822 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4823 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4824 4825 /* Unmute retasking pin widget output buffers since the default 4826 * state appears to be output. As the pin mode is changed by the 4827 * user the pin mode control will take care of enabling the pin's 4828 * input/output buffers as needed. 4829 */ 4830 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4831 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4832 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4833 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4834 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4835 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4836 /* Also unmute the mono-out pin widget */ 4837 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4838 4839 /* Mute capture amp left and right */ 4840 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4841 /* Set ADC connection select to match default mixer setting (mic1 4842 * pin) 4843 */ 4844 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00}, 4845 4846 /* Do the same for the second ADC: mute capture input amp and 4847 * set ADC connection to mic1 pin 4848 */ 4849 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4850 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00}, 4851 4852 /* Mute all inputs to mixer widget (even unconnected ones) */ 4853 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */ 4854 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */ 4855 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */ 4856 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */ 4857 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */ 4858 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */ 4859 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */ 4860 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */ 4861 4862 { } 4863 }; 4864 #endif 4865 4866 #define alc260_pcm_analog_playback alc880_pcm_analog_alt_playback 4867 #define alc260_pcm_analog_capture alc880_pcm_analog_capture 4868 4869 #define alc260_pcm_digital_playback alc880_pcm_digital_playback 4870 #define alc260_pcm_digital_capture alc880_pcm_digital_capture 4871 4872 /* 4873 * for BIOS auto-configuration 4874 */ 4875 4876 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid, 4877 const char *pfx) 4878 { 4879 hda_nid_t nid_vol; 4880 unsigned long vol_val, sw_val; 4881 char name[32]; 4882 int err; 4883 4884 if (nid >= 0x0f && nid < 0x11) { 4885 nid_vol = nid - 0x7; 4886 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT); 4887 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 4888 } else if (nid == 0x11) { 4889 nid_vol = nid - 0x7; 4890 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT); 4891 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT); 4892 } else if (nid >= 0x12 && nid <= 0x15) { 4893 nid_vol = 0x08; 4894 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT); 4895 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 4896 } else 4897 return 0; /* N/A */ 4898 4899 snprintf(name, sizeof(name), "%s Playback Volume", pfx); 4900 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val); 4901 if (err < 0) 4902 return err; 4903 snprintf(name, sizeof(name), "%s Playback Switch", pfx); 4904 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val); 4905 if (err < 0) 4906 return err; 4907 return 1; 4908 } 4909 4910 /* add playback controls from the parsed DAC table */ 4911 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec, 4912 const struct auto_pin_cfg *cfg) 4913 { 4914 hda_nid_t nid; 4915 int err; 4916 4917 spec->multiout.num_dacs = 1; 4918 spec->multiout.dac_nids = spec->private_dac_nids; 4919 spec->multiout.dac_nids[0] = 0x02; 4920 4921 nid = cfg->line_out_pins[0]; 4922 if (nid) { 4923 err = alc260_add_playback_controls(spec, nid, "Front"); 4924 if (err < 0) 4925 return err; 4926 } 4927 4928 nid = cfg->speaker_pins[0]; 4929 if (nid) { 4930 err = alc260_add_playback_controls(spec, nid, "Speaker"); 4931 if (err < 0) 4932 return err; 4933 } 4934 4935 nid = cfg->hp_pins[0]; 4936 if (nid) { 4937 err = alc260_add_playback_controls(spec, nid, "Headphone"); 4938 if (err < 0) 4939 return err; 4940 } 4941 return 0; 4942 } 4943 4944 /* create playback/capture controls for input pins */ 4945 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec, 4946 const struct auto_pin_cfg *cfg) 4947 { 4948 struct hda_input_mux *imux = &spec->private_imux; 4949 int i, err, idx; 4950 4951 for (i = 0; i < AUTO_PIN_LAST; i++) { 4952 if (cfg->input_pins[i] >= 0x12) { 4953 idx = cfg->input_pins[i] - 0x12; 4954 err = new_analog_input(spec, cfg->input_pins[i], 4955 auto_pin_cfg_labels[i], idx, 4956 0x07); 4957 if (err < 0) 4958 return err; 4959 imux->items[imux->num_items].label = 4960 auto_pin_cfg_labels[i]; 4961 imux->items[imux->num_items].index = idx; 4962 imux->num_items++; 4963 } 4964 if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){ 4965 idx = cfg->input_pins[i] - 0x09; 4966 err = new_analog_input(spec, cfg->input_pins[i], 4967 auto_pin_cfg_labels[i], idx, 4968 0x07); 4969 if (err < 0) 4970 return err; 4971 imux->items[imux->num_items].label = 4972 auto_pin_cfg_labels[i]; 4973 imux->items[imux->num_items].index = idx; 4974 imux->num_items++; 4975 } 4976 } 4977 return 0; 4978 } 4979 4980 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec, 4981 hda_nid_t nid, int pin_type, 4982 int sel_idx) 4983 { 4984 alc_set_pin_output(codec, nid, pin_type); 4985 /* need the manual connection? */ 4986 if (nid >= 0x12) { 4987 int idx = nid - 0x12; 4988 snd_hda_codec_write(codec, idx + 0x0b, 0, 4989 AC_VERB_SET_CONNECT_SEL, sel_idx); 4990 } 4991 } 4992 4993 static void alc260_auto_init_multi_out(struct hda_codec *codec) 4994 { 4995 struct alc_spec *spec = codec->spec; 4996 hda_nid_t nid; 4997 4998 alc_subsystem_id(codec, 0x10, 0x15, 0x0f); 4999 nid = spec->autocfg.line_out_pins[0]; 5000 if (nid) { 5001 int pin_type = get_pin_type(spec->autocfg.line_out_type); 5002 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0); 5003 } 5004 5005 nid = spec->autocfg.speaker_pins[0]; 5006 if (nid) 5007 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0); 5008 5009 nid = spec->autocfg.hp_pins[0]; 5010 if (nid) 5011 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0); 5012 } 5013 5014 #define ALC260_PIN_CD_NID 0x16 5015 static void alc260_auto_init_analog_input(struct hda_codec *codec) 5016 { 5017 struct alc_spec *spec = codec->spec; 5018 int i; 5019 5020 for (i = 0; i < AUTO_PIN_LAST; i++) { 5021 hda_nid_t nid = spec->autocfg.input_pins[i]; 5022 if (nid >= 0x12) { 5023 snd_hda_codec_write(codec, nid, 0, 5024 AC_VERB_SET_PIN_WIDGET_CONTROL, 5025 i <= AUTO_PIN_FRONT_MIC ? 5026 PIN_VREF80 : PIN_IN); 5027 if (nid != ALC260_PIN_CD_NID) 5028 snd_hda_codec_write(codec, nid, 0, 5029 AC_VERB_SET_AMP_GAIN_MUTE, 5030 AMP_OUT_MUTE); 5031 } 5032 } 5033 } 5034 5035 /* 5036 * generic initialization of ADC, input mixers and output mixers 5037 */ 5038 static struct hda_verb alc260_volume_init_verbs[] = { 5039 /* 5040 * Unmute ADC0-1 and set the default input to mic-in 5041 */ 5042 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00}, 5043 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5044 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00}, 5045 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5046 5047 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 5048 * mixer widget 5049 * Note: PASD motherboards uses the Line In 2 as the input for 5050 * front panel mic (mic 2) 5051 */ 5052 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 5053 /* mute analog inputs */ 5054 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5055 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5056 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5057 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5058 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5059 5060 /* 5061 * Set up output mixers (0x08 - 0x0a) 5062 */ 5063 /* set vol=0 to output mixers */ 5064 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5065 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5066 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5067 /* set up input amps for analog loopback */ 5068 /* Amp Indices: DAC = 0, mixer = 1 */ 5069 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5070 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5071 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5072 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5073 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5074 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5075 5076 { } 5077 }; 5078 5079 static int alc260_parse_auto_config(struct hda_codec *codec) 5080 { 5081 struct alc_spec *spec = codec->spec; 5082 unsigned int wcap; 5083 int err; 5084 static hda_nid_t alc260_ignore[] = { 0x17, 0 }; 5085 5086 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 5087 alc260_ignore); 5088 if (err < 0) 5089 return err; 5090 err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg); 5091 if (err < 0) 5092 return err; 5093 if (!spec->kctl_alloc) 5094 return 0; /* can't find valid BIOS pin config */ 5095 err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg); 5096 if (err < 0) 5097 return err; 5098 5099 spec->multiout.max_channels = 2; 5100 5101 if (spec->autocfg.dig_out_pin) 5102 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID; 5103 if (spec->kctl_alloc) 5104 spec->mixers[spec->num_mixers++] = spec->kctl_alloc; 5105 5106 spec->init_verbs[spec->num_init_verbs++] = alc260_volume_init_verbs; 5107 5108 spec->num_mux_defs = 1; 5109 spec->input_mux = &spec->private_imux; 5110 5111 /* check whether NID 0x04 is valid */ 5112 wcap = get_wcaps(codec, 0x04); 5113 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */ 5114 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) { 5115 spec->adc_nids = alc260_adc_nids_alt; 5116 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt); 5117 spec->mixers[spec->num_mixers] = alc260_capture_alt_mixer; 5118 } else { 5119 spec->adc_nids = alc260_adc_nids; 5120 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids); 5121 spec->mixers[spec->num_mixers] = alc260_capture_mixer; 5122 } 5123 spec->num_mixers++; 5124 5125 return 1; 5126 } 5127 5128 /* additional initialization for auto-configuration model */ 5129 static void alc260_auto_init(struct hda_codec *codec) 5130 { 5131 struct alc_spec *spec = codec->spec; 5132 alc260_auto_init_multi_out(codec); 5133 alc260_auto_init_analog_input(codec); 5134 if (spec->unsol_event) 5135 alc_sku_automute(codec); 5136 } 5137 5138 #ifdef CONFIG_SND_HDA_POWER_SAVE 5139 static struct hda_amp_list alc260_loopbacks[] = { 5140 { 0x07, HDA_INPUT, 0 }, 5141 { 0x07, HDA_INPUT, 1 }, 5142 { 0x07, HDA_INPUT, 2 }, 5143 { 0x07, HDA_INPUT, 3 }, 5144 { 0x07, HDA_INPUT, 4 }, 5145 { } /* end */ 5146 }; 5147 #endif 5148 5149 /* 5150 * ALC260 configurations 5151 */ 5152 static const char *alc260_models[ALC260_MODEL_LAST] = { 5153 [ALC260_BASIC] = "basic", 5154 [ALC260_HP] = "hp", 5155 [ALC260_HP_3013] = "hp-3013", 5156 [ALC260_FUJITSU_S702X] = "fujitsu", 5157 [ALC260_ACER] = "acer", 5158 [ALC260_WILL] = "will", 5159 [ALC260_REPLACER_672V] = "replacer", 5160 #ifdef CONFIG_SND_DEBUG 5161 [ALC260_TEST] = "test", 5162 #endif 5163 [ALC260_AUTO] = "auto", 5164 }; 5165 5166 static struct snd_pci_quirk alc260_cfg_tbl[] = { 5167 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER), 5168 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER), 5169 SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013), 5170 SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013), 5171 SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013), 5172 SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013), 5173 SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_3013), 5174 SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013), 5175 SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP), 5176 SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP), 5177 SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP), 5178 SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC), 5179 SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC), 5180 SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC), 5181 SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X), 5182 SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC), 5183 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V), 5184 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL), 5185 {} 5186 }; 5187 5188 static struct alc_config_preset alc260_presets[] = { 5189 [ALC260_BASIC] = { 5190 .mixers = { alc260_base_output_mixer, 5191 alc260_input_mixer, 5192 alc260_pc_beep_mixer, 5193 alc260_capture_mixer }, 5194 .init_verbs = { alc260_init_verbs }, 5195 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5196 .dac_nids = alc260_dac_nids, 5197 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids), 5198 .adc_nids = alc260_adc_nids, 5199 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5200 .channel_mode = alc260_modes, 5201 .input_mux = &alc260_capture_source, 5202 }, 5203 [ALC260_HP] = { 5204 .mixers = { alc260_hp_output_mixer, 5205 alc260_input_mixer, 5206 alc260_capture_alt_mixer }, 5207 .init_verbs = { alc260_init_verbs, 5208 alc260_hp_unsol_verbs }, 5209 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5210 .dac_nids = alc260_dac_nids, 5211 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids), 5212 .adc_nids = alc260_hp_adc_nids, 5213 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5214 .channel_mode = alc260_modes, 5215 .input_mux = &alc260_capture_source, 5216 .unsol_event = alc260_hp_unsol_event, 5217 .init_hook = alc260_hp_automute, 5218 }, 5219 [ALC260_HP_3013] = { 5220 .mixers = { alc260_hp_3013_mixer, 5221 alc260_input_mixer, 5222 alc260_capture_alt_mixer }, 5223 .init_verbs = { alc260_hp_3013_init_verbs, 5224 alc260_hp_3013_unsol_verbs }, 5225 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5226 .dac_nids = alc260_dac_nids, 5227 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids), 5228 .adc_nids = alc260_hp_adc_nids, 5229 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5230 .channel_mode = alc260_modes, 5231 .input_mux = &alc260_capture_source, 5232 .unsol_event = alc260_hp_3013_unsol_event, 5233 .init_hook = alc260_hp_3013_automute, 5234 }, 5235 [ALC260_FUJITSU_S702X] = { 5236 .mixers = { alc260_fujitsu_mixer, 5237 alc260_capture_mixer }, 5238 .init_verbs = { alc260_fujitsu_init_verbs }, 5239 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5240 .dac_nids = alc260_dac_nids, 5241 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids), 5242 .adc_nids = alc260_dual_adc_nids, 5243 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5244 .channel_mode = alc260_modes, 5245 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources), 5246 .input_mux = alc260_fujitsu_capture_sources, 5247 }, 5248 [ALC260_ACER] = { 5249 .mixers = { alc260_acer_mixer, 5250 alc260_capture_mixer }, 5251 .init_verbs = { alc260_acer_init_verbs }, 5252 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5253 .dac_nids = alc260_dac_nids, 5254 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids), 5255 .adc_nids = alc260_dual_adc_nids, 5256 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5257 .channel_mode = alc260_modes, 5258 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources), 5259 .input_mux = alc260_acer_capture_sources, 5260 }, 5261 [ALC260_WILL] = { 5262 .mixers = { alc260_will_mixer, 5263 alc260_capture_mixer }, 5264 .init_verbs = { alc260_init_verbs, alc260_will_verbs }, 5265 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5266 .dac_nids = alc260_dac_nids, 5267 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids), 5268 .adc_nids = alc260_adc_nids, 5269 .dig_out_nid = ALC260_DIGOUT_NID, 5270 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5271 .channel_mode = alc260_modes, 5272 .input_mux = &alc260_capture_source, 5273 }, 5274 [ALC260_REPLACER_672V] = { 5275 .mixers = { alc260_replacer_672v_mixer, 5276 alc260_capture_mixer }, 5277 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs }, 5278 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5279 .dac_nids = alc260_dac_nids, 5280 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids), 5281 .adc_nids = alc260_adc_nids, 5282 .dig_out_nid = ALC260_DIGOUT_NID, 5283 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5284 .channel_mode = alc260_modes, 5285 .input_mux = &alc260_capture_source, 5286 .unsol_event = alc260_replacer_672v_unsol_event, 5287 .init_hook = alc260_replacer_672v_automute, 5288 }, 5289 #ifdef CONFIG_SND_DEBUG 5290 [ALC260_TEST] = { 5291 .mixers = { alc260_test_mixer, 5292 alc260_capture_mixer }, 5293 .init_verbs = { alc260_test_init_verbs }, 5294 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids), 5295 .dac_nids = alc260_test_dac_nids, 5296 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids), 5297 .adc_nids = alc260_test_adc_nids, 5298 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5299 .channel_mode = alc260_modes, 5300 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources), 5301 .input_mux = alc260_test_capture_sources, 5302 }, 5303 #endif 5304 }; 5305 5306 static int patch_alc260(struct hda_codec *codec) 5307 { 5308 struct alc_spec *spec; 5309 int err, board_config; 5310 5311 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5312 if (spec == NULL) 5313 return -ENOMEM; 5314 5315 codec->spec = spec; 5316 5317 board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST, 5318 alc260_models, 5319 alc260_cfg_tbl); 5320 if (board_config < 0) { 5321 snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260, " 5322 "trying auto-probe from BIOS...\n"); 5323 board_config = ALC260_AUTO; 5324 } 5325 5326 if (board_config == ALC260_AUTO) { 5327 /* automatic parse from the BIOS config */ 5328 err = alc260_parse_auto_config(codec); 5329 if (err < 0) { 5330 alc_free(codec); 5331 return err; 5332 } else if (!err) { 5333 printk(KERN_INFO 5334 "hda_codec: Cannot set up configuration " 5335 "from BIOS. Using base mode...\n"); 5336 board_config = ALC260_BASIC; 5337 } 5338 } 5339 5340 if (board_config != ALC260_AUTO) 5341 setup_preset(spec, &alc260_presets[board_config]); 5342 5343 spec->stream_name_analog = "ALC260 Analog"; 5344 spec->stream_analog_playback = &alc260_pcm_analog_playback; 5345 spec->stream_analog_capture = &alc260_pcm_analog_capture; 5346 5347 spec->stream_name_digital = "ALC260 Digital"; 5348 spec->stream_digital_playback = &alc260_pcm_digital_playback; 5349 spec->stream_digital_capture = &alc260_pcm_digital_capture; 5350 5351 spec->vmaster_nid = 0x08; 5352 5353 codec->patch_ops = alc_patch_ops; 5354 if (board_config == ALC260_AUTO) 5355 spec->init_hook = alc260_auto_init; 5356 #ifdef CONFIG_SND_HDA_POWER_SAVE 5357 if (!spec->loopback.amplist) 5358 spec->loopback.amplist = alc260_loopbacks; 5359 #endif 5360 5361 return 0; 5362 } 5363 5364 5365 /* 5366 * ALC882 support 5367 * 5368 * ALC882 is almost identical with ALC880 but has cleaner and more flexible 5369 * configuration. Each pin widget can choose any input DACs and a mixer. 5370 * Each ADC is connected from a mixer of all inputs. This makes possible 5371 * 6-channel independent captures. 5372 * 5373 * In addition, an independent DAC for the multi-playback (not used in this 5374 * driver yet). 5375 */ 5376 #define ALC882_DIGOUT_NID 0x06 5377 #define ALC882_DIGIN_NID 0x0a 5378 5379 static struct hda_channel_mode alc882_ch_modes[1] = { 5380 { 8, NULL } 5381 }; 5382 5383 static hda_nid_t alc882_dac_nids[4] = { 5384 /* front, rear, clfe, rear_surr */ 5385 0x02, 0x03, 0x04, 0x05 5386 }; 5387 5388 /* identical with ALC880 */ 5389 #define alc882_adc_nids alc880_adc_nids 5390 #define alc882_adc_nids_alt alc880_adc_nids_alt 5391 5392 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 }; 5393 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 }; 5394 5395 /* input MUX */ 5396 /* FIXME: should be a matrix-type input source selection */ 5397 5398 static struct hda_input_mux alc882_capture_source = { 5399 .num_items = 4, 5400 .items = { 5401 { "Mic", 0x0 }, 5402 { "Front Mic", 0x1 }, 5403 { "Line", 0x2 }, 5404 { "CD", 0x4 }, 5405 }, 5406 }; 5407 #define alc882_mux_enum_info alc_mux_enum_info 5408 #define alc882_mux_enum_get alc_mux_enum_get 5409 5410 static int alc882_mux_enum_put(struct snd_kcontrol *kcontrol, 5411 struct snd_ctl_elem_value *ucontrol) 5412 { 5413 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 5414 struct alc_spec *spec = codec->spec; 5415 const struct hda_input_mux *imux = spec->input_mux; 5416 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 5417 hda_nid_t nid = spec->capsrc_nids ? 5418 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx]; 5419 unsigned int *cur_val = &spec->cur_mux[adc_idx]; 5420 unsigned int i, idx; 5421 5422 idx = ucontrol->value.enumerated.item[0]; 5423 if (idx >= imux->num_items) 5424 idx = imux->num_items - 1; 5425 if (*cur_val == idx) 5426 return 0; 5427 for (i = 0; i < imux->num_items; i++) { 5428 unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE; 5429 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 5430 imux->items[i].index, 5431 HDA_AMP_MUTE, v); 5432 } 5433 *cur_val = idx; 5434 return 1; 5435 } 5436 5437 /* 5438 * 2ch mode 5439 */ 5440 static struct hda_verb alc882_3ST_ch2_init[] = { 5441 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 5442 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 5443 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 5444 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 5445 { } /* end */ 5446 }; 5447 5448 /* 5449 * 6ch mode 5450 */ 5451 static struct hda_verb alc882_3ST_ch6_init[] = { 5452 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 5453 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 5454 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 }, 5455 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 5456 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 5457 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 5458 { } /* end */ 5459 }; 5460 5461 static struct hda_channel_mode alc882_3ST_6ch_modes[2] = { 5462 { 2, alc882_3ST_ch2_init }, 5463 { 6, alc882_3ST_ch6_init }, 5464 }; 5465 5466 /* 5467 * 6ch mode 5468 */ 5469 static struct hda_verb alc882_sixstack_ch6_init[] = { 5470 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 5471 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 5472 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 5473 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 5474 { } /* end */ 5475 }; 5476 5477 /* 5478 * 8ch mode 5479 */ 5480 static struct hda_verb alc882_sixstack_ch8_init[] = { 5481 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 5482 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 5483 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 5484 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 5485 { } /* end */ 5486 }; 5487 5488 static struct hda_channel_mode alc882_sixstack_modes[2] = { 5489 { 6, alc882_sixstack_ch6_init }, 5490 { 8, alc882_sixstack_ch8_init }, 5491 }; 5492 5493 /* 5494 * macbook pro ALC885 can switch LineIn to LineOut without loosing Mic 5495 */ 5496 5497 /* 5498 * 2ch mode 5499 */ 5500 static struct hda_verb alc885_mbp_ch2_init[] = { 5501 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 5502 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5503 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5504 { } /* end */ 5505 }; 5506 5507 /* 5508 * 6ch mode 5509 */ 5510 static struct hda_verb alc885_mbp_ch6_init[] = { 5511 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 5512 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5513 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 5514 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5515 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5516 { } /* end */ 5517 }; 5518 5519 static struct hda_channel_mode alc885_mbp_6ch_modes[2] = { 5520 { 2, alc885_mbp_ch2_init }, 5521 { 6, alc885_mbp_ch6_init }, 5522 }; 5523 5524 5525 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17 5526 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b 5527 */ 5528 static struct snd_kcontrol_new alc882_base_mixer[] = { 5529 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 5530 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 5531 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 5532 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 5533 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 5534 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 5535 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 5536 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 5537 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 5538 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 5539 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 5540 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 5541 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 5542 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 5543 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 5544 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 5545 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 5546 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 5547 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 5548 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 5549 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 5550 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 5551 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 5552 { } /* end */ 5553 }; 5554 5555 static struct snd_kcontrol_new alc885_mbp3_mixer[] = { 5556 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT), 5557 HDA_BIND_MUTE ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT), 5558 HDA_CODEC_MUTE ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT), 5559 HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT), 5560 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 5561 HDA_CODEC_MUTE ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 5562 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT), 5563 HDA_CODEC_MUTE ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT), 5564 HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT), 5565 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT), 5566 { } /* end */ 5567 }; 5568 static struct snd_kcontrol_new alc882_w2jc_mixer[] = { 5569 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 5570 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 5571 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 5572 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 5573 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 5574 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 5575 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 5576 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 5577 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 5578 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 5579 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 5580 { } /* end */ 5581 }; 5582 5583 static struct snd_kcontrol_new alc882_targa_mixer[] = { 5584 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 5585 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 5586 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 5587 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 5588 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 5589 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 5590 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 5591 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 5592 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 5593 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 5594 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 5595 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 5596 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 5597 { } /* end */ 5598 }; 5599 5600 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ??? 5601 * Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c 5602 */ 5603 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = { 5604 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 5605 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 5606 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 5607 HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT), 5608 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 5609 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 5610 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 5611 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 5612 HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT), 5613 HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT), 5614 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 5615 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 5616 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 5617 { } /* end */ 5618 }; 5619 5620 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = { 5621 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 5622 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 5623 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 5624 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 5625 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 5626 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 5627 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 5628 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 5629 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 5630 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 5631 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 5632 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 5633 { } /* end */ 5634 }; 5635 5636 static struct snd_kcontrol_new alc882_chmode_mixer[] = { 5637 { 5638 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 5639 .name = "Channel Mode", 5640 .info = alc_ch_mode_info, 5641 .get = alc_ch_mode_get, 5642 .put = alc_ch_mode_put, 5643 }, 5644 { } /* end */ 5645 }; 5646 5647 static struct hda_verb alc882_init_verbs[] = { 5648 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 5649 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5650 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5651 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5652 /* Rear mixer */ 5653 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5654 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5655 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5656 /* CLFE mixer */ 5657 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5658 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5659 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5660 /* Side mixer */ 5661 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5662 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5663 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5664 5665 /* Front Pin: output 0 (0x0c) */ 5666 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5667 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5668 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 5669 /* Rear Pin: output 1 (0x0d) */ 5670 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5671 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5672 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 5673 /* CLFE Pin: output 2 (0x0e) */ 5674 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5675 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5676 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02}, 5677 /* Side Pin: output 3 (0x0f) */ 5678 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5679 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5680 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 5681 /* Mic (rear) pin: input vref at 80% */ 5682 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 5683 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 5684 /* Front Mic pin: input vref at 80% */ 5685 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 5686 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 5687 /* Line In pin: input */ 5688 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 5689 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 5690 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 5691 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 5692 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5693 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 5694 /* CD pin widget for input */ 5695 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 5696 5697 /* FIXME: use matrix-type input source selection */ 5698 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 5699 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 5700 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5701 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5702 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5703 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5704 /* Input mixer2 */ 5705 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5706 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5707 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5708 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5709 /* Input mixer3 */ 5710 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5711 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5712 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5713 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5714 /* ADC1: mute amp left and right */ 5715 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5716 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 5717 /* ADC2: mute amp left and right */ 5718 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5719 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 5720 /* ADC3: mute amp left and right */ 5721 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5722 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 5723 5724 { } 5725 }; 5726 5727 static struct hda_verb alc882_eapd_verbs[] = { 5728 /* change to EAPD mode */ 5729 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 5730 {0x20, AC_VERB_SET_PROC_COEF, 0x3060}, 5731 { } 5732 }; 5733 5734 /* Mac Pro test */ 5735 static struct snd_kcontrol_new alc882_macpro_mixer[] = { 5736 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 5737 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 5738 HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT), 5739 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT), 5740 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT), 5741 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT), 5742 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT), 5743 { } /* end */ 5744 }; 5745 5746 static struct hda_verb alc882_macpro_init_verbs[] = { 5747 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 5748 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5749 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5750 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5751 /* Front Pin: output 0 (0x0c) */ 5752 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5753 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5754 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 5755 /* Front Mic pin: input vref at 80% */ 5756 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 5757 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 5758 /* Speaker: output */ 5759 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5760 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5761 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04}, 5762 /* Headphone output (output 0 - 0x0c) */ 5763 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 5764 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5765 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00}, 5766 5767 /* FIXME: use matrix-type input source selection */ 5768 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 5769 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 5770 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5771 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5772 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5773 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5774 /* Input mixer2 */ 5775 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5776 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5777 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5778 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5779 /* Input mixer3 */ 5780 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5781 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5782 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5783 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5784 /* ADC1: mute amp left and right */ 5785 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5786 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 5787 /* ADC2: mute amp left and right */ 5788 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5789 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 5790 /* ADC3: mute amp left and right */ 5791 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5792 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 5793 5794 { } 5795 }; 5796 5797 /* Macbook Pro rev3 */ 5798 static struct hda_verb alc885_mbp3_init_verbs[] = { 5799 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 5800 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5801 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5802 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5803 /* Rear mixer */ 5804 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5805 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5806 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5807 /* Front Pin: output 0 (0x0c) */ 5808 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5809 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5810 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 5811 /* HP Pin: output 0 (0x0d) */ 5812 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4}, 5813 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 5814 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 5815 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 5816 /* Mic (rear) pin: input vref at 80% */ 5817 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 5818 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 5819 /* Front Mic pin: input vref at 80% */ 5820 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 5821 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 5822 /* Line In pin: use output 1 when in LineOut mode */ 5823 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 5824 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 5825 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, 5826 5827 /* FIXME: use matrix-type input source selection */ 5828 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 5829 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 5830 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5831 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5832 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5833 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5834 /* Input mixer2 */ 5835 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5836 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5837 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5838 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5839 /* Input mixer3 */ 5840 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5841 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5842 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5843 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5844 /* ADC1: mute amp left and right */ 5845 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5846 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 5847 /* ADC2: mute amp left and right */ 5848 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5849 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 5850 /* ADC3: mute amp left and right */ 5851 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5852 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 5853 5854 { } 5855 }; 5856 5857 /* iMac 24 mixer. */ 5858 static struct snd_kcontrol_new alc885_imac24_mixer[] = { 5859 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT), 5860 HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT), 5861 { } /* end */ 5862 }; 5863 5864 /* iMac 24 init verbs. */ 5865 static struct hda_verb alc885_imac24_init_verbs[] = { 5866 /* Internal speakers: output 0 (0x0c) */ 5867 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5868 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5869 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00}, 5870 /* Internal speakers: output 0 (0x0c) */ 5871 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5872 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5873 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00}, 5874 /* Headphone: output 0 (0x0c) */ 5875 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 5876 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5877 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 5878 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 5879 /* Front Mic: input vref at 80% */ 5880 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 5881 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 5882 { } 5883 }; 5884 5885 /* Toggle speaker-output according to the hp-jack state */ 5886 static void alc885_imac24_automute(struct hda_codec *codec) 5887 { 5888 unsigned int present; 5889 5890 present = snd_hda_codec_read(codec, 0x14, 0, 5891 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 5892 snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0, 5893 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 5894 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0, 5895 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 5896 } 5897 5898 /* Processes unsolicited events. */ 5899 static void alc885_imac24_unsol_event(struct hda_codec *codec, 5900 unsigned int res) 5901 { 5902 /* Headphone insertion or removal. */ 5903 if ((res >> 26) == ALC880_HP_EVENT) 5904 alc885_imac24_automute(codec); 5905 } 5906 5907 static void alc885_mbp3_automute(struct hda_codec *codec) 5908 { 5909 unsigned int present; 5910 5911 present = snd_hda_codec_read(codec, 0x15, 0, 5912 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 5913 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 5914 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 5915 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 5916 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE); 5917 5918 } 5919 static void alc885_mbp3_unsol_event(struct hda_codec *codec, 5920 unsigned int res) 5921 { 5922 /* Headphone insertion or removal. */ 5923 if ((res >> 26) == ALC880_HP_EVENT) 5924 alc885_mbp3_automute(codec); 5925 } 5926 5927 5928 static struct hda_verb alc882_targa_verbs[] = { 5929 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5930 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5931 5932 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 5933 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5934 5935 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 5936 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */ 5937 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 5938 5939 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 5940 {0x01, AC_VERB_SET_GPIO_MASK, 0x03}, 5941 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03}, 5942 {0x01, AC_VERB_SET_GPIO_DATA, 0x03}, 5943 { } /* end */ 5944 }; 5945 5946 /* toggle speaker-output according to the hp-jack state */ 5947 static void alc882_targa_automute(struct hda_codec *codec) 5948 { 5949 unsigned int present; 5950 5951 present = snd_hda_codec_read(codec, 0x14, 0, 5952 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 5953 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 5954 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 5955 snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA, 5956 present ? 1 : 3); 5957 } 5958 5959 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res) 5960 { 5961 /* Looks like the unsol event is incompatible with the standard 5962 * definition. 4bit tag is placed at 26 bit! 5963 */ 5964 if (((res >> 26) == ALC880_HP_EVENT)) { 5965 alc882_targa_automute(codec); 5966 } 5967 } 5968 5969 static struct hda_verb alc882_asus_a7j_verbs[] = { 5970 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5971 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5972 5973 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 5974 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5975 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5976 5977 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */ 5978 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 5979 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */ 5980 5981 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 5982 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */ 5983 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 5984 { } /* end */ 5985 }; 5986 5987 static struct hda_verb alc882_asus_a7m_verbs[] = { 5988 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5989 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5990 5991 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 5992 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5993 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5994 5995 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */ 5996 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 5997 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */ 5998 5999 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 6000 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */ 6001 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 6002 { } /* end */ 6003 }; 6004 6005 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted) 6006 { 6007 unsigned int gpiostate, gpiomask, gpiodir; 6008 6009 gpiostate = snd_hda_codec_read(codec, codec->afg, 0, 6010 AC_VERB_GET_GPIO_DATA, 0); 6011 6012 if (!muted) 6013 gpiostate |= (1 << pin); 6014 else 6015 gpiostate &= ~(1 << pin); 6016 6017 gpiomask = snd_hda_codec_read(codec, codec->afg, 0, 6018 AC_VERB_GET_GPIO_MASK, 0); 6019 gpiomask |= (1 << pin); 6020 6021 gpiodir = snd_hda_codec_read(codec, codec->afg, 0, 6022 AC_VERB_GET_GPIO_DIRECTION, 0); 6023 gpiodir |= (1 << pin); 6024 6025 6026 snd_hda_codec_write(codec, codec->afg, 0, 6027 AC_VERB_SET_GPIO_MASK, gpiomask); 6028 snd_hda_codec_write(codec, codec->afg, 0, 6029 AC_VERB_SET_GPIO_DIRECTION, gpiodir); 6030 6031 msleep(1); 6032 6033 snd_hda_codec_write(codec, codec->afg, 0, 6034 AC_VERB_SET_GPIO_DATA, gpiostate); 6035 } 6036 6037 /* set up GPIO at initialization */ 6038 static void alc885_macpro_init_hook(struct hda_codec *codec) 6039 { 6040 alc882_gpio_mute(codec, 0, 0); 6041 alc882_gpio_mute(codec, 1, 0); 6042 } 6043 6044 /* set up GPIO and update auto-muting at initialization */ 6045 static void alc885_imac24_init_hook(struct hda_codec *codec) 6046 { 6047 alc885_macpro_init_hook(codec); 6048 alc885_imac24_automute(codec); 6049 } 6050 6051 /* 6052 * generic initialization of ADC, input mixers and output mixers 6053 */ 6054 static struct hda_verb alc882_auto_init_verbs[] = { 6055 /* 6056 * Unmute ADC0-2 and set the default input to mic-in 6057 */ 6058 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 6059 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6060 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 6061 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6062 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 6063 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6064 6065 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 6066 * mixer widget 6067 * Note: PASD motherboards uses the Line In 2 as the input for 6068 * front panel mic (mic 2) 6069 */ 6070 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 6071 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6072 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6073 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6074 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6075 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6076 6077 /* 6078 * Set up output mixers (0x0c - 0x0f) 6079 */ 6080 /* set vol=0 to output mixers */ 6081 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6082 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6083 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6084 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6085 /* set up input amps for analog loopback */ 6086 /* Amp Indices: DAC = 0, mixer = 1 */ 6087 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6088 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6089 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6090 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6091 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6092 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6093 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6094 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6095 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6096 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6097 6098 /* FIXME: use matrix-type input source selection */ 6099 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 6100 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 6101 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 6102 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 6103 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 6104 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 6105 /* Input mixer2 */ 6106 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 6107 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 6108 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 6109 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 6110 /* Input mixer3 */ 6111 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 6112 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 6113 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 6114 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 6115 6116 { } 6117 }; 6118 6119 /* capture mixer elements */ 6120 static struct snd_kcontrol_new alc882_capture_alt_mixer[] = { 6121 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 6122 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 6123 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 6124 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 6125 { 6126 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6127 /* The multiple "Capture Source" controls confuse alsamixer 6128 * So call somewhat different.. 6129 */ 6130 /* .name = "Capture Source", */ 6131 .name = "Input Source", 6132 .count = 2, 6133 .info = alc882_mux_enum_info, 6134 .get = alc882_mux_enum_get, 6135 .put = alc882_mux_enum_put, 6136 }, 6137 { } /* end */ 6138 }; 6139 6140 static struct snd_kcontrol_new alc882_capture_mixer[] = { 6141 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT), 6142 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT), 6143 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT), 6144 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT), 6145 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT), 6146 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT), 6147 { 6148 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6149 /* The multiple "Capture Source" controls confuse alsamixer 6150 * So call somewhat different.. 6151 */ 6152 /* .name = "Capture Source", */ 6153 .name = "Input Source", 6154 .count = 3, 6155 .info = alc882_mux_enum_info, 6156 .get = alc882_mux_enum_get, 6157 .put = alc882_mux_enum_put, 6158 }, 6159 { } /* end */ 6160 }; 6161 6162 #ifdef CONFIG_SND_HDA_POWER_SAVE 6163 #define alc882_loopbacks alc880_loopbacks 6164 #endif 6165 6166 /* pcm configuration: identiacal with ALC880 */ 6167 #define alc882_pcm_analog_playback alc880_pcm_analog_playback 6168 #define alc882_pcm_analog_capture alc880_pcm_analog_capture 6169 #define alc882_pcm_digital_playback alc880_pcm_digital_playback 6170 #define alc882_pcm_digital_capture alc880_pcm_digital_capture 6171 6172 /* 6173 * configuration and preset 6174 */ 6175 static const char *alc882_models[ALC882_MODEL_LAST] = { 6176 [ALC882_3ST_DIG] = "3stack-dig", 6177 [ALC882_6ST_DIG] = "6stack-dig", 6178 [ALC882_ARIMA] = "arima", 6179 [ALC882_W2JC] = "w2jc", 6180 [ALC882_TARGA] = "targa", 6181 [ALC882_ASUS_A7J] = "asus-a7j", 6182 [ALC882_ASUS_A7M] = "asus-a7m", 6183 [ALC885_MACPRO] = "macpro", 6184 [ALC885_MBP3] = "mbp3", 6185 [ALC885_IMAC24] = "imac24", 6186 [ALC882_AUTO] = "auto", 6187 }; 6188 6189 static struct snd_pci_quirk alc882_cfg_tbl[] = { 6190 SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG), 6191 SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J), 6192 SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J), 6193 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M), 6194 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC), 6195 SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG), 6196 SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG), 6197 SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG), 6198 SND_PCI_QUIRK(0x106b, 0x00a0, "Apple iMac 24''", ALC885_IMAC24), 6199 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG), 6200 SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8 */ 6201 SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG), 6202 SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), 6203 {} 6204 }; 6205 6206 static struct alc_config_preset alc882_presets[] = { 6207 [ALC882_3ST_DIG] = { 6208 .mixers = { alc882_base_mixer }, 6209 .init_verbs = { alc882_init_verbs }, 6210 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6211 .dac_nids = alc882_dac_nids, 6212 .dig_out_nid = ALC882_DIGOUT_NID, 6213 .dig_in_nid = ALC882_DIGIN_NID, 6214 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes), 6215 .channel_mode = alc882_ch_modes, 6216 .need_dac_fix = 1, 6217 .input_mux = &alc882_capture_source, 6218 }, 6219 [ALC882_6ST_DIG] = { 6220 .mixers = { alc882_base_mixer, alc882_chmode_mixer }, 6221 .init_verbs = { alc882_init_verbs }, 6222 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6223 .dac_nids = alc882_dac_nids, 6224 .dig_out_nid = ALC882_DIGOUT_NID, 6225 .dig_in_nid = ALC882_DIGIN_NID, 6226 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes), 6227 .channel_mode = alc882_sixstack_modes, 6228 .input_mux = &alc882_capture_source, 6229 }, 6230 [ALC882_ARIMA] = { 6231 .mixers = { alc882_base_mixer, alc882_chmode_mixer }, 6232 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs }, 6233 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6234 .dac_nids = alc882_dac_nids, 6235 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes), 6236 .channel_mode = alc882_sixstack_modes, 6237 .input_mux = &alc882_capture_source, 6238 }, 6239 [ALC882_W2JC] = { 6240 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer }, 6241 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs, 6242 alc880_gpio1_init_verbs }, 6243 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6244 .dac_nids = alc882_dac_nids, 6245 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 6246 .channel_mode = alc880_threestack_modes, 6247 .need_dac_fix = 1, 6248 .input_mux = &alc882_capture_source, 6249 .dig_out_nid = ALC882_DIGOUT_NID, 6250 }, 6251 [ALC885_MBP3] = { 6252 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer }, 6253 .init_verbs = { alc885_mbp3_init_verbs, 6254 alc880_gpio1_init_verbs }, 6255 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6256 .dac_nids = alc882_dac_nids, 6257 .channel_mode = alc885_mbp_6ch_modes, 6258 .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes), 6259 .input_mux = &alc882_capture_source, 6260 .dig_out_nid = ALC882_DIGOUT_NID, 6261 .dig_in_nid = ALC882_DIGIN_NID, 6262 .unsol_event = alc885_mbp3_unsol_event, 6263 .init_hook = alc885_mbp3_automute, 6264 }, 6265 [ALC885_MACPRO] = { 6266 .mixers = { alc882_macpro_mixer }, 6267 .init_verbs = { alc882_macpro_init_verbs }, 6268 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6269 .dac_nids = alc882_dac_nids, 6270 .dig_out_nid = ALC882_DIGOUT_NID, 6271 .dig_in_nid = ALC882_DIGIN_NID, 6272 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes), 6273 .channel_mode = alc882_ch_modes, 6274 .input_mux = &alc882_capture_source, 6275 .init_hook = alc885_macpro_init_hook, 6276 }, 6277 [ALC885_IMAC24] = { 6278 .mixers = { alc885_imac24_mixer }, 6279 .init_verbs = { alc885_imac24_init_verbs }, 6280 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6281 .dac_nids = alc882_dac_nids, 6282 .dig_out_nid = ALC882_DIGOUT_NID, 6283 .dig_in_nid = ALC882_DIGIN_NID, 6284 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes), 6285 .channel_mode = alc882_ch_modes, 6286 .input_mux = &alc882_capture_source, 6287 .unsol_event = alc885_imac24_unsol_event, 6288 .init_hook = alc885_imac24_init_hook, 6289 }, 6290 [ALC882_TARGA] = { 6291 .mixers = { alc882_targa_mixer, alc882_chmode_mixer, 6292 alc882_capture_mixer }, 6293 .init_verbs = { alc882_init_verbs, alc882_targa_verbs}, 6294 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6295 .dac_nids = alc882_dac_nids, 6296 .dig_out_nid = ALC882_DIGOUT_NID, 6297 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids), 6298 .adc_nids = alc882_adc_nids, 6299 .capsrc_nids = alc882_capsrc_nids, 6300 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes), 6301 .channel_mode = alc882_3ST_6ch_modes, 6302 .need_dac_fix = 1, 6303 .input_mux = &alc882_capture_source, 6304 .unsol_event = alc882_targa_unsol_event, 6305 .init_hook = alc882_targa_automute, 6306 }, 6307 [ALC882_ASUS_A7J] = { 6308 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer, 6309 alc882_capture_mixer }, 6310 .init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs}, 6311 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6312 .dac_nids = alc882_dac_nids, 6313 .dig_out_nid = ALC882_DIGOUT_NID, 6314 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids), 6315 .adc_nids = alc882_adc_nids, 6316 .capsrc_nids = alc882_capsrc_nids, 6317 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes), 6318 .channel_mode = alc882_3ST_6ch_modes, 6319 .need_dac_fix = 1, 6320 .input_mux = &alc882_capture_source, 6321 }, 6322 [ALC882_ASUS_A7M] = { 6323 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer }, 6324 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs, 6325 alc880_gpio1_init_verbs, 6326 alc882_asus_a7m_verbs }, 6327 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6328 .dac_nids = alc882_dac_nids, 6329 .dig_out_nid = ALC882_DIGOUT_NID, 6330 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 6331 .channel_mode = alc880_threestack_modes, 6332 .need_dac_fix = 1, 6333 .input_mux = &alc882_capture_source, 6334 }, 6335 }; 6336 6337 6338 /* 6339 * Pin config fixes 6340 */ 6341 enum { 6342 PINFIX_ABIT_AW9D_MAX 6343 }; 6344 6345 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = { 6346 { 0x15, 0x01080104 }, /* side */ 6347 { 0x16, 0x01011012 }, /* rear */ 6348 { 0x17, 0x01016011 }, /* clfe */ 6349 { } 6350 }; 6351 6352 static const struct alc_pincfg *alc882_pin_fixes[] = { 6353 [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix, 6354 }; 6355 6356 static struct snd_pci_quirk alc882_pinfix_tbl[] = { 6357 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX), 6358 {} 6359 }; 6360 6361 /* 6362 * BIOS auto configuration 6363 */ 6364 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec, 6365 hda_nid_t nid, int pin_type, 6366 int dac_idx) 6367 { 6368 /* set as output */ 6369 struct alc_spec *spec = codec->spec; 6370 int idx; 6371 6372 alc_set_pin_output(codec, nid, pin_type); 6373 if (spec->multiout.dac_nids[dac_idx] == 0x25) 6374 idx = 4; 6375 else 6376 idx = spec->multiout.dac_nids[dac_idx] - 2; 6377 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx); 6378 6379 } 6380 6381 static void alc882_auto_init_multi_out(struct hda_codec *codec) 6382 { 6383 struct alc_spec *spec = codec->spec; 6384 int i; 6385 6386 alc_subsystem_id(codec, 0x15, 0x1b, 0x14); 6387 for (i = 0; i <= HDA_SIDE; i++) { 6388 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 6389 int pin_type = get_pin_type(spec->autocfg.line_out_type); 6390 if (nid) 6391 alc882_auto_set_output_and_unmute(codec, nid, pin_type, 6392 i); 6393 } 6394 } 6395 6396 static void alc882_auto_init_hp_out(struct hda_codec *codec) 6397 { 6398 struct alc_spec *spec = codec->spec; 6399 hda_nid_t pin; 6400 6401 pin = spec->autocfg.hp_pins[0]; 6402 if (pin) /* connect to front */ 6403 /* use dac 0 */ 6404 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 6405 pin = spec->autocfg.speaker_pins[0]; 6406 if (pin) 6407 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 6408 } 6409 6410 #define alc882_is_input_pin(nid) alc880_is_input_pin(nid) 6411 #define ALC882_PIN_CD_NID ALC880_PIN_CD_NID 6412 6413 static void alc882_auto_init_analog_input(struct hda_codec *codec) 6414 { 6415 struct alc_spec *spec = codec->spec; 6416 int i; 6417 6418 for (i = 0; i < AUTO_PIN_LAST; i++) { 6419 hda_nid_t nid = spec->autocfg.input_pins[i]; 6420 unsigned int vref; 6421 if (!nid) 6422 continue; 6423 vref = PIN_IN; 6424 if (1 /*i <= AUTO_PIN_FRONT_MIC*/) { 6425 unsigned int pincap; 6426 pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP); 6427 if ((pincap >> AC_PINCAP_VREF_SHIFT) & 6428 AC_PINCAP_VREF_80) 6429 vref = PIN_VREF80; 6430 } 6431 snd_hda_codec_write(codec, nid, 0, 6432 AC_VERB_SET_PIN_WIDGET_CONTROL, vref); 6433 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) 6434 snd_hda_codec_write(codec, nid, 0, 6435 AC_VERB_SET_AMP_GAIN_MUTE, 6436 AMP_OUT_MUTE); 6437 } 6438 } 6439 6440 /* add mic boosts if needed */ 6441 static int alc_auto_add_mic_boost(struct hda_codec *codec) 6442 { 6443 struct alc_spec *spec = codec->spec; 6444 int err; 6445 hda_nid_t nid; 6446 6447 nid = spec->autocfg.input_pins[AUTO_PIN_MIC]; 6448 if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) { 6449 err = add_control(spec, ALC_CTL_WIDGET_VOL, 6450 "Mic Boost", 6451 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT)); 6452 if (err < 0) 6453 return err; 6454 } 6455 nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC]; 6456 if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) { 6457 err = add_control(spec, ALC_CTL_WIDGET_VOL, 6458 "Front Mic Boost", 6459 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT)); 6460 if (err < 0) 6461 return err; 6462 } 6463 return 0; 6464 } 6465 6466 /* almost identical with ALC880 parser... */ 6467 static int alc882_parse_auto_config(struct hda_codec *codec) 6468 { 6469 struct alc_spec *spec = codec->spec; 6470 int err = alc880_parse_auto_config(codec); 6471 6472 if (err < 0) 6473 return err; 6474 else if (!err) 6475 return 0; /* no config found */ 6476 6477 err = alc_auto_add_mic_boost(codec); 6478 if (err < 0) 6479 return err; 6480 6481 /* hack - override the init verbs */ 6482 spec->init_verbs[0] = alc882_auto_init_verbs; 6483 6484 return 1; /* config found */ 6485 } 6486 6487 /* additional initialization for auto-configuration model */ 6488 static void alc882_auto_init(struct hda_codec *codec) 6489 { 6490 struct alc_spec *spec = codec->spec; 6491 alc882_auto_init_multi_out(codec); 6492 alc882_auto_init_hp_out(codec); 6493 alc882_auto_init_analog_input(codec); 6494 if (spec->unsol_event) 6495 alc_sku_automute(codec); 6496 } 6497 6498 static int patch_alc883(struct hda_codec *codec); /* called in patch_alc882() */ 6499 6500 static int patch_alc882(struct hda_codec *codec) 6501 { 6502 struct alc_spec *spec; 6503 int err, board_config; 6504 6505 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 6506 if (spec == NULL) 6507 return -ENOMEM; 6508 6509 codec->spec = spec; 6510 6511 board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST, 6512 alc882_models, 6513 alc882_cfg_tbl); 6514 6515 if (board_config < 0 || board_config >= ALC882_MODEL_LAST) { 6516 /* Pick up systems that don't supply PCI SSID */ 6517 switch (codec->subsystem_id) { 6518 case 0x106b0c00: /* Mac Pro */ 6519 board_config = ALC885_MACPRO; 6520 break; 6521 case 0x106b1000: /* iMac 24 */ 6522 board_config = ALC885_IMAC24; 6523 break; 6524 case 0x106b00a1: /* Macbook (might be wrong - PCI SSID?) */ 6525 case 0x106b2c00: /* Macbook Pro rev3 */ 6526 case 0x106b3600: /* Macbook 3.1 */ 6527 board_config = ALC885_MBP3; 6528 break; 6529 default: 6530 /* ALC889A is handled better as ALC888-compatible */ 6531 if (codec->revision_id == 0x100103) { 6532 alc_free(codec); 6533 return patch_alc883(codec); 6534 } 6535 printk(KERN_INFO "hda_codec: Unknown model for ALC882, " 6536 "trying auto-probe from BIOS...\n"); 6537 board_config = ALC882_AUTO; 6538 } 6539 } 6540 6541 alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes); 6542 6543 if (board_config == ALC882_AUTO) { 6544 /* automatic parse from the BIOS config */ 6545 err = alc882_parse_auto_config(codec); 6546 if (err < 0) { 6547 alc_free(codec); 6548 return err; 6549 } else if (!err) { 6550 printk(KERN_INFO 6551 "hda_codec: Cannot set up configuration " 6552 "from BIOS. Using base mode...\n"); 6553 board_config = ALC882_3ST_DIG; 6554 } 6555 } 6556 6557 if (board_config != ALC882_AUTO) 6558 setup_preset(spec, &alc882_presets[board_config]); 6559 6560 if (codec->vendor_id == 0x10ec0885) { 6561 spec->stream_name_analog = "ALC885 Analog"; 6562 spec->stream_name_digital = "ALC885 Digital"; 6563 } else { 6564 spec->stream_name_analog = "ALC882 Analog"; 6565 spec->stream_name_digital = "ALC882 Digital"; 6566 } 6567 6568 spec->stream_analog_playback = &alc882_pcm_analog_playback; 6569 spec->stream_analog_capture = &alc882_pcm_analog_capture; 6570 /* FIXME: setup DAC5 */ 6571 /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/ 6572 spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture; 6573 6574 spec->stream_digital_playback = &alc882_pcm_digital_playback; 6575 spec->stream_digital_capture = &alc882_pcm_digital_capture; 6576 6577 if (!spec->adc_nids && spec->input_mux) { 6578 /* check whether NID 0x07 is valid */ 6579 unsigned int wcap = get_wcaps(codec, 0x07); 6580 /* get type */ 6581 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 6582 if (wcap != AC_WID_AUD_IN) { 6583 spec->adc_nids = alc882_adc_nids_alt; 6584 spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt); 6585 spec->capsrc_nids = alc882_capsrc_nids_alt; 6586 spec->mixers[spec->num_mixers] = 6587 alc882_capture_alt_mixer; 6588 spec->num_mixers++; 6589 } else { 6590 spec->adc_nids = alc882_adc_nids; 6591 spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids); 6592 spec->capsrc_nids = alc882_capsrc_nids; 6593 spec->mixers[spec->num_mixers] = alc882_capture_mixer; 6594 spec->num_mixers++; 6595 } 6596 } 6597 6598 spec->vmaster_nid = 0x0c; 6599 6600 codec->patch_ops = alc_patch_ops; 6601 if (board_config == ALC882_AUTO) 6602 spec->init_hook = alc882_auto_init; 6603 #ifdef CONFIG_SND_HDA_POWER_SAVE 6604 if (!spec->loopback.amplist) 6605 spec->loopback.amplist = alc882_loopbacks; 6606 #endif 6607 6608 return 0; 6609 } 6610 6611 /* 6612 * ALC883 support 6613 * 6614 * ALC883 is almost identical with ALC880 but has cleaner and more flexible 6615 * configuration. Each pin widget can choose any input DACs and a mixer. 6616 * Each ADC is connected from a mixer of all inputs. This makes possible 6617 * 6-channel independent captures. 6618 * 6619 * In addition, an independent DAC for the multi-playback (not used in this 6620 * driver yet). 6621 */ 6622 #define ALC883_DIGOUT_NID 0x06 6623 #define ALC883_DIGIN_NID 0x0a 6624 6625 static hda_nid_t alc883_dac_nids[4] = { 6626 /* front, rear, clfe, rear_surr */ 6627 0x02, 0x03, 0x04, 0x05 6628 }; 6629 6630 static hda_nid_t alc883_adc_nids[2] = { 6631 /* ADC1-2 */ 6632 0x08, 0x09, 6633 }; 6634 6635 static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 }; 6636 6637 /* input MUX */ 6638 /* FIXME: should be a matrix-type input source selection */ 6639 6640 static struct hda_input_mux alc883_capture_source = { 6641 .num_items = 4, 6642 .items = { 6643 { "Mic", 0x0 }, 6644 { "Front Mic", 0x1 }, 6645 { "Line", 0x2 }, 6646 { "CD", 0x4 }, 6647 }, 6648 }; 6649 6650 static struct hda_input_mux alc883_3stack_6ch_intel = { 6651 .num_items = 4, 6652 .items = { 6653 { "Mic", 0x1 }, 6654 { "Front Mic", 0x0 }, 6655 { "Line", 0x2 }, 6656 { "CD", 0x4 }, 6657 }, 6658 }; 6659 6660 static struct hda_input_mux alc883_lenovo_101e_capture_source = { 6661 .num_items = 2, 6662 .items = { 6663 { "Mic", 0x1 }, 6664 { "Line", 0x2 }, 6665 }, 6666 }; 6667 6668 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = { 6669 .num_items = 4, 6670 .items = { 6671 { "Mic", 0x0 }, 6672 { "iMic", 0x1 }, 6673 { "Line", 0x2 }, 6674 { "CD", 0x4 }, 6675 }, 6676 }; 6677 6678 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = { 6679 .num_items = 2, 6680 .items = { 6681 { "Mic", 0x0 }, 6682 { "Int Mic", 0x1 }, 6683 }, 6684 }; 6685 6686 #define alc883_mux_enum_info alc_mux_enum_info 6687 #define alc883_mux_enum_get alc_mux_enum_get 6688 /* ALC883 has the ALC882-type input selection */ 6689 #define alc883_mux_enum_put alc882_mux_enum_put 6690 6691 /* 6692 * 2ch mode 6693 */ 6694 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = { 6695 { 2, NULL } 6696 }; 6697 6698 /* 6699 * 2ch mode 6700 */ 6701 static struct hda_verb alc883_3ST_ch2_init[] = { 6702 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 6703 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 6704 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 6705 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 6706 { } /* end */ 6707 }; 6708 6709 /* 6710 * 4ch mode 6711 */ 6712 static struct hda_verb alc883_3ST_ch4_init[] = { 6713 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 6714 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 6715 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6716 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 6717 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 6718 { } /* end */ 6719 }; 6720 6721 /* 6722 * 6ch mode 6723 */ 6724 static struct hda_verb alc883_3ST_ch6_init[] = { 6725 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6726 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 6727 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 }, 6728 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6729 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 6730 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 6731 { } /* end */ 6732 }; 6733 6734 static struct hda_channel_mode alc883_3ST_6ch_modes[3] = { 6735 { 2, alc883_3ST_ch2_init }, 6736 { 4, alc883_3ST_ch4_init }, 6737 { 6, alc883_3ST_ch6_init }, 6738 }; 6739 6740 /* 6741 * 2ch mode 6742 */ 6743 static struct hda_verb alc883_3ST_ch2_intel_init[] = { 6744 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 6745 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 6746 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 6747 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 6748 { } /* end */ 6749 }; 6750 6751 /* 6752 * 4ch mode 6753 */ 6754 static struct hda_verb alc883_3ST_ch4_intel_init[] = { 6755 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 6756 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 6757 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6758 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 6759 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 6760 { } /* end */ 6761 }; 6762 6763 /* 6764 * 6ch mode 6765 */ 6766 static struct hda_verb alc883_3ST_ch6_intel_init[] = { 6767 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6768 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 6769 { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 }, 6770 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6771 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 6772 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 6773 { } /* end */ 6774 }; 6775 6776 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = { 6777 { 2, alc883_3ST_ch2_intel_init }, 6778 { 4, alc883_3ST_ch4_intel_init }, 6779 { 6, alc883_3ST_ch6_intel_init }, 6780 }; 6781 6782 /* 6783 * 6ch mode 6784 */ 6785 static struct hda_verb alc883_sixstack_ch6_init[] = { 6786 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 6787 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6788 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6789 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6790 { } /* end */ 6791 }; 6792 6793 /* 6794 * 8ch mode 6795 */ 6796 static struct hda_verb alc883_sixstack_ch8_init[] = { 6797 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6798 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6799 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6800 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6801 { } /* end */ 6802 }; 6803 6804 static struct hda_channel_mode alc883_sixstack_modes[2] = { 6805 { 6, alc883_sixstack_ch6_init }, 6806 { 8, alc883_sixstack_ch8_init }, 6807 }; 6808 6809 static struct hda_verb alc883_medion_eapd_verbs[] = { 6810 /* eanable EAPD on medion laptop */ 6811 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 6812 {0x20, AC_VERB_SET_PROC_COEF, 0x3070}, 6813 { } 6814 }; 6815 6816 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17 6817 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b 6818 */ 6819 6820 static struct snd_kcontrol_new alc883_base_mixer[] = { 6821 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 6822 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 6823 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 6824 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 6825 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 6826 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 6827 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 6828 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 6829 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 6830 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 6831 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 6832 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 6833 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 6834 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 6835 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 6836 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 6837 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 6838 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 6839 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 6840 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 6841 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 6842 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 6843 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 6844 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 6845 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 6846 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 6847 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 6848 { 6849 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6850 /* .name = "Capture Source", */ 6851 .name = "Input Source", 6852 .count = 2, 6853 .info = alc883_mux_enum_info, 6854 .get = alc883_mux_enum_get, 6855 .put = alc883_mux_enum_put, 6856 }, 6857 { } /* end */ 6858 }; 6859 6860 static struct snd_kcontrol_new alc883_mitac_mixer[] = { 6861 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 6862 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 6863 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 6864 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 6865 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 6866 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 6867 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 6868 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 6869 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 6870 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 6871 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 6872 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 6873 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 6874 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 6875 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 6876 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 6877 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 6878 { 6879 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6880 /* .name = "Capture Source", */ 6881 .name = "Input Source", 6882 .count = 2, 6883 .info = alc883_mux_enum_info, 6884 .get = alc883_mux_enum_get, 6885 .put = alc883_mux_enum_put, 6886 }, 6887 { } /* end */ 6888 }; 6889 6890 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = { 6891 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 6892 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 6893 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 6894 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 6895 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 6896 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 6897 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 6898 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 6899 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 6900 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 6901 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 6902 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 6903 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 6904 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 6905 { 6906 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6907 /* .name = "Capture Source", */ 6908 .name = "Input Source", 6909 .count = 2, 6910 .info = alc883_mux_enum_info, 6911 .get = alc883_mux_enum_get, 6912 .put = alc883_mux_enum_put, 6913 }, 6914 { } /* end */ 6915 }; 6916 6917 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = { 6918 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 6919 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 6920 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 6921 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 6922 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 6923 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 6924 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 6925 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 6926 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 6927 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 6928 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 6929 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 6930 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 6931 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 6932 { 6933 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6934 /* .name = "Capture Source", */ 6935 .name = "Input Source", 6936 .count = 2, 6937 .info = alc883_mux_enum_info, 6938 .get = alc883_mux_enum_get, 6939 .put = alc883_mux_enum_put, 6940 }, 6941 { } /* end */ 6942 }; 6943 6944 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = { 6945 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 6946 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 6947 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 6948 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 6949 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 6950 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 6951 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 6952 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 6953 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 6954 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 6955 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 6956 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 6957 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 6958 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 6959 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 6960 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 6961 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 6962 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 6963 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 6964 { 6965 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6966 /* .name = "Capture Source", */ 6967 .name = "Input Source", 6968 .count = 2, 6969 .info = alc883_mux_enum_info, 6970 .get = alc883_mux_enum_get, 6971 .put = alc883_mux_enum_put, 6972 }, 6973 { } /* end */ 6974 }; 6975 6976 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = { 6977 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 6978 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 6979 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 6980 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 6981 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 6982 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 6983 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 6984 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 6985 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 6986 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 6987 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 6988 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 6989 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 6990 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 6991 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 6992 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 6993 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 6994 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 6995 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 6996 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 6997 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 6998 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 6999 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7000 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 7001 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 7002 { 7003 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7004 /* .name = "Capture Source", */ 7005 .name = "Input Source", 7006 .count = 2, 7007 .info = alc883_mux_enum_info, 7008 .get = alc883_mux_enum_get, 7009 .put = alc883_mux_enum_put, 7010 }, 7011 { } /* end */ 7012 }; 7013 7014 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = { 7015 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7016 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7017 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7018 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 7019 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, 7020 HDA_OUTPUT), 7021 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 7022 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 7023 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 7024 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 7025 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7026 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7027 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7028 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7029 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7030 HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT), 7031 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7032 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7033 HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT), 7034 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7035 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 7036 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 7037 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7038 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7039 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 7040 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 7041 { 7042 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7043 /* .name = "Capture Source", */ 7044 .name = "Input Source", 7045 .count = 2, 7046 .info = alc883_mux_enum_info, 7047 .get = alc883_mux_enum_get, 7048 .put = alc883_mux_enum_put, 7049 }, 7050 { } /* end */ 7051 }; 7052 7053 static struct snd_kcontrol_new alc883_fivestack_mixer[] = { 7054 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7055 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7056 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7057 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 7058 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 7059 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 7060 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 7061 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 7062 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7063 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7064 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7065 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7066 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7067 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7068 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7069 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7070 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7071 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 7072 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7073 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 7074 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 7075 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7076 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7077 7078 { 7079 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7080 /* .name = "Capture Source", */ 7081 .name = "Input Source", 7082 .count = 1, 7083 .info = alc883_mux_enum_info, 7084 .get = alc883_mux_enum_get, 7085 .put = alc883_mux_enum_put, 7086 }, 7087 { } /* end */ 7088 }; 7089 7090 static struct snd_kcontrol_new alc883_tagra_mixer[] = { 7091 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7092 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 7093 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7094 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7095 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 7096 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 7097 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 7098 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 7099 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 7100 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7101 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7102 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7103 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7104 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7105 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7106 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7107 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7108 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7109 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 7110 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 7111 { 7112 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7113 /* .name = "Capture Source", */ 7114 .name = "Input Source", 7115 .count = 2, 7116 .info = alc883_mux_enum_info, 7117 .get = alc883_mux_enum_get, 7118 .put = alc883_mux_enum_put, 7119 }, 7120 { } /* end */ 7121 }; 7122 7123 static struct snd_kcontrol_new alc883_tagra_2ch_mixer[] = { 7124 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7125 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 7126 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7127 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7128 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7129 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7130 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7131 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7132 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7133 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 7134 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7135 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7136 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7137 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 7138 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 7139 { 7140 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7141 /* .name = "Capture Source", */ 7142 .name = "Input Source", 7143 .count = 2, 7144 .info = alc883_mux_enum_info, 7145 .get = alc883_mux_enum_get, 7146 .put = alc883_mux_enum_put, 7147 }, 7148 { } /* end */ 7149 }; 7150 7151 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = { 7152 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7153 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7154 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7155 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 7156 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7157 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7158 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7159 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7160 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7161 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7162 { 7163 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7164 /* .name = "Capture Source", */ 7165 .name = "Input Source", 7166 .count = 1, 7167 .info = alc883_mux_enum_info, 7168 .get = alc883_mux_enum_get, 7169 .put = alc883_mux_enum_put, 7170 }, 7171 { } /* end */ 7172 }; 7173 7174 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = { 7175 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7176 HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT), 7177 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 7178 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7179 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7180 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7181 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7182 HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7183 HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7184 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7185 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7186 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 7187 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 7188 { 7189 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7190 /* .name = "Capture Source", */ 7191 .name = "Input Source", 7192 .count = 2, 7193 .info = alc883_mux_enum_info, 7194 .get = alc883_mux_enum_get, 7195 .put = alc883_mux_enum_put, 7196 }, 7197 { } /* end */ 7198 }; 7199 7200 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = { 7201 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7202 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 7203 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT), 7204 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7205 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7206 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7207 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7208 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7209 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7210 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7211 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7212 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 7213 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 7214 { 7215 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7216 /* .name = "Capture Source", */ 7217 .name = "Input Source", 7218 .count = 2, 7219 .info = alc883_mux_enum_info, 7220 .get = alc883_mux_enum_get, 7221 .put = alc883_mux_enum_put, 7222 }, 7223 { } /* end */ 7224 }; 7225 7226 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = { 7227 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7228 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7229 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 7230 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7231 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7232 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7233 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7234 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7235 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7236 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7237 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 7238 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 7239 { 7240 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7241 /* .name = "Capture Source", */ 7242 .name = "Input Source", 7243 .count = 2, 7244 .info = alc883_mux_enum_info, 7245 .get = alc883_mux_enum_get, 7246 .put = alc883_mux_enum_put, 7247 }, 7248 { } /* end */ 7249 }; 7250 7251 static struct snd_kcontrol_new alc883_chmode_mixer[] = { 7252 { 7253 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7254 .name = "Channel Mode", 7255 .info = alc_ch_mode_info, 7256 .get = alc_ch_mode_get, 7257 .put = alc_ch_mode_put, 7258 }, 7259 { } /* end */ 7260 }; 7261 7262 static struct hda_verb alc883_init_verbs[] = { 7263 /* ADC1: mute amp left and right */ 7264 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7265 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 7266 /* ADC2: mute amp left and right */ 7267 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7268 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 7269 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 7270 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7271 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7272 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7273 /* Rear mixer */ 7274 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7275 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7276 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7277 /* CLFE mixer */ 7278 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7279 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7280 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7281 /* Side mixer */ 7282 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7283 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7284 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7285 7286 /* mute analog input loopbacks */ 7287 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7288 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7289 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 7290 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 7291 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 7292 7293 /* Front Pin: output 0 (0x0c) */ 7294 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7295 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7296 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 7297 /* Rear Pin: output 1 (0x0d) */ 7298 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7299 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7300 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 7301 /* CLFE Pin: output 2 (0x0e) */ 7302 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7303 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7304 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02}, 7305 /* Side Pin: output 3 (0x0f) */ 7306 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7307 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7308 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 7309 /* Mic (rear) pin: input vref at 80% */ 7310 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 7311 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 7312 /* Front Mic pin: input vref at 80% */ 7313 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 7314 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 7315 /* Line In pin: input */ 7316 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 7317 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 7318 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 7319 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7320 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7321 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 7322 /* CD pin widget for input */ 7323 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 7324 7325 /* FIXME: use matrix-type input source selection */ 7326 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 7327 /* Input mixer2 */ 7328 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7329 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7330 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 7331 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 7332 /* Input mixer3 */ 7333 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7334 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7335 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 7336 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 7337 { } 7338 }; 7339 7340 /* toggle speaker-output according to the hp-jack state */ 7341 static void alc883_mitac_hp_automute(struct hda_codec *codec) 7342 { 7343 unsigned int present; 7344 7345 present = snd_hda_codec_read(codec, 0x15, 0, 7346 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7347 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 7348 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7349 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0, 7350 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7351 } 7352 7353 /* auto-toggle front mic */ 7354 /* 7355 static void alc883_mitac_mic_automute(struct hda_codec *codec) 7356 { 7357 unsigned int present; 7358 unsigned char bits; 7359 7360 present = snd_hda_codec_read(codec, 0x18, 0, 7361 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7362 bits = present ? HDA_AMP_MUTE : 0; 7363 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits); 7364 } 7365 */ 7366 7367 static void alc883_mitac_automute(struct hda_codec *codec) 7368 { 7369 alc883_mitac_hp_automute(codec); 7370 /* alc883_mitac_mic_automute(codec); */ 7371 } 7372 7373 static void alc883_mitac_unsol_event(struct hda_codec *codec, 7374 unsigned int res) 7375 { 7376 switch (res >> 26) { 7377 case ALC880_HP_EVENT: 7378 alc883_mitac_hp_automute(codec); 7379 break; 7380 case ALC880_MIC_EVENT: 7381 /* alc883_mitac_mic_automute(codec); */ 7382 break; 7383 } 7384 } 7385 7386 static struct hda_verb alc883_mitac_verbs[] = { 7387 /* HP */ 7388 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 7389 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7390 /* Subwoofer */ 7391 {0x17, AC_VERB_SET_CONNECT_SEL, 0x02}, 7392 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7393 7394 /* enable unsolicited event */ 7395 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7396 /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */ 7397 7398 { } /* end */ 7399 }; 7400 7401 static struct hda_verb alc883_clevo_m720_verbs[] = { 7402 /* HP */ 7403 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 7404 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7405 /* Int speaker */ 7406 {0x14, AC_VERB_SET_CONNECT_SEL, 0x01}, 7407 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7408 7409 /* enable unsolicited event */ 7410 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7411 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, 7412 7413 { } /* end */ 7414 }; 7415 7416 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = { 7417 /* HP */ 7418 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 7419 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7420 /* Subwoofer */ 7421 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 7422 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7423 7424 /* enable unsolicited event */ 7425 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7426 7427 { } /* end */ 7428 }; 7429 7430 static struct hda_verb alc883_tagra_verbs[] = { 7431 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7432 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7433 7434 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7435 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7436 7437 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 7438 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */ 7439 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 7440 7441 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7442 {0x01, AC_VERB_SET_GPIO_MASK, 0x03}, 7443 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03}, 7444 {0x01, AC_VERB_SET_GPIO_DATA, 0x03}, 7445 7446 { } /* end */ 7447 }; 7448 7449 static struct hda_verb alc883_lenovo_101e_verbs[] = { 7450 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 7451 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN}, 7452 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN}, 7453 { } /* end */ 7454 }; 7455 7456 static struct hda_verb alc883_lenovo_nb0763_verbs[] = { 7457 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 7458 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7459 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7460 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7461 { } /* end */ 7462 }; 7463 7464 static struct hda_verb alc888_lenovo_ms7195_verbs[] = { 7465 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7466 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7467 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 7468 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN}, 7469 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7470 { } /* end */ 7471 }; 7472 7473 static struct hda_verb alc883_haier_w66_verbs[] = { 7474 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7475 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7476 7477 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7478 7479 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 7480 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7481 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7482 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7483 { } /* end */ 7484 }; 7485 7486 static struct hda_verb alc888_3st_hp_verbs[] = { 7487 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front: output 0 (0x0c) */ 7488 {0x16, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Rear : output 1 (0x0d) */ 7489 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* CLFE : output 2 (0x0e) */ 7490 { } 7491 }; 7492 7493 static struct hda_verb alc888_6st_dell_verbs[] = { 7494 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7495 { } 7496 }; 7497 7498 static struct hda_verb alc888_3st_hp_2ch_init[] = { 7499 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 7500 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7501 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 7502 { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7503 { } 7504 }; 7505 7506 static struct hda_verb alc888_3st_hp_6ch_init[] = { 7507 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7508 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7509 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7510 { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7511 { } 7512 }; 7513 7514 static struct hda_channel_mode alc888_3st_hp_modes[2] = { 7515 { 2, alc888_3st_hp_2ch_init }, 7516 { 6, alc888_3st_hp_6ch_init }, 7517 }; 7518 7519 /* toggle front-jack and RCA according to the hp-jack state */ 7520 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec) 7521 { 7522 unsigned int present; 7523 7524 present = snd_hda_codec_read(codec, 0x1b, 0, 7525 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7526 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 7527 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7528 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 7529 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7530 } 7531 7532 /* toggle RCA according to the front-jack state */ 7533 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec) 7534 { 7535 unsigned int present; 7536 7537 present = snd_hda_codec_read(codec, 0x14, 0, 7538 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7539 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 7540 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7541 } 7542 7543 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec, 7544 unsigned int res) 7545 { 7546 if ((res >> 26) == ALC880_HP_EVENT) 7547 alc888_lenovo_ms7195_front_automute(codec); 7548 if ((res >> 26) == ALC880_FRONT_EVENT) 7549 alc888_lenovo_ms7195_rca_automute(codec); 7550 } 7551 7552 static struct hda_verb alc883_medion_md2_verbs[] = { 7553 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7554 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7555 7556 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7557 7558 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7559 { } /* end */ 7560 }; 7561 7562 /* toggle speaker-output according to the hp-jack state */ 7563 static void alc883_medion_md2_automute(struct hda_codec *codec) 7564 { 7565 unsigned int present; 7566 7567 present = snd_hda_codec_read(codec, 0x14, 0, 7568 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7569 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 7570 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7571 } 7572 7573 static void alc883_medion_md2_unsol_event(struct hda_codec *codec, 7574 unsigned int res) 7575 { 7576 if ((res >> 26) == ALC880_HP_EVENT) 7577 alc883_medion_md2_automute(codec); 7578 } 7579 7580 /* toggle speaker-output according to the hp-jack state */ 7581 static void alc883_tagra_automute(struct hda_codec *codec) 7582 { 7583 unsigned int present; 7584 unsigned char bits; 7585 7586 present = snd_hda_codec_read(codec, 0x14, 0, 7587 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7588 bits = present ? HDA_AMP_MUTE : 0; 7589 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 7590 HDA_AMP_MUTE, bits); 7591 snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA, 7592 present ? 1 : 3); 7593 } 7594 7595 static void alc883_tagra_unsol_event(struct hda_codec *codec, unsigned int res) 7596 { 7597 if ((res >> 26) == ALC880_HP_EVENT) 7598 alc883_tagra_automute(codec); 7599 } 7600 7601 /* toggle speaker-output according to the hp-jack state */ 7602 static void alc883_clevo_m720_hp_automute(struct hda_codec *codec) 7603 { 7604 unsigned int present; 7605 unsigned char bits; 7606 7607 present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0) 7608 & AC_PINSENSE_PRESENCE; 7609 bits = present ? HDA_AMP_MUTE : 0; 7610 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 7611 HDA_AMP_MUTE, bits); 7612 } 7613 7614 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec) 7615 { 7616 unsigned int present; 7617 7618 present = snd_hda_codec_read(codec, 0x18, 0, 7619 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7620 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, 7621 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7622 } 7623 7624 static void alc883_clevo_m720_automute(struct hda_codec *codec) 7625 { 7626 alc883_clevo_m720_hp_automute(codec); 7627 alc883_clevo_m720_mic_automute(codec); 7628 } 7629 7630 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec, 7631 unsigned int res) 7632 { 7633 switch (res >> 26) { 7634 case ALC880_HP_EVENT: 7635 alc883_clevo_m720_hp_automute(codec); 7636 break; 7637 case ALC880_MIC_EVENT: 7638 alc883_clevo_m720_mic_automute(codec); 7639 break; 7640 } 7641 } 7642 7643 /* toggle speaker-output according to the hp-jack state */ 7644 static void alc883_2ch_fujitsu_pi2515_automute(struct hda_codec *codec) 7645 { 7646 unsigned int present; 7647 unsigned char bits; 7648 7649 present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0) 7650 & AC_PINSENSE_PRESENCE; 7651 bits = present ? HDA_AMP_MUTE : 0; 7652 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 7653 HDA_AMP_MUTE, bits); 7654 } 7655 7656 static void alc883_2ch_fujitsu_pi2515_unsol_event(struct hda_codec *codec, 7657 unsigned int res) 7658 { 7659 if ((res >> 26) == ALC880_HP_EVENT) 7660 alc883_2ch_fujitsu_pi2515_automute(codec); 7661 } 7662 7663 static void alc883_haier_w66_automute(struct hda_codec *codec) 7664 { 7665 unsigned int present; 7666 unsigned char bits; 7667 7668 present = snd_hda_codec_read(codec, 0x1b, 0, 7669 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7670 bits = present ? 0x80 : 0; 7671 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 7672 0x80, bits); 7673 } 7674 7675 static void alc883_haier_w66_unsol_event(struct hda_codec *codec, 7676 unsigned int res) 7677 { 7678 if ((res >> 26) == ALC880_HP_EVENT) 7679 alc883_haier_w66_automute(codec); 7680 } 7681 7682 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec) 7683 { 7684 unsigned int present; 7685 unsigned char bits; 7686 7687 present = snd_hda_codec_read(codec, 0x14, 0, 7688 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7689 bits = present ? HDA_AMP_MUTE : 0; 7690 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 7691 HDA_AMP_MUTE, bits); 7692 } 7693 7694 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec) 7695 { 7696 unsigned int present; 7697 unsigned char bits; 7698 7699 present = snd_hda_codec_read(codec, 0x1b, 0, 7700 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7701 bits = present ? HDA_AMP_MUTE : 0; 7702 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 7703 HDA_AMP_MUTE, bits); 7704 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 7705 HDA_AMP_MUTE, bits); 7706 } 7707 7708 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec, 7709 unsigned int res) 7710 { 7711 if ((res >> 26) == ALC880_HP_EVENT) 7712 alc883_lenovo_101e_all_automute(codec); 7713 if ((res >> 26) == ALC880_FRONT_EVENT) 7714 alc883_lenovo_101e_ispeaker_automute(codec); 7715 } 7716 7717 /* toggle speaker-output according to the hp-jack state */ 7718 static void alc883_acer_aspire_automute(struct hda_codec *codec) 7719 { 7720 unsigned int present; 7721 7722 present = snd_hda_codec_read(codec, 0x14, 0, 7723 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7724 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 7725 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7726 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 7727 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7728 } 7729 7730 static void alc883_acer_aspire_unsol_event(struct hda_codec *codec, 7731 unsigned int res) 7732 { 7733 if ((res >> 26) == ALC880_HP_EVENT) 7734 alc883_acer_aspire_automute(codec); 7735 } 7736 7737 static struct hda_verb alc883_acer_eapd_verbs[] = { 7738 /* HP Pin: output 0 (0x0c) */ 7739 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7740 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7741 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 7742 /* Front Pin: output 0 (0x0c) */ 7743 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7744 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 7745 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7746 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, 7747 /* eanable EAPD on medion laptop */ 7748 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 7749 {0x20, AC_VERB_SET_PROC_COEF, 0x3050}, 7750 /* enable unsolicited event */ 7751 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7752 { } 7753 }; 7754 7755 static void alc888_6st_dell_front_automute(struct hda_codec *codec) 7756 { 7757 unsigned int present; 7758 7759 present = snd_hda_codec_read(codec, 0x1b, 0, 7760 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7761 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 7762 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7763 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 7764 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7765 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 7766 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7767 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0, 7768 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7769 } 7770 7771 static void alc888_6st_dell_unsol_event(struct hda_codec *codec, 7772 unsigned int res) 7773 { 7774 switch (res >> 26) { 7775 case ALC880_HP_EVENT: 7776 printk("hp_event\n"); 7777 alc888_6st_dell_front_automute(codec); 7778 break; 7779 } 7780 } 7781 7782 /* 7783 * generic initialization of ADC, input mixers and output mixers 7784 */ 7785 static struct hda_verb alc883_auto_init_verbs[] = { 7786 /* 7787 * Unmute ADC0-2 and set the default input to mic-in 7788 */ 7789 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 7790 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7791 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 7792 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7793 7794 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 7795 * mixer widget 7796 * Note: PASD motherboards uses the Line In 2 as the input for 7797 * front panel mic (mic 2) 7798 */ 7799 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 7800 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7801 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7802 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 7803 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 7804 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 7805 7806 /* 7807 * Set up output mixers (0x0c - 0x0f) 7808 */ 7809 /* set vol=0 to output mixers */ 7810 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7811 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7812 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7813 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7814 /* set up input amps for analog loopback */ 7815 /* Amp Indices: DAC = 0, mixer = 1 */ 7816 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7817 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7818 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7819 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7820 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7821 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7822 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7823 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7824 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7825 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7826 7827 /* FIXME: use matrix-type input source selection */ 7828 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 7829 /* Input mixer1 */ 7830 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7831 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7832 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 7833 /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */ 7834 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 7835 /* Input mixer2 */ 7836 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7837 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7838 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 7839 /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */ 7840 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 7841 7842 { } 7843 }; 7844 7845 /* capture mixer elements */ 7846 static struct snd_kcontrol_new alc883_capture_mixer[] = { 7847 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7848 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7849 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 7850 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 7851 { 7852 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7853 /* The multiple "Capture Source" controls confuse alsamixer 7854 * So call somewhat different.. 7855 */ 7856 /* .name = "Capture Source", */ 7857 .name = "Input Source", 7858 .count = 2, 7859 .info = alc882_mux_enum_info, 7860 .get = alc882_mux_enum_get, 7861 .put = alc882_mux_enum_put, 7862 }, 7863 { } /* end */ 7864 }; 7865 7866 #ifdef CONFIG_SND_HDA_POWER_SAVE 7867 #define alc883_loopbacks alc880_loopbacks 7868 #endif 7869 7870 /* pcm configuration: identiacal with ALC880 */ 7871 #define alc883_pcm_analog_playback alc880_pcm_analog_playback 7872 #define alc883_pcm_analog_capture alc880_pcm_analog_capture 7873 #define alc883_pcm_analog_alt_capture alc880_pcm_analog_alt_capture 7874 #define alc883_pcm_digital_playback alc880_pcm_digital_playback 7875 #define alc883_pcm_digital_capture alc880_pcm_digital_capture 7876 7877 /* 7878 * configuration and preset 7879 */ 7880 static const char *alc883_models[ALC883_MODEL_LAST] = { 7881 [ALC883_3ST_2ch_DIG] = "3stack-dig", 7882 [ALC883_3ST_6ch_DIG] = "3stack-6ch-dig", 7883 [ALC883_3ST_6ch] = "3stack-6ch", 7884 [ALC883_6ST_DIG] = "6stack-dig", 7885 [ALC883_TARGA_DIG] = "targa-dig", 7886 [ALC883_TARGA_2ch_DIG] = "targa-2ch-dig", 7887 [ALC883_ACER] = "acer", 7888 [ALC883_ACER_ASPIRE] = "acer-aspire", 7889 [ALC883_MEDION] = "medion", 7890 [ALC883_MEDION_MD2] = "medion-md2", 7891 [ALC883_LAPTOP_EAPD] = "laptop-eapd", 7892 [ALC883_LENOVO_101E_2ch] = "lenovo-101e", 7893 [ALC883_LENOVO_NB0763] = "lenovo-nb0763", 7894 [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig", 7895 [ALC883_HAIER_W66] = "haier-w66", 7896 [ALC888_3ST_HP] = "3stack-hp", 7897 [ALC888_6ST_DELL] = "6stack-dell", 7898 [ALC883_MITAC] = "mitac", 7899 [ALC883_CLEVO_M720] = "clevo-m720", 7900 [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515", 7901 [ALC883_3ST_6ch_INTEL] = "3stack-6ch-intel", 7902 [ALC883_AUTO] = "auto", 7903 }; 7904 7905 static struct snd_pci_quirk alc883_cfg_tbl[] = { 7906 SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG), 7907 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE), 7908 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE), 7909 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE), 7910 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE), 7911 SND_PCI_QUIRK(0x1025, 0, "Acer laptop", ALC883_ACER), /* default Acer */ 7912 SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL), 7913 SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG), 7914 SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP), 7915 SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP), 7916 SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG), 7917 SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG), 7918 SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG), 7919 SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG), 7920 SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC), 7921 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD), 7922 SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch), 7923 SND_PCI_QUIRK(0x1458, 0xa002, "MSI", ALC883_6ST_DIG), 7924 SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG), 7925 SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG), 7926 SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG), 7927 SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG), 7928 SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG), 7929 SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG), 7930 SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG), 7931 SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG), 7932 SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG), 7933 SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG), 7934 SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG), 7935 SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG), 7936 SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG), 7937 SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG), 7938 SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG), 7939 SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG), 7940 SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG), 7941 SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG), 7942 SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG), 7943 SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG), 7944 SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG), 7945 SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG), 7946 SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG), 7947 SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720), 7948 SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720), 7949 SND_PCI_QUIRK(0x1558, 0, "Clevo laptop", ALC883_LAPTOP_EAPD), 7950 SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch), 7951 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION), 7952 SND_PCI_QUIRK(0x1734, 0x1108, "Fujitsu AMILO Pi2515", ALC883_FUJITSU_PI2515), 7953 SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch), 7954 SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763), 7955 SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763), 7956 SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763), 7957 SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2), 7958 SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG), 7959 SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66), 7960 SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL), 7961 SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL), 7962 SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch), 7963 {} 7964 }; 7965 7966 static struct alc_config_preset alc883_presets[] = { 7967 [ALC883_3ST_2ch_DIG] = { 7968 .mixers = { alc883_3ST_2ch_mixer }, 7969 .init_verbs = { alc883_init_verbs }, 7970 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 7971 .dac_nids = alc883_dac_nids, 7972 .dig_out_nid = ALC883_DIGOUT_NID, 7973 .dig_in_nid = ALC883_DIGIN_NID, 7974 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 7975 .channel_mode = alc883_3ST_2ch_modes, 7976 .input_mux = &alc883_capture_source, 7977 }, 7978 [ALC883_3ST_6ch_DIG] = { 7979 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 7980 .init_verbs = { alc883_init_verbs }, 7981 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 7982 .dac_nids = alc883_dac_nids, 7983 .dig_out_nid = ALC883_DIGOUT_NID, 7984 .dig_in_nid = ALC883_DIGIN_NID, 7985 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 7986 .channel_mode = alc883_3ST_6ch_modes, 7987 .need_dac_fix = 1, 7988 .input_mux = &alc883_capture_source, 7989 }, 7990 [ALC883_3ST_6ch] = { 7991 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 7992 .init_verbs = { alc883_init_verbs }, 7993 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 7994 .dac_nids = alc883_dac_nids, 7995 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 7996 .channel_mode = alc883_3ST_6ch_modes, 7997 .need_dac_fix = 1, 7998 .input_mux = &alc883_capture_source, 7999 }, 8000 [ALC883_3ST_6ch_INTEL] = { 8001 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer }, 8002 .init_verbs = { alc883_init_verbs }, 8003 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8004 .dac_nids = alc883_dac_nids, 8005 .dig_out_nid = ALC883_DIGOUT_NID, 8006 .dig_in_nid = ALC883_DIGIN_NID, 8007 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes), 8008 .channel_mode = alc883_3ST_6ch_intel_modes, 8009 .need_dac_fix = 1, 8010 .input_mux = &alc883_3stack_6ch_intel, 8011 }, 8012 [ALC883_6ST_DIG] = { 8013 .mixers = { alc883_base_mixer, alc883_chmode_mixer }, 8014 .init_verbs = { alc883_init_verbs }, 8015 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8016 .dac_nids = alc883_dac_nids, 8017 .dig_out_nid = ALC883_DIGOUT_NID, 8018 .dig_in_nid = ALC883_DIGIN_NID, 8019 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes), 8020 .channel_mode = alc883_sixstack_modes, 8021 .input_mux = &alc883_capture_source, 8022 }, 8023 [ALC883_TARGA_DIG] = { 8024 .mixers = { alc883_tagra_mixer, alc883_chmode_mixer }, 8025 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs}, 8026 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8027 .dac_nids = alc883_dac_nids, 8028 .dig_out_nid = ALC883_DIGOUT_NID, 8029 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 8030 .channel_mode = alc883_3ST_6ch_modes, 8031 .need_dac_fix = 1, 8032 .input_mux = &alc883_capture_source, 8033 .unsol_event = alc883_tagra_unsol_event, 8034 .init_hook = alc883_tagra_automute, 8035 }, 8036 [ALC883_TARGA_2ch_DIG] = { 8037 .mixers = { alc883_tagra_2ch_mixer}, 8038 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs}, 8039 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8040 .dac_nids = alc883_dac_nids, 8041 .dig_out_nid = ALC883_DIGOUT_NID, 8042 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8043 .channel_mode = alc883_3ST_2ch_modes, 8044 .input_mux = &alc883_capture_source, 8045 .unsol_event = alc883_tagra_unsol_event, 8046 .init_hook = alc883_tagra_automute, 8047 }, 8048 [ALC883_ACER] = { 8049 .mixers = { alc883_base_mixer }, 8050 /* On TravelMate laptops, GPIO 0 enables the internal speaker 8051 * and the headphone jack. Turn this on and rely on the 8052 * standard mute methods whenever the user wants to turn 8053 * these outputs off. 8054 */ 8055 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs }, 8056 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8057 .dac_nids = alc883_dac_nids, 8058 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8059 .channel_mode = alc883_3ST_2ch_modes, 8060 .input_mux = &alc883_capture_source, 8061 }, 8062 [ALC883_ACER_ASPIRE] = { 8063 .mixers = { alc883_acer_aspire_mixer }, 8064 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs }, 8065 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8066 .dac_nids = alc883_dac_nids, 8067 .dig_out_nid = ALC883_DIGOUT_NID, 8068 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8069 .channel_mode = alc883_3ST_2ch_modes, 8070 .input_mux = &alc883_capture_source, 8071 .unsol_event = alc883_acer_aspire_unsol_event, 8072 .init_hook = alc883_acer_aspire_automute, 8073 }, 8074 [ALC883_MEDION] = { 8075 .mixers = { alc883_fivestack_mixer, 8076 alc883_chmode_mixer }, 8077 .init_verbs = { alc883_init_verbs, 8078 alc883_medion_eapd_verbs }, 8079 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8080 .dac_nids = alc883_dac_nids, 8081 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes), 8082 .channel_mode = alc883_sixstack_modes, 8083 .input_mux = &alc883_capture_source, 8084 }, 8085 [ALC883_MEDION_MD2] = { 8086 .mixers = { alc883_medion_md2_mixer}, 8087 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs}, 8088 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8089 .dac_nids = alc883_dac_nids, 8090 .dig_out_nid = ALC883_DIGOUT_NID, 8091 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8092 .channel_mode = alc883_3ST_2ch_modes, 8093 .input_mux = &alc883_capture_source, 8094 .unsol_event = alc883_medion_md2_unsol_event, 8095 .init_hook = alc883_medion_md2_automute, 8096 }, 8097 [ALC883_LAPTOP_EAPD] = { 8098 .mixers = { alc883_base_mixer }, 8099 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs }, 8100 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8101 .dac_nids = alc883_dac_nids, 8102 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8103 .channel_mode = alc883_3ST_2ch_modes, 8104 .input_mux = &alc883_capture_source, 8105 }, 8106 [ALC883_CLEVO_M720] = { 8107 .mixers = { alc883_clevo_m720_mixer }, 8108 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs }, 8109 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8110 .dac_nids = alc883_dac_nids, 8111 .dig_out_nid = ALC883_DIGOUT_NID, 8112 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8113 .channel_mode = alc883_3ST_2ch_modes, 8114 .input_mux = &alc883_capture_source, 8115 .unsol_event = alc883_clevo_m720_unsol_event, 8116 .init_hook = alc883_clevo_m720_automute, 8117 }, 8118 [ALC883_LENOVO_101E_2ch] = { 8119 .mixers = { alc883_lenovo_101e_2ch_mixer}, 8120 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs}, 8121 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8122 .dac_nids = alc883_dac_nids, 8123 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8124 .channel_mode = alc883_3ST_2ch_modes, 8125 .input_mux = &alc883_lenovo_101e_capture_source, 8126 .unsol_event = alc883_lenovo_101e_unsol_event, 8127 .init_hook = alc883_lenovo_101e_all_automute, 8128 }, 8129 [ALC883_LENOVO_NB0763] = { 8130 .mixers = { alc883_lenovo_nb0763_mixer }, 8131 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs}, 8132 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8133 .dac_nids = alc883_dac_nids, 8134 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8135 .channel_mode = alc883_3ST_2ch_modes, 8136 .need_dac_fix = 1, 8137 .input_mux = &alc883_lenovo_nb0763_capture_source, 8138 .unsol_event = alc883_medion_md2_unsol_event, 8139 .init_hook = alc883_medion_md2_automute, 8140 }, 8141 [ALC888_LENOVO_MS7195_DIG] = { 8142 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 8143 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs}, 8144 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8145 .dac_nids = alc883_dac_nids, 8146 .dig_out_nid = ALC883_DIGOUT_NID, 8147 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 8148 .channel_mode = alc883_3ST_6ch_modes, 8149 .need_dac_fix = 1, 8150 .input_mux = &alc883_capture_source, 8151 .unsol_event = alc883_lenovo_ms7195_unsol_event, 8152 .init_hook = alc888_lenovo_ms7195_front_automute, 8153 }, 8154 [ALC883_HAIER_W66] = { 8155 .mixers = { alc883_tagra_2ch_mixer}, 8156 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs}, 8157 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8158 .dac_nids = alc883_dac_nids, 8159 .dig_out_nid = ALC883_DIGOUT_NID, 8160 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8161 .channel_mode = alc883_3ST_2ch_modes, 8162 .input_mux = &alc883_capture_source, 8163 .unsol_event = alc883_haier_w66_unsol_event, 8164 .init_hook = alc883_haier_w66_automute, 8165 }, 8166 [ALC888_3ST_HP] = { 8167 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 8168 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs }, 8169 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8170 .dac_nids = alc883_dac_nids, 8171 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes), 8172 .channel_mode = alc888_3st_hp_modes, 8173 .need_dac_fix = 1, 8174 .input_mux = &alc883_capture_source, 8175 }, 8176 [ALC888_6ST_DELL] = { 8177 .mixers = { alc883_base_mixer, alc883_chmode_mixer }, 8178 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs }, 8179 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8180 .dac_nids = alc883_dac_nids, 8181 .dig_out_nid = ALC883_DIGOUT_NID, 8182 .dig_in_nid = ALC883_DIGIN_NID, 8183 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes), 8184 .channel_mode = alc883_sixstack_modes, 8185 .input_mux = &alc883_capture_source, 8186 .unsol_event = alc888_6st_dell_unsol_event, 8187 .init_hook = alc888_6st_dell_front_automute, 8188 }, 8189 [ALC883_MITAC] = { 8190 .mixers = { alc883_mitac_mixer }, 8191 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs }, 8192 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8193 .dac_nids = alc883_dac_nids, 8194 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8195 .channel_mode = alc883_3ST_2ch_modes, 8196 .input_mux = &alc883_capture_source, 8197 .unsol_event = alc883_mitac_unsol_event, 8198 .init_hook = alc883_mitac_automute, 8199 }, 8200 [ALC883_FUJITSU_PI2515] = { 8201 .mixers = { alc883_2ch_fujitsu_pi2515_mixer }, 8202 .init_verbs = { alc883_init_verbs, 8203 alc883_2ch_fujitsu_pi2515_verbs}, 8204 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8205 .dac_nids = alc883_dac_nids, 8206 .dig_out_nid = ALC883_DIGOUT_NID, 8207 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8208 .channel_mode = alc883_3ST_2ch_modes, 8209 .input_mux = &alc883_fujitsu_pi2515_capture_source, 8210 .unsol_event = alc883_2ch_fujitsu_pi2515_unsol_event, 8211 .init_hook = alc883_2ch_fujitsu_pi2515_automute, 8212 }, 8213 }; 8214 8215 8216 /* 8217 * BIOS auto configuration 8218 */ 8219 static void alc883_auto_set_output_and_unmute(struct hda_codec *codec, 8220 hda_nid_t nid, int pin_type, 8221 int dac_idx) 8222 { 8223 /* set as output */ 8224 struct alc_spec *spec = codec->spec; 8225 int idx; 8226 8227 alc_set_pin_output(codec, nid, pin_type); 8228 if (spec->multiout.dac_nids[dac_idx] == 0x25) 8229 idx = 4; 8230 else 8231 idx = spec->multiout.dac_nids[dac_idx] - 2; 8232 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx); 8233 8234 } 8235 8236 static void alc883_auto_init_multi_out(struct hda_codec *codec) 8237 { 8238 struct alc_spec *spec = codec->spec; 8239 int i; 8240 8241 alc_subsystem_id(codec, 0x15, 0x1b, 0x14); 8242 for (i = 0; i <= HDA_SIDE; i++) { 8243 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 8244 int pin_type = get_pin_type(spec->autocfg.line_out_type); 8245 if (nid) 8246 alc883_auto_set_output_and_unmute(codec, nid, pin_type, 8247 i); 8248 } 8249 } 8250 8251 static void alc883_auto_init_hp_out(struct hda_codec *codec) 8252 { 8253 struct alc_spec *spec = codec->spec; 8254 hda_nid_t pin; 8255 8256 pin = spec->autocfg.hp_pins[0]; 8257 if (pin) /* connect to front */ 8258 /* use dac 0 */ 8259 alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 8260 pin = spec->autocfg.speaker_pins[0]; 8261 if (pin) 8262 alc883_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 8263 } 8264 8265 #define alc883_is_input_pin(nid) alc880_is_input_pin(nid) 8266 #define ALC883_PIN_CD_NID ALC880_PIN_CD_NID 8267 8268 static void alc883_auto_init_analog_input(struct hda_codec *codec) 8269 { 8270 struct alc_spec *spec = codec->spec; 8271 int i; 8272 8273 for (i = 0; i < AUTO_PIN_LAST; i++) { 8274 hda_nid_t nid = spec->autocfg.input_pins[i]; 8275 if (alc883_is_input_pin(nid)) { 8276 snd_hda_codec_write(codec, nid, 0, 8277 AC_VERB_SET_PIN_WIDGET_CONTROL, 8278 (i <= AUTO_PIN_FRONT_MIC ? 8279 PIN_VREF80 : PIN_IN)); 8280 if (nid != ALC883_PIN_CD_NID) 8281 snd_hda_codec_write(codec, nid, 0, 8282 AC_VERB_SET_AMP_GAIN_MUTE, 8283 AMP_OUT_MUTE); 8284 } 8285 } 8286 } 8287 8288 /* almost identical with ALC880 parser... */ 8289 static int alc883_parse_auto_config(struct hda_codec *codec) 8290 { 8291 struct alc_spec *spec = codec->spec; 8292 int err = alc880_parse_auto_config(codec); 8293 8294 if (err < 0) 8295 return err; 8296 else if (!err) 8297 return 0; /* no config found */ 8298 8299 err = alc_auto_add_mic_boost(codec); 8300 if (err < 0) 8301 return err; 8302 8303 /* hack - override the init verbs */ 8304 spec->init_verbs[0] = alc883_auto_init_verbs; 8305 spec->mixers[spec->num_mixers] = alc883_capture_mixer; 8306 spec->num_mixers++; 8307 8308 return 1; /* config found */ 8309 } 8310 8311 /* additional initialization for auto-configuration model */ 8312 static void alc883_auto_init(struct hda_codec *codec) 8313 { 8314 struct alc_spec *spec = codec->spec; 8315 alc883_auto_init_multi_out(codec); 8316 alc883_auto_init_hp_out(codec); 8317 alc883_auto_init_analog_input(codec); 8318 if (spec->unsol_event) 8319 alc_sku_automute(codec); 8320 } 8321 8322 static int patch_alc883(struct hda_codec *codec) 8323 { 8324 struct alc_spec *spec; 8325 int err, board_config; 8326 8327 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 8328 if (spec == NULL) 8329 return -ENOMEM; 8330 8331 codec->spec = spec; 8332 8333 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 8334 8335 board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST, 8336 alc883_models, 8337 alc883_cfg_tbl); 8338 if (board_config < 0) { 8339 printk(KERN_INFO "hda_codec: Unknown model for ALC883, " 8340 "trying auto-probe from BIOS...\n"); 8341 board_config = ALC883_AUTO; 8342 } 8343 8344 if (board_config == ALC883_AUTO) { 8345 /* automatic parse from the BIOS config */ 8346 err = alc883_parse_auto_config(codec); 8347 if (err < 0) { 8348 alc_free(codec); 8349 return err; 8350 } else if (!err) { 8351 printk(KERN_INFO 8352 "hda_codec: Cannot set up configuration " 8353 "from BIOS. Using base mode...\n"); 8354 board_config = ALC883_3ST_2ch_DIG; 8355 } 8356 } 8357 8358 if (board_config != ALC883_AUTO) 8359 setup_preset(spec, &alc883_presets[board_config]); 8360 8361 switch (codec->vendor_id) { 8362 case 0x10ec0888: 8363 spec->stream_name_analog = "ALC888 Analog"; 8364 spec->stream_name_digital = "ALC888 Digital"; 8365 break; 8366 case 0x10ec0889: 8367 spec->stream_name_analog = "ALC889 Analog"; 8368 spec->stream_name_digital = "ALC889 Digital"; 8369 break; 8370 default: 8371 spec->stream_name_analog = "ALC883 Analog"; 8372 spec->stream_name_digital = "ALC883 Digital"; 8373 break; 8374 } 8375 8376 spec->stream_analog_playback = &alc883_pcm_analog_playback; 8377 spec->stream_analog_capture = &alc883_pcm_analog_capture; 8378 spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture; 8379 8380 spec->stream_digital_playback = &alc883_pcm_digital_playback; 8381 spec->stream_digital_capture = &alc883_pcm_digital_capture; 8382 8383 spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids); 8384 spec->adc_nids = alc883_adc_nids; 8385 spec->capsrc_nids = alc883_capsrc_nids; 8386 8387 spec->vmaster_nid = 0x0c; 8388 8389 codec->patch_ops = alc_patch_ops; 8390 if (board_config == ALC883_AUTO) 8391 spec->init_hook = alc883_auto_init; 8392 else if (codec->vendor_id == 0x10ec0888) 8393 spec->init_hook = alc888_coef_init; 8394 8395 #ifdef CONFIG_SND_HDA_POWER_SAVE 8396 if (!spec->loopback.amplist) 8397 spec->loopback.amplist = alc883_loopbacks; 8398 #endif 8399 8400 return 0; 8401 } 8402 8403 /* 8404 * ALC262 support 8405 */ 8406 8407 #define ALC262_DIGOUT_NID ALC880_DIGOUT_NID 8408 #define ALC262_DIGIN_NID ALC880_DIGIN_NID 8409 8410 #define alc262_dac_nids alc260_dac_nids 8411 #define alc262_adc_nids alc882_adc_nids 8412 #define alc262_adc_nids_alt alc882_adc_nids_alt 8413 #define alc262_capsrc_nids alc882_capsrc_nids 8414 #define alc262_capsrc_nids_alt alc882_capsrc_nids_alt 8415 8416 #define alc262_modes alc260_modes 8417 #define alc262_capture_source alc882_capture_source 8418 8419 static struct snd_kcontrol_new alc262_base_mixer[] = { 8420 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8421 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 8422 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 8423 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 8424 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 8425 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 8426 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8427 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8428 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 8429 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 8430 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 8431 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 8432 /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT), 8433 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */ 8434 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT), 8435 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 8436 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 8437 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT), 8438 { } /* end */ 8439 }; 8440 8441 static struct snd_kcontrol_new alc262_hippo1_mixer[] = { 8442 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8443 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 8444 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 8445 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 8446 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 8447 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 8448 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8449 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8450 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 8451 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 8452 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 8453 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 8454 /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT), 8455 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */ 8456 /*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/ 8457 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 8458 { } /* end */ 8459 }; 8460 8461 /* update HP, line and mono-out pins according to the master switch */ 8462 static void alc262_hp_master_update(struct hda_codec *codec) 8463 { 8464 struct alc_spec *spec = codec->spec; 8465 int val = spec->master_sw; 8466 8467 /* HP & line-out */ 8468 snd_hda_codec_write_cache(codec, 0x1b, 0, 8469 AC_VERB_SET_PIN_WIDGET_CONTROL, 8470 val ? PIN_HP : 0); 8471 snd_hda_codec_write_cache(codec, 0x15, 0, 8472 AC_VERB_SET_PIN_WIDGET_CONTROL, 8473 val ? PIN_HP : 0); 8474 /* mono (speaker) depending on the HP jack sense */ 8475 val = val && !spec->jack_present; 8476 snd_hda_codec_write_cache(codec, 0x16, 0, 8477 AC_VERB_SET_PIN_WIDGET_CONTROL, 8478 val ? PIN_OUT : 0); 8479 } 8480 8481 static void alc262_hp_bpc_automute(struct hda_codec *codec) 8482 { 8483 struct alc_spec *spec = codec->spec; 8484 unsigned int presence; 8485 presence = snd_hda_codec_read(codec, 0x1b, 0, 8486 AC_VERB_GET_PIN_SENSE, 0); 8487 spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE); 8488 alc262_hp_master_update(codec); 8489 } 8490 8491 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res) 8492 { 8493 if ((res >> 26) != ALC880_HP_EVENT) 8494 return; 8495 alc262_hp_bpc_automute(codec); 8496 } 8497 8498 static void alc262_hp_wildwest_automute(struct hda_codec *codec) 8499 { 8500 struct alc_spec *spec = codec->spec; 8501 unsigned int presence; 8502 presence = snd_hda_codec_read(codec, 0x15, 0, 8503 AC_VERB_GET_PIN_SENSE, 0); 8504 spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE); 8505 alc262_hp_master_update(codec); 8506 } 8507 8508 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec, 8509 unsigned int res) 8510 { 8511 if ((res >> 26) != ALC880_HP_EVENT) 8512 return; 8513 alc262_hp_wildwest_automute(codec); 8514 } 8515 8516 static int alc262_hp_master_sw_get(struct snd_kcontrol *kcontrol, 8517 struct snd_ctl_elem_value *ucontrol) 8518 { 8519 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 8520 struct alc_spec *spec = codec->spec; 8521 *ucontrol->value.integer.value = spec->master_sw; 8522 return 0; 8523 } 8524 8525 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol, 8526 struct snd_ctl_elem_value *ucontrol) 8527 { 8528 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 8529 struct alc_spec *spec = codec->spec; 8530 int val = !!*ucontrol->value.integer.value; 8531 8532 if (val == spec->master_sw) 8533 return 0; 8534 spec->master_sw = val; 8535 alc262_hp_master_update(codec); 8536 return 1; 8537 } 8538 8539 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = { 8540 { 8541 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 8542 .name = "Master Playback Switch", 8543 .info = snd_ctl_boolean_mono_info, 8544 .get = alc262_hp_master_sw_get, 8545 .put = alc262_hp_master_sw_put, 8546 }, 8547 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8548 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT), 8549 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 8550 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0, 8551 HDA_OUTPUT), 8552 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0, 8553 HDA_OUTPUT), 8554 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8555 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8556 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 8557 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 8558 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 8559 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 8560 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 8561 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 8562 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 8563 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 8564 HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT), 8565 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), 8566 HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT), 8567 HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT), 8568 { } /* end */ 8569 }; 8570 8571 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = { 8572 { 8573 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 8574 .name = "Master Playback Switch", 8575 .info = snd_ctl_boolean_mono_info, 8576 .get = alc262_hp_master_sw_get, 8577 .put = alc262_hp_master_sw_put, 8578 }, 8579 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8580 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 8581 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 8582 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 8583 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0, 8584 HDA_OUTPUT), 8585 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0, 8586 HDA_OUTPUT), 8587 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT), 8588 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT), 8589 HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT), 8590 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT), 8591 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT), 8592 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 8593 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 8594 HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT), 8595 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), 8596 { } /* end */ 8597 }; 8598 8599 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = { 8600 HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8601 HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8602 HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT), 8603 { } /* end */ 8604 }; 8605 8606 /* mute/unmute internal speaker according to the hp jack and mute state */ 8607 static void alc262_hp_t5735_automute(struct hda_codec *codec, int force) 8608 { 8609 struct alc_spec *spec = codec->spec; 8610 8611 if (force || !spec->sense_updated) { 8612 unsigned int present; 8613 present = snd_hda_codec_read(codec, 0x15, 0, 8614 AC_VERB_GET_PIN_SENSE, 0); 8615 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0; 8616 spec->sense_updated = 1; 8617 } 8618 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, HDA_AMP_MUTE, 8619 spec->jack_present ? HDA_AMP_MUTE : 0); 8620 } 8621 8622 static void alc262_hp_t5735_unsol_event(struct hda_codec *codec, 8623 unsigned int res) 8624 { 8625 if ((res >> 26) != ALC880_HP_EVENT) 8626 return; 8627 alc262_hp_t5735_automute(codec, 1); 8628 } 8629 8630 static void alc262_hp_t5735_init_hook(struct hda_codec *codec) 8631 { 8632 alc262_hp_t5735_automute(codec, 1); 8633 } 8634 8635 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = { 8636 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8637 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 8638 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 8639 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 8640 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8641 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8642 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 8643 { } /* end */ 8644 }; 8645 8646 static struct hda_verb alc262_hp_t5735_verbs[] = { 8647 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8648 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8649 8650 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 8651 { } 8652 }; 8653 8654 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = { 8655 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8656 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 8657 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT), 8658 HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT), 8659 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT), 8660 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT), 8661 { } /* end */ 8662 }; 8663 8664 static struct hda_verb alc262_hp_rp5700_verbs[] = { 8665 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8666 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8667 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8668 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8669 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 8670 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 8671 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 8672 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 8673 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))}, 8674 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))}, 8675 {} 8676 }; 8677 8678 static struct hda_input_mux alc262_hp_rp5700_capture_source = { 8679 .num_items = 1, 8680 .items = { 8681 { "Line", 0x1 }, 8682 }, 8683 }; 8684 8685 /* bind hp and internal speaker mute (with plug check) */ 8686 static int alc262_sony_master_sw_put(struct snd_kcontrol *kcontrol, 8687 struct snd_ctl_elem_value *ucontrol) 8688 { 8689 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 8690 long *valp = ucontrol->value.integer.value; 8691 int change; 8692 8693 /* change hp mute */ 8694 change = snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0, 8695 HDA_AMP_MUTE, 8696 valp[0] ? 0 : HDA_AMP_MUTE); 8697 change |= snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0, 8698 HDA_AMP_MUTE, 8699 valp[1] ? 0 : HDA_AMP_MUTE); 8700 if (change) { 8701 /* change speaker according to HP jack state */ 8702 struct alc_spec *spec = codec->spec; 8703 unsigned int mute; 8704 if (spec->jack_present) 8705 mute = HDA_AMP_MUTE; 8706 else 8707 mute = snd_hda_codec_amp_read(codec, 0x15, 0, 8708 HDA_OUTPUT, 0); 8709 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 8710 HDA_AMP_MUTE, mute); 8711 } 8712 return change; 8713 } 8714 8715 static struct snd_kcontrol_new alc262_sony_mixer[] = { 8716 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8717 { 8718 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 8719 .name = "Master Playback Switch", 8720 .info = snd_hda_mixer_amp_switch_info, 8721 .get = snd_hda_mixer_amp_switch_get, 8722 .put = alc262_sony_master_sw_put, 8723 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT), 8724 }, 8725 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8726 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8727 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 8728 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 8729 { } /* end */ 8730 }; 8731 8732 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = { 8733 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8734 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 8735 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 8736 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8737 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8738 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 8739 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 8740 { } /* end */ 8741 }; 8742 8743 #define alc262_capture_mixer alc882_capture_mixer 8744 #define alc262_capture_alt_mixer alc882_capture_alt_mixer 8745 8746 /* 8747 * generic initialization of ADC, input mixers and output mixers 8748 */ 8749 static struct hda_verb alc262_init_verbs[] = { 8750 /* 8751 * Unmute ADC0-2 and set the default input to mic-in 8752 */ 8753 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 8754 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8755 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 8756 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8757 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 8758 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8759 8760 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 8761 * mixer widget 8762 * Note: PASD motherboards uses the Line In 2 as the input for 8763 * front panel mic (mic 2) 8764 */ 8765 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 8766 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8767 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8768 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 8769 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 8770 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 8771 8772 /* 8773 * Set up output mixers (0x0c - 0x0e) 8774 */ 8775 /* set vol=0 to output mixers */ 8776 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8777 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8778 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8779 /* set up input amps for analog loopback */ 8780 /* Amp Indices: DAC = 0, mixer = 1 */ 8781 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8782 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8783 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8784 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8785 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8786 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8787 8788 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 8789 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 8790 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 8791 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 8792 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 8793 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 8794 8795 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 8796 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 8797 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 8798 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 8799 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 8800 8801 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 8802 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 8803 8804 /* FIXME: use matrix-type input source selection */ 8805 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 8806 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 8807 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 8808 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 8809 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 8810 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 8811 /* Input mixer2 */ 8812 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 8813 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 8814 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 8815 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 8816 /* Input mixer3 */ 8817 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 8818 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 8819 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 8820 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 8821 8822 { } 8823 }; 8824 8825 static struct hda_verb alc262_hippo_unsol_verbs[] = { 8826 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 8827 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8828 {} 8829 }; 8830 8831 static struct hda_verb alc262_hippo1_unsol_verbs[] = { 8832 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 8833 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 8834 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 8835 8836 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 8837 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8838 {} 8839 }; 8840 8841 static struct hda_verb alc262_sony_unsol_verbs[] = { 8842 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 8843 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 8844 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, // Front Mic 8845 8846 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 8847 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8848 {} 8849 }; 8850 8851 /* mute/unmute internal speaker according to the hp jack and mute state */ 8852 static void alc262_hippo_automute(struct hda_codec *codec) 8853 { 8854 struct alc_spec *spec = codec->spec; 8855 unsigned int mute; 8856 unsigned int present; 8857 8858 /* need to execute and sync at first */ 8859 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0); 8860 present = snd_hda_codec_read(codec, 0x15, 0, 8861 AC_VERB_GET_PIN_SENSE, 0); 8862 spec->jack_present = (present & 0x80000000) != 0; 8863 if (spec->jack_present) { 8864 /* mute internal speaker */ 8865 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 8866 HDA_AMP_MUTE, HDA_AMP_MUTE); 8867 } else { 8868 /* unmute internal speaker if necessary */ 8869 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0); 8870 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 8871 HDA_AMP_MUTE, mute); 8872 } 8873 } 8874 8875 /* unsolicited event for HP jack sensing */ 8876 static void alc262_hippo_unsol_event(struct hda_codec *codec, 8877 unsigned int res) 8878 { 8879 if ((res >> 26) != ALC880_HP_EVENT) 8880 return; 8881 alc262_hippo_automute(codec); 8882 } 8883 8884 static void alc262_hippo1_automute(struct hda_codec *codec) 8885 { 8886 unsigned int mute; 8887 unsigned int present; 8888 8889 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0); 8890 present = snd_hda_codec_read(codec, 0x1b, 0, 8891 AC_VERB_GET_PIN_SENSE, 0); 8892 present = (present & 0x80000000) != 0; 8893 if (present) { 8894 /* mute internal speaker */ 8895 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 8896 HDA_AMP_MUTE, HDA_AMP_MUTE); 8897 } else { 8898 /* unmute internal speaker if necessary */ 8899 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0); 8900 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 8901 HDA_AMP_MUTE, mute); 8902 } 8903 } 8904 8905 /* unsolicited event for HP jack sensing */ 8906 static void alc262_hippo1_unsol_event(struct hda_codec *codec, 8907 unsigned int res) 8908 { 8909 if ((res >> 26) != ALC880_HP_EVENT) 8910 return; 8911 alc262_hippo1_automute(codec); 8912 } 8913 8914 /* 8915 * fujitsu model 8916 * 0x14 = headphone/spdif-out, 0x15 = internal speaker, 8917 * 0x1b = port replicator headphone out 8918 */ 8919 8920 #define ALC_HP_EVENT 0x37 8921 8922 static struct hda_verb alc262_fujitsu_unsol_verbs[] = { 8923 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT}, 8924 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8925 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT}, 8926 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8927 {} 8928 }; 8929 8930 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = { 8931 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT}, 8932 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8933 {} 8934 }; 8935 8936 static struct hda_input_mux alc262_fujitsu_capture_source = { 8937 .num_items = 3, 8938 .items = { 8939 { "Mic", 0x0 }, 8940 { "Int Mic", 0x1 }, 8941 { "CD", 0x4 }, 8942 }, 8943 }; 8944 8945 static struct hda_input_mux alc262_HP_capture_source = { 8946 .num_items = 5, 8947 .items = { 8948 { "Mic", 0x0 }, 8949 { "Front Mic", 0x1 }, 8950 { "Line", 0x2 }, 8951 { "CD", 0x4 }, 8952 { "AUX IN", 0x6 }, 8953 }, 8954 }; 8955 8956 static struct hda_input_mux alc262_HP_D7000_capture_source = { 8957 .num_items = 4, 8958 .items = { 8959 { "Mic", 0x0 }, 8960 { "Front Mic", 0x2 }, 8961 { "Line", 0x1 }, 8962 { "CD", 0x4 }, 8963 }, 8964 }; 8965 8966 /* mute/unmute internal speaker according to the hp jacks and mute state */ 8967 static void alc262_fujitsu_automute(struct hda_codec *codec, int force) 8968 { 8969 struct alc_spec *spec = codec->spec; 8970 unsigned int mute; 8971 8972 if (force || !spec->sense_updated) { 8973 unsigned int present; 8974 /* need to execute and sync at first */ 8975 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0); 8976 /* check laptop HP jack */ 8977 present = snd_hda_codec_read(codec, 0x14, 0, 8978 AC_VERB_GET_PIN_SENSE, 0); 8979 /* need to execute and sync at first */ 8980 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0); 8981 /* check docking HP jack */ 8982 present |= snd_hda_codec_read(codec, 0x1b, 0, 8983 AC_VERB_GET_PIN_SENSE, 0); 8984 if (present & AC_PINSENSE_PRESENCE) 8985 spec->jack_present = 1; 8986 else 8987 spec->jack_present = 0; 8988 spec->sense_updated = 1; 8989 } 8990 /* unmute internal speaker only if both HPs are unplugged and 8991 * master switch is on 8992 */ 8993 if (spec->jack_present) 8994 mute = HDA_AMP_MUTE; 8995 else 8996 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0); 8997 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 8998 HDA_AMP_MUTE, mute); 8999 } 9000 9001 /* unsolicited event for HP jack sensing */ 9002 static void alc262_fujitsu_unsol_event(struct hda_codec *codec, 9003 unsigned int res) 9004 { 9005 if ((res >> 26) != ALC_HP_EVENT) 9006 return; 9007 alc262_fujitsu_automute(codec, 1); 9008 } 9009 9010 static void alc262_fujitsu_init_hook(struct hda_codec *codec) 9011 { 9012 alc262_fujitsu_automute(codec, 1); 9013 } 9014 9015 /* bind volumes of both NID 0x0c and 0x0d */ 9016 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = { 9017 .ops = &snd_hda_bind_vol, 9018 .values = { 9019 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT), 9020 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT), 9021 0 9022 }, 9023 }; 9024 9025 /* mute/unmute internal speaker according to the hp jack and mute state */ 9026 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force) 9027 { 9028 struct alc_spec *spec = codec->spec; 9029 unsigned int mute; 9030 9031 if (force || !spec->sense_updated) { 9032 unsigned int present_int_hp; 9033 /* need to execute and sync at first */ 9034 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0); 9035 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0, 9036 AC_VERB_GET_PIN_SENSE, 0); 9037 spec->jack_present = (present_int_hp & 0x80000000) != 0; 9038 spec->sense_updated = 1; 9039 } 9040 if (spec->jack_present) { 9041 /* mute internal speaker */ 9042 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9043 HDA_AMP_MUTE, HDA_AMP_MUTE); 9044 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 9045 HDA_AMP_MUTE, HDA_AMP_MUTE); 9046 } else { 9047 /* unmute internal speaker if necessary */ 9048 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0); 9049 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9050 HDA_AMP_MUTE, mute); 9051 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 9052 HDA_AMP_MUTE, mute); 9053 } 9054 } 9055 9056 /* unsolicited event for HP jack sensing */ 9057 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec, 9058 unsigned int res) 9059 { 9060 if ((res >> 26) != ALC_HP_EVENT) 9061 return; 9062 alc262_lenovo_3000_automute(codec, 1); 9063 } 9064 9065 /* bind hp and internal speaker mute (with plug check) */ 9066 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol, 9067 struct snd_ctl_elem_value *ucontrol) 9068 { 9069 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 9070 long *valp = ucontrol->value.integer.value; 9071 int change; 9072 9073 change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9074 HDA_AMP_MUTE, 9075 valp ? 0 : HDA_AMP_MUTE); 9076 change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 9077 HDA_AMP_MUTE, 9078 valp ? 0 : HDA_AMP_MUTE); 9079 9080 if (change) 9081 alc262_fujitsu_automute(codec, 0); 9082 return change; 9083 } 9084 9085 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = { 9086 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol), 9087 { 9088 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 9089 .name = "Master Playback Switch", 9090 .info = snd_hda_mixer_amp_switch_info, 9091 .get = snd_hda_mixer_amp_switch_get, 9092 .put = alc262_fujitsu_master_sw_put, 9093 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 9094 }, 9095 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 9096 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 9097 HDA_CODEC_VOLUME("PC Speaker Volume", 0x0b, 0x05, HDA_INPUT), 9098 HDA_CODEC_MUTE("PC Speaker Switch", 0x0b, 0x05, HDA_INPUT), 9099 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 9100 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9101 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9102 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 9103 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 9104 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 9105 { } /* end */ 9106 }; 9107 9108 /* bind hp and internal speaker mute (with plug check) */ 9109 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol, 9110 struct snd_ctl_elem_value *ucontrol) 9111 { 9112 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 9113 long *valp = ucontrol->value.integer.value; 9114 int change; 9115 9116 change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 9117 HDA_AMP_MUTE, 9118 valp ? 0 : HDA_AMP_MUTE); 9119 9120 if (change) 9121 alc262_lenovo_3000_automute(codec, 0); 9122 return change; 9123 } 9124 9125 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = { 9126 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol), 9127 { 9128 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 9129 .name = "Master Playback Switch", 9130 .info = snd_hda_mixer_amp_switch_info, 9131 .get = snd_hda_mixer_amp_switch_get, 9132 .put = alc262_lenovo_3000_master_sw_put, 9133 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT), 9134 }, 9135 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 9136 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 9137 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 9138 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9139 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9140 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 9141 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 9142 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 9143 { } /* end */ 9144 }; 9145 9146 /* additional init verbs for Benq laptops */ 9147 static struct hda_verb alc262_EAPD_verbs[] = { 9148 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 9149 {0x20, AC_VERB_SET_PROC_COEF, 0x3070}, 9150 {} 9151 }; 9152 9153 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = { 9154 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 9155 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 9156 9157 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 9158 {0x20, AC_VERB_SET_PROC_COEF, 0x3050}, 9159 {} 9160 }; 9161 9162 /* Samsung Q1 Ultra Vista model setup */ 9163 static struct snd_kcontrol_new alc262_ultra_mixer[] = { 9164 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9165 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT), 9166 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 9167 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 9168 HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT), 9169 HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT), 9170 { } /* end */ 9171 }; 9172 9173 static struct hda_verb alc262_ultra_verbs[] = { 9174 /* output mixer */ 9175 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 9176 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 9177 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9178 /* speaker */ 9179 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9180 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 9181 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9182 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 9183 /* HP */ 9184 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9185 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 9186 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9187 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 9188 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 9189 /* internal mic */ 9190 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 9191 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 9192 /* ADC, choose mic */ 9193 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 9194 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 9195 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9196 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 9197 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 9198 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 9199 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 9200 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 9201 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 9202 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)}, 9203 {} 9204 }; 9205 9206 /* mute/unmute internal speaker according to the hp jack and mute state */ 9207 static void alc262_ultra_automute(struct hda_codec *codec) 9208 { 9209 struct alc_spec *spec = codec->spec; 9210 unsigned int mute; 9211 9212 mute = 0; 9213 /* auto-mute only when HP is used as HP */ 9214 if (!spec->cur_mux[0]) { 9215 unsigned int present; 9216 /* need to execute and sync at first */ 9217 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0); 9218 present = snd_hda_codec_read(codec, 0x15, 0, 9219 AC_VERB_GET_PIN_SENSE, 0); 9220 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0; 9221 if (spec->jack_present) 9222 mute = HDA_AMP_MUTE; 9223 } 9224 /* mute/unmute internal speaker */ 9225 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9226 HDA_AMP_MUTE, mute); 9227 /* mute/unmute HP */ 9228 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 9229 HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE); 9230 } 9231 9232 /* unsolicited event for HP jack sensing */ 9233 static void alc262_ultra_unsol_event(struct hda_codec *codec, 9234 unsigned int res) 9235 { 9236 if ((res >> 26) != ALC880_HP_EVENT) 9237 return; 9238 alc262_ultra_automute(codec); 9239 } 9240 9241 static struct hda_input_mux alc262_ultra_capture_source = { 9242 .num_items = 2, 9243 .items = { 9244 { "Mic", 0x1 }, 9245 { "Headphone", 0x7 }, 9246 }, 9247 }; 9248 9249 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol, 9250 struct snd_ctl_elem_value *ucontrol) 9251 { 9252 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 9253 struct alc_spec *spec = codec->spec; 9254 int ret; 9255 9256 ret = alc882_mux_enum_put(kcontrol, ucontrol); 9257 if (!ret) 9258 return 0; 9259 /* reprogram the HP pin as mic or HP according to the input source */ 9260 snd_hda_codec_write_cache(codec, 0x15, 0, 9261 AC_VERB_SET_PIN_WIDGET_CONTROL, 9262 spec->cur_mux[0] ? PIN_VREF80 : PIN_HP); 9263 alc262_ultra_automute(codec); /* mute/unmute HP */ 9264 return ret; 9265 } 9266 9267 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = { 9268 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT), 9269 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT), 9270 { 9271 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 9272 .name = "Capture Source", 9273 .info = alc882_mux_enum_info, 9274 .get = alc882_mux_enum_get, 9275 .put = alc262_ultra_mux_enum_put, 9276 }, 9277 { } /* end */ 9278 }; 9279 9280 /* add playback controls from the parsed DAC table */ 9281 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec, 9282 const struct auto_pin_cfg *cfg) 9283 { 9284 hda_nid_t nid; 9285 int err; 9286 9287 spec->multiout.num_dacs = 1; /* only use one dac */ 9288 spec->multiout.dac_nids = spec->private_dac_nids; 9289 spec->multiout.dac_nids[0] = 2; 9290 9291 nid = cfg->line_out_pins[0]; 9292 if (nid) { 9293 err = add_control(spec, ALC_CTL_WIDGET_VOL, 9294 "Front Playback Volume", 9295 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT)); 9296 if (err < 0) 9297 return err; 9298 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 9299 "Front Playback Switch", 9300 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 9301 if (err < 0) 9302 return err; 9303 } 9304 9305 nid = cfg->speaker_pins[0]; 9306 if (nid) { 9307 if (nid == 0x16) { 9308 err = add_control(spec, ALC_CTL_WIDGET_VOL, 9309 "Speaker Playback Volume", 9310 HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, 9311 HDA_OUTPUT)); 9312 if (err < 0) 9313 return err; 9314 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 9315 "Speaker Playback Switch", 9316 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 9317 HDA_OUTPUT)); 9318 if (err < 0) 9319 return err; 9320 } else { 9321 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 9322 "Speaker Playback Switch", 9323 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 9324 HDA_OUTPUT)); 9325 if (err < 0) 9326 return err; 9327 } 9328 } 9329 nid = cfg->hp_pins[0]; 9330 if (nid) { 9331 /* spec->multiout.hp_nid = 2; */ 9332 if (nid == 0x16) { 9333 err = add_control(spec, ALC_CTL_WIDGET_VOL, 9334 "Headphone Playback Volume", 9335 HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, 9336 HDA_OUTPUT)); 9337 if (err < 0) 9338 return err; 9339 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 9340 "Headphone Playback Switch", 9341 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 9342 HDA_OUTPUT)); 9343 if (err < 0) 9344 return err; 9345 } else { 9346 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 9347 "Headphone Playback Switch", 9348 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 9349 HDA_OUTPUT)); 9350 if (err < 0) 9351 return err; 9352 } 9353 } 9354 return 0; 9355 } 9356 9357 /* identical with ALC880 */ 9358 #define alc262_auto_create_analog_input_ctls \ 9359 alc880_auto_create_analog_input_ctls 9360 9361 /* 9362 * generic initialization of ADC, input mixers and output mixers 9363 */ 9364 static struct hda_verb alc262_volume_init_verbs[] = { 9365 /* 9366 * Unmute ADC0-2 and set the default input to mic-in 9367 */ 9368 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 9369 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9370 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 9371 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9372 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 9373 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9374 9375 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 9376 * mixer widget 9377 * Note: PASD motherboards uses the Line In 2 as the input for 9378 * front panel mic (mic 2) 9379 */ 9380 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 9381 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 9382 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 9383 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 9384 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 9385 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 9386 9387 /* 9388 * Set up output mixers (0x0c - 0x0f) 9389 */ 9390 /* set vol=0 to output mixers */ 9391 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9392 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9393 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9394 9395 /* set up input amps for analog loopback */ 9396 /* Amp Indices: DAC = 0, mixer = 1 */ 9397 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9398 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9399 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9400 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9401 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9402 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9403 9404 /* FIXME: use matrix-type input source selection */ 9405 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 9406 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 9407 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 9408 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 9409 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 9410 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 9411 /* Input mixer2 */ 9412 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 9413 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 9414 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 9415 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 9416 /* Input mixer3 */ 9417 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 9418 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 9419 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 9420 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 9421 9422 { } 9423 }; 9424 9425 static struct hda_verb alc262_HP_BPC_init_verbs[] = { 9426 /* 9427 * Unmute ADC0-2 and set the default input to mic-in 9428 */ 9429 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 9430 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9431 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 9432 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9433 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 9434 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9435 9436 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 9437 * mixer widget 9438 * Note: PASD motherboards uses the Line In 2 as the input for 9439 * front panel mic (mic 2) 9440 */ 9441 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 9442 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 9443 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 9444 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 9445 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 9446 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 9447 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 9448 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 9449 9450 /* 9451 * Set up output mixers (0x0c - 0x0e) 9452 */ 9453 /* set vol=0 to output mixers */ 9454 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9455 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9456 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9457 9458 /* set up input amps for analog loopback */ 9459 /* Amp Indices: DAC = 0, mixer = 1 */ 9460 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9461 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9462 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9463 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9464 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9465 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9466 9467 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9468 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 9469 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 9470 9471 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 9472 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 9473 9474 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 9475 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 9476 9477 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 9478 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 9479 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 9480 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 9481 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 9482 9483 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, 9484 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 9485 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 9486 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, 9487 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 9488 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 9489 9490 9491 /* FIXME: use matrix-type input source selection */ 9492 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 9493 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 9494 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 9495 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, 9496 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, 9497 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, 9498 /* Input mixer2 */ 9499 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 9500 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, 9501 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, 9502 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, 9503 /* Input mixer3 */ 9504 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 9505 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, 9506 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, 9507 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, 9508 9509 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9510 9511 { } 9512 }; 9513 9514 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = { 9515 /* 9516 * Unmute ADC0-2 and set the default input to mic-in 9517 */ 9518 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 9519 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9520 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 9521 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9522 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 9523 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9524 9525 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 9526 * mixer widget 9527 * Note: PASD motherboards uses the Line In 2 as the input for front 9528 * panel mic (mic 2) 9529 */ 9530 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 9531 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 9532 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 9533 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 9534 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 9535 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 9536 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 9537 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 9538 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 9539 /* 9540 * Set up output mixers (0x0c - 0x0e) 9541 */ 9542 /* set vol=0 to output mixers */ 9543 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9544 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9545 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9546 9547 /* set up input amps for analog loopback */ 9548 /* Amp Indices: DAC = 0, mixer = 1 */ 9549 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9550 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9551 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9552 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9553 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9554 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9555 9556 9557 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP */ 9558 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Mono */ 9559 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* rear MIC */ 9560 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* Line in */ 9561 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Front MIC */ 9562 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Line out */ 9563 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD in */ 9564 9565 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 9566 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 9567 9568 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 9569 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 9570 9571 /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */ 9572 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 9573 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 9574 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, 9575 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 9576 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 9577 9578 /* FIXME: use matrix-type input source selection */ 9579 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 9580 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 9581 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/ 9582 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/ 9583 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/ 9584 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/ 9585 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/ 9586 /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */ 9587 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/ 9588 /* Input mixer2 */ 9589 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 9590 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 9591 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, 9592 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, 9593 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, 9594 /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */ 9595 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, 9596 /* Input mixer3 */ 9597 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 9598 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 9599 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, 9600 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, 9601 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, 9602 /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */ 9603 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, 9604 9605 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9606 9607 { } 9608 }; 9609 9610 #ifdef CONFIG_SND_HDA_POWER_SAVE 9611 #define alc262_loopbacks alc880_loopbacks 9612 #endif 9613 9614 /* pcm configuration: identiacal with ALC880 */ 9615 #define alc262_pcm_analog_playback alc880_pcm_analog_playback 9616 #define alc262_pcm_analog_capture alc880_pcm_analog_capture 9617 #define alc262_pcm_digital_playback alc880_pcm_digital_playback 9618 #define alc262_pcm_digital_capture alc880_pcm_digital_capture 9619 9620 /* 9621 * BIOS auto configuration 9622 */ 9623 static int alc262_parse_auto_config(struct hda_codec *codec) 9624 { 9625 struct alc_spec *spec = codec->spec; 9626 int err; 9627 static hda_nid_t alc262_ignore[] = { 0x1d, 0 }; 9628 9629 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 9630 alc262_ignore); 9631 if (err < 0) 9632 return err; 9633 if (!spec->autocfg.line_outs) 9634 return 0; /* can't find valid BIOS pin config */ 9635 err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg); 9636 if (err < 0) 9637 return err; 9638 err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg); 9639 if (err < 0) 9640 return err; 9641 9642 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 9643 9644 if (spec->autocfg.dig_out_pin) 9645 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID; 9646 if (spec->autocfg.dig_in_pin) 9647 spec->dig_in_nid = ALC262_DIGIN_NID; 9648 9649 if (spec->kctl_alloc) 9650 spec->mixers[spec->num_mixers++] = spec->kctl_alloc; 9651 9652 spec->init_verbs[spec->num_init_verbs++] = alc262_volume_init_verbs; 9653 spec->num_mux_defs = 1; 9654 spec->input_mux = &spec->private_imux; 9655 9656 err = alc_auto_add_mic_boost(codec); 9657 if (err < 0) 9658 return err; 9659 9660 return 1; 9661 } 9662 9663 #define alc262_auto_init_multi_out alc882_auto_init_multi_out 9664 #define alc262_auto_init_hp_out alc882_auto_init_hp_out 9665 #define alc262_auto_init_analog_input alc882_auto_init_analog_input 9666 9667 9668 /* init callback for auto-configuration model -- overriding the default init */ 9669 static void alc262_auto_init(struct hda_codec *codec) 9670 { 9671 struct alc_spec *spec = codec->spec; 9672 alc262_auto_init_multi_out(codec); 9673 alc262_auto_init_hp_out(codec); 9674 alc262_auto_init_analog_input(codec); 9675 if (spec->unsol_event) 9676 alc_sku_automute(codec); 9677 } 9678 9679 /* 9680 * configuration and preset 9681 */ 9682 static const char *alc262_models[ALC262_MODEL_LAST] = { 9683 [ALC262_BASIC] = "basic", 9684 [ALC262_HIPPO] = "hippo", 9685 [ALC262_HIPPO_1] = "hippo_1", 9686 [ALC262_FUJITSU] = "fujitsu", 9687 [ALC262_HP_BPC] = "hp-bpc", 9688 [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000", 9689 [ALC262_HP_TC_T5735] = "hp-tc-t5735", 9690 [ALC262_HP_RP5700] = "hp-rp5700", 9691 [ALC262_BENQ_ED8] = "benq", 9692 [ALC262_BENQ_T31] = "benq-t31", 9693 [ALC262_SONY_ASSAMD] = "sony-assamd", 9694 [ALC262_ULTRA] = "ultra", 9695 [ALC262_LENOVO_3000] = "lenovo-3000", 9696 [ALC262_AUTO] = "auto", 9697 }; 9698 9699 static struct snd_pci_quirk alc262_cfg_tbl[] = { 9700 SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO), 9701 SND_PCI_QUIRK(0x103c, 0x12fe, "HP xw9400", ALC262_HP_BPC), 9702 SND_PCI_QUIRK(0x103c, 0x12ff, "HP xw4550", ALC262_HP_BPC), 9703 SND_PCI_QUIRK(0x103c, 0x1306, "HP xw8600", ALC262_HP_BPC), 9704 SND_PCI_QUIRK(0x103c, 0x1307, "HP xw6600", ALC262_HP_BPC), 9705 SND_PCI_QUIRK(0x103c, 0x1308, "HP xw4600", ALC262_HP_BPC), 9706 SND_PCI_QUIRK(0x103c, 0x1309, "HP xw4*00", ALC262_HP_BPC), 9707 SND_PCI_QUIRK(0x103c, 0x130a, "HP xw6*00", ALC262_HP_BPC), 9708 SND_PCI_QUIRK(0x103c, 0x130b, "HP xw8*00", ALC262_HP_BPC), 9709 SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL), 9710 SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF), 9711 SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL), 9712 SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF), 9713 SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL), 9714 SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF), 9715 SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL), 9716 SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF), 9717 SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC), 9718 SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC), 9719 SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC), 9720 SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735", 9721 ALC262_HP_TC_T5735), 9722 SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700), 9723 SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD), 9724 SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO), 9725 SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD), 9726 SND_PCI_QUIRK(0x104d, 0x900e, "Sony ASSAMD", ALC262_SONY_ASSAMD), 9727 SND_PCI_QUIRK(0x104d, 0x9015, "Sony 0x9015", ALC262_SONY_ASSAMD), 9728 SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1", 9729 ALC262_SONY_ASSAMD), 9730 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU), 9731 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU), 9732 SND_PCI_QUIRK(0x144d, 0xc032, "Samsung Q1 Ultra", ALC262_ULTRA), 9733 SND_PCI_QUIRK(0x144d, 0xc039, "Samsung Q1U EL", ALC262_ULTRA), 9734 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000), 9735 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8), 9736 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31), 9737 SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1), 9738 {} 9739 }; 9740 9741 static struct alc_config_preset alc262_presets[] = { 9742 [ALC262_BASIC] = { 9743 .mixers = { alc262_base_mixer }, 9744 .init_verbs = { alc262_init_verbs }, 9745 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 9746 .dac_nids = alc262_dac_nids, 9747 .hp_nid = 0x03, 9748 .num_channel_mode = ARRAY_SIZE(alc262_modes), 9749 .channel_mode = alc262_modes, 9750 .input_mux = &alc262_capture_source, 9751 }, 9752 [ALC262_HIPPO] = { 9753 .mixers = { alc262_base_mixer }, 9754 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs}, 9755 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 9756 .dac_nids = alc262_dac_nids, 9757 .hp_nid = 0x03, 9758 .dig_out_nid = ALC262_DIGOUT_NID, 9759 .num_channel_mode = ARRAY_SIZE(alc262_modes), 9760 .channel_mode = alc262_modes, 9761 .input_mux = &alc262_capture_source, 9762 .unsol_event = alc262_hippo_unsol_event, 9763 .init_hook = alc262_hippo_automute, 9764 }, 9765 [ALC262_HIPPO_1] = { 9766 .mixers = { alc262_hippo1_mixer }, 9767 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs}, 9768 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 9769 .dac_nids = alc262_dac_nids, 9770 .hp_nid = 0x02, 9771 .dig_out_nid = ALC262_DIGOUT_NID, 9772 .num_channel_mode = ARRAY_SIZE(alc262_modes), 9773 .channel_mode = alc262_modes, 9774 .input_mux = &alc262_capture_source, 9775 .unsol_event = alc262_hippo1_unsol_event, 9776 .init_hook = alc262_hippo1_automute, 9777 }, 9778 [ALC262_FUJITSU] = { 9779 .mixers = { alc262_fujitsu_mixer }, 9780 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs, 9781 alc262_fujitsu_unsol_verbs }, 9782 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 9783 .dac_nids = alc262_dac_nids, 9784 .hp_nid = 0x03, 9785 .dig_out_nid = ALC262_DIGOUT_NID, 9786 .num_channel_mode = ARRAY_SIZE(alc262_modes), 9787 .channel_mode = alc262_modes, 9788 .input_mux = &alc262_fujitsu_capture_source, 9789 .unsol_event = alc262_fujitsu_unsol_event, 9790 .init_hook = alc262_fujitsu_init_hook, 9791 }, 9792 [ALC262_HP_BPC] = { 9793 .mixers = { alc262_HP_BPC_mixer }, 9794 .init_verbs = { alc262_HP_BPC_init_verbs }, 9795 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 9796 .dac_nids = alc262_dac_nids, 9797 .hp_nid = 0x03, 9798 .num_channel_mode = ARRAY_SIZE(alc262_modes), 9799 .channel_mode = alc262_modes, 9800 .input_mux = &alc262_HP_capture_source, 9801 .unsol_event = alc262_hp_bpc_unsol_event, 9802 .init_hook = alc262_hp_bpc_automute, 9803 }, 9804 [ALC262_HP_BPC_D7000_WF] = { 9805 .mixers = { alc262_HP_BPC_WildWest_mixer }, 9806 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs }, 9807 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 9808 .dac_nids = alc262_dac_nids, 9809 .hp_nid = 0x03, 9810 .num_channel_mode = ARRAY_SIZE(alc262_modes), 9811 .channel_mode = alc262_modes, 9812 .input_mux = &alc262_HP_D7000_capture_source, 9813 .unsol_event = alc262_hp_wildwest_unsol_event, 9814 .init_hook = alc262_hp_wildwest_automute, 9815 }, 9816 [ALC262_HP_BPC_D7000_WL] = { 9817 .mixers = { alc262_HP_BPC_WildWest_mixer, 9818 alc262_HP_BPC_WildWest_option_mixer }, 9819 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs }, 9820 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 9821 .dac_nids = alc262_dac_nids, 9822 .hp_nid = 0x03, 9823 .num_channel_mode = ARRAY_SIZE(alc262_modes), 9824 .channel_mode = alc262_modes, 9825 .input_mux = &alc262_HP_D7000_capture_source, 9826 .unsol_event = alc262_hp_wildwest_unsol_event, 9827 .init_hook = alc262_hp_wildwest_automute, 9828 }, 9829 [ALC262_HP_TC_T5735] = { 9830 .mixers = { alc262_hp_t5735_mixer }, 9831 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs }, 9832 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 9833 .dac_nids = alc262_dac_nids, 9834 .hp_nid = 0x03, 9835 .num_channel_mode = ARRAY_SIZE(alc262_modes), 9836 .channel_mode = alc262_modes, 9837 .input_mux = &alc262_capture_source, 9838 .unsol_event = alc262_hp_t5735_unsol_event, 9839 .init_hook = alc262_hp_t5735_init_hook, 9840 }, 9841 [ALC262_HP_RP5700] = { 9842 .mixers = { alc262_hp_rp5700_mixer }, 9843 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs }, 9844 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 9845 .dac_nids = alc262_dac_nids, 9846 .num_channel_mode = ARRAY_SIZE(alc262_modes), 9847 .channel_mode = alc262_modes, 9848 .input_mux = &alc262_hp_rp5700_capture_source, 9849 }, 9850 [ALC262_BENQ_ED8] = { 9851 .mixers = { alc262_base_mixer }, 9852 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs }, 9853 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 9854 .dac_nids = alc262_dac_nids, 9855 .hp_nid = 0x03, 9856 .num_channel_mode = ARRAY_SIZE(alc262_modes), 9857 .channel_mode = alc262_modes, 9858 .input_mux = &alc262_capture_source, 9859 }, 9860 [ALC262_SONY_ASSAMD] = { 9861 .mixers = { alc262_sony_mixer }, 9862 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs}, 9863 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 9864 .dac_nids = alc262_dac_nids, 9865 .hp_nid = 0x02, 9866 .num_channel_mode = ARRAY_SIZE(alc262_modes), 9867 .channel_mode = alc262_modes, 9868 .input_mux = &alc262_capture_source, 9869 .unsol_event = alc262_hippo_unsol_event, 9870 .init_hook = alc262_hippo_automute, 9871 }, 9872 [ALC262_BENQ_T31] = { 9873 .mixers = { alc262_benq_t31_mixer }, 9874 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs }, 9875 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 9876 .dac_nids = alc262_dac_nids, 9877 .hp_nid = 0x03, 9878 .num_channel_mode = ARRAY_SIZE(alc262_modes), 9879 .channel_mode = alc262_modes, 9880 .input_mux = &alc262_capture_source, 9881 .unsol_event = alc262_hippo_unsol_event, 9882 .init_hook = alc262_hippo_automute, 9883 }, 9884 [ALC262_ULTRA] = { 9885 .mixers = { alc262_ultra_mixer, alc262_ultra_capture_mixer }, 9886 .init_verbs = { alc262_ultra_verbs }, 9887 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 9888 .dac_nids = alc262_dac_nids, 9889 .num_channel_mode = ARRAY_SIZE(alc262_modes), 9890 .channel_mode = alc262_modes, 9891 .input_mux = &alc262_ultra_capture_source, 9892 .adc_nids = alc262_adc_nids, /* ADC0 */ 9893 .capsrc_nids = alc262_capsrc_nids, 9894 .num_adc_nids = 1, /* single ADC */ 9895 .unsol_event = alc262_ultra_unsol_event, 9896 .init_hook = alc262_ultra_automute, 9897 }, 9898 [ALC262_LENOVO_3000] = { 9899 .mixers = { alc262_lenovo_3000_mixer }, 9900 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs, 9901 alc262_lenovo_3000_unsol_verbs }, 9902 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 9903 .dac_nids = alc262_dac_nids, 9904 .hp_nid = 0x03, 9905 .dig_out_nid = ALC262_DIGOUT_NID, 9906 .num_channel_mode = ARRAY_SIZE(alc262_modes), 9907 .channel_mode = alc262_modes, 9908 .input_mux = &alc262_fujitsu_capture_source, 9909 .unsol_event = alc262_lenovo_3000_unsol_event, 9910 }, 9911 }; 9912 9913 static int patch_alc262(struct hda_codec *codec) 9914 { 9915 struct alc_spec *spec; 9916 int board_config; 9917 int err; 9918 9919 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 9920 if (spec == NULL) 9921 return -ENOMEM; 9922 9923 codec->spec = spec; 9924 #if 0 9925 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is 9926 * under-run 9927 */ 9928 { 9929 int tmp; 9930 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7); 9931 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0); 9932 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7); 9933 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80); 9934 } 9935 #endif 9936 9937 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 9938 9939 board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST, 9940 alc262_models, 9941 alc262_cfg_tbl); 9942 9943 if (board_config < 0) { 9944 printk(KERN_INFO "hda_codec: Unknown model for ALC262, " 9945 "trying auto-probe from BIOS...\n"); 9946 board_config = ALC262_AUTO; 9947 } 9948 9949 if (board_config == ALC262_AUTO) { 9950 /* automatic parse from the BIOS config */ 9951 err = alc262_parse_auto_config(codec); 9952 if (err < 0) { 9953 alc_free(codec); 9954 return err; 9955 } else if (!err) { 9956 printk(KERN_INFO 9957 "hda_codec: Cannot set up configuration " 9958 "from BIOS. Using base mode...\n"); 9959 board_config = ALC262_BASIC; 9960 } 9961 } 9962 9963 if (board_config != ALC262_AUTO) 9964 setup_preset(spec, &alc262_presets[board_config]); 9965 9966 spec->stream_name_analog = "ALC262 Analog"; 9967 spec->stream_analog_playback = &alc262_pcm_analog_playback; 9968 spec->stream_analog_capture = &alc262_pcm_analog_capture; 9969 9970 spec->stream_name_digital = "ALC262 Digital"; 9971 spec->stream_digital_playback = &alc262_pcm_digital_playback; 9972 spec->stream_digital_capture = &alc262_pcm_digital_capture; 9973 9974 if (!spec->adc_nids && spec->input_mux) { 9975 /* check whether NID 0x07 is valid */ 9976 unsigned int wcap = get_wcaps(codec, 0x07); 9977 9978 /* get type */ 9979 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 9980 if (wcap != AC_WID_AUD_IN) { 9981 spec->adc_nids = alc262_adc_nids_alt; 9982 spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt); 9983 spec->capsrc_nids = alc262_capsrc_nids_alt; 9984 spec->mixers[spec->num_mixers] = 9985 alc262_capture_alt_mixer; 9986 spec->num_mixers++; 9987 } else { 9988 spec->adc_nids = alc262_adc_nids; 9989 spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids); 9990 spec->capsrc_nids = alc262_capsrc_nids; 9991 spec->mixers[spec->num_mixers] = alc262_capture_mixer; 9992 spec->num_mixers++; 9993 } 9994 } 9995 9996 spec->vmaster_nid = 0x0c; 9997 9998 codec->patch_ops = alc_patch_ops; 9999 if (board_config == ALC262_AUTO) 10000 spec->init_hook = alc262_auto_init; 10001 #ifdef CONFIG_SND_HDA_POWER_SAVE 10002 if (!spec->loopback.amplist) 10003 spec->loopback.amplist = alc262_loopbacks; 10004 #endif 10005 10006 return 0; 10007 } 10008 10009 /* 10010 * ALC268 channel source setting (2 channel) 10011 */ 10012 #define ALC268_DIGOUT_NID ALC880_DIGOUT_NID 10013 #define alc268_modes alc260_modes 10014 10015 static hda_nid_t alc268_dac_nids[2] = { 10016 /* front, hp */ 10017 0x02, 0x03 10018 }; 10019 10020 static hda_nid_t alc268_adc_nids[2] = { 10021 /* ADC0-1 */ 10022 0x08, 0x07 10023 }; 10024 10025 static hda_nid_t alc268_adc_nids_alt[1] = { 10026 /* ADC0 */ 10027 0x08 10028 }; 10029 10030 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 }; 10031 10032 static struct snd_kcontrol_new alc268_base_mixer[] = { 10033 /* output mixer control */ 10034 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT), 10035 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 10036 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT), 10037 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 10038 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 10039 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 10040 HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT), 10041 { } 10042 }; 10043 10044 /* bind Beep switches of both NID 0x0f and 0x10 */ 10045 static struct hda_bind_ctls alc268_bind_beep_sw = { 10046 .ops = &snd_hda_bind_sw, 10047 .values = { 10048 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT), 10049 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT), 10050 0 10051 }, 10052 }; 10053 10054 static struct snd_kcontrol_new alc268_beep_mixer[] = { 10055 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT), 10056 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw), 10057 { } 10058 }; 10059 10060 static struct hda_verb alc268_eapd_verbs[] = { 10061 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 10062 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 10063 { } 10064 }; 10065 10066 /* Toshiba specific */ 10067 #define alc268_toshiba_automute alc262_hippo_automute 10068 10069 static struct hda_verb alc268_toshiba_verbs[] = { 10070 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 10071 { } /* end */ 10072 }; 10073 10074 /* Acer specific */ 10075 /* bind volumes of both NID 0x02 and 0x03 */ 10076 static struct hda_bind_ctls alc268_acer_bind_master_vol = { 10077 .ops = &snd_hda_bind_vol, 10078 .values = { 10079 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT), 10080 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT), 10081 0 10082 }, 10083 }; 10084 10085 /* mute/unmute internal speaker according to the hp jack and mute state */ 10086 static void alc268_acer_automute(struct hda_codec *codec, int force) 10087 { 10088 struct alc_spec *spec = codec->spec; 10089 unsigned int mute; 10090 10091 if (force || !spec->sense_updated) { 10092 unsigned int present; 10093 present = snd_hda_codec_read(codec, 0x14, 0, 10094 AC_VERB_GET_PIN_SENSE, 0); 10095 spec->jack_present = (present & 0x80000000) != 0; 10096 spec->sense_updated = 1; 10097 } 10098 if (spec->jack_present) 10099 mute = HDA_AMP_MUTE; /* mute internal speaker */ 10100 else /* unmute internal speaker if necessary */ 10101 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0); 10102 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 10103 HDA_AMP_MUTE, mute); 10104 } 10105 10106 10107 /* bind hp and internal speaker mute (with plug check) */ 10108 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol, 10109 struct snd_ctl_elem_value *ucontrol) 10110 { 10111 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 10112 long *valp = ucontrol->value.integer.value; 10113 int change; 10114 10115 change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0, 10116 HDA_AMP_MUTE, 10117 valp[0] ? 0 : HDA_AMP_MUTE); 10118 change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0, 10119 HDA_AMP_MUTE, 10120 valp[1] ? 0 : HDA_AMP_MUTE); 10121 if (change) 10122 alc268_acer_automute(codec, 0); 10123 return change; 10124 } 10125 10126 static struct snd_kcontrol_new alc268_acer_mixer[] = { 10127 /* output mixer control */ 10128 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol), 10129 { 10130 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 10131 .name = "Master Playback Switch", 10132 .info = snd_hda_mixer_amp_switch_info, 10133 .get = snd_hda_mixer_amp_switch_get, 10134 .put = alc268_acer_master_sw_put, 10135 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 10136 }, 10137 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 10138 HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT), 10139 HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT), 10140 { } 10141 }; 10142 10143 static struct hda_verb alc268_acer_verbs[] = { 10144 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */ 10145 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 10146 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 10147 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 10148 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 10149 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 10150 10151 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 10152 { } 10153 }; 10154 10155 /* unsolicited event for HP jack sensing */ 10156 static void alc268_toshiba_unsol_event(struct hda_codec *codec, 10157 unsigned int res) 10158 { 10159 if ((res >> 26) != ALC880_HP_EVENT) 10160 return; 10161 alc268_toshiba_automute(codec); 10162 } 10163 10164 static void alc268_acer_unsol_event(struct hda_codec *codec, 10165 unsigned int res) 10166 { 10167 if ((res >> 26) != ALC880_HP_EVENT) 10168 return; 10169 alc268_acer_automute(codec, 1); 10170 } 10171 10172 static void alc268_acer_init_hook(struct hda_codec *codec) 10173 { 10174 alc268_acer_automute(codec, 1); 10175 } 10176 10177 static struct snd_kcontrol_new alc268_dell_mixer[] = { 10178 /* output mixer control */ 10179 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 10180 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 10181 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 10182 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 10183 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 10184 HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT), 10185 { } 10186 }; 10187 10188 static struct hda_verb alc268_dell_verbs[] = { 10189 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 10190 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 10191 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 10192 { } 10193 }; 10194 10195 /* mute/unmute internal speaker according to the hp jack and mute state */ 10196 static void alc268_dell_automute(struct hda_codec *codec) 10197 { 10198 unsigned int present; 10199 unsigned int mute; 10200 10201 present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0); 10202 if (present & 0x80000000) 10203 mute = HDA_AMP_MUTE; 10204 else 10205 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0); 10206 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 10207 HDA_AMP_MUTE, mute); 10208 } 10209 10210 static void alc268_dell_unsol_event(struct hda_codec *codec, 10211 unsigned int res) 10212 { 10213 if ((res >> 26) != ALC880_HP_EVENT) 10214 return; 10215 alc268_dell_automute(codec); 10216 } 10217 10218 #define alc268_dell_init_hook alc268_dell_automute 10219 10220 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = { 10221 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT), 10222 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 10223 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT), 10224 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 10225 HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT), 10226 HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT), 10227 HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT), 10228 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 10229 { } 10230 }; 10231 10232 static struct hda_verb alc267_quanta_il1_verbs[] = { 10233 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 10234 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, 10235 { } 10236 }; 10237 10238 static void alc267_quanta_il1_hp_automute(struct hda_codec *codec) 10239 { 10240 unsigned int present; 10241 10242 present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0) 10243 & AC_PINSENSE_PRESENCE; 10244 snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 10245 present ? 0 : PIN_OUT); 10246 } 10247 10248 static void alc267_quanta_il1_mic_automute(struct hda_codec *codec) 10249 { 10250 unsigned int present; 10251 10252 present = snd_hda_codec_read(codec, 0x18, 0, 10253 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 10254 snd_hda_codec_write(codec, 0x23, 0, 10255 AC_VERB_SET_CONNECT_SEL, 10256 present ? 0x00 : 0x01); 10257 } 10258 10259 static void alc267_quanta_il1_automute(struct hda_codec *codec) 10260 { 10261 alc267_quanta_il1_hp_automute(codec); 10262 alc267_quanta_il1_mic_automute(codec); 10263 } 10264 10265 static void alc267_quanta_il1_unsol_event(struct hda_codec *codec, 10266 unsigned int res) 10267 { 10268 switch (res >> 26) { 10269 case ALC880_HP_EVENT: 10270 alc267_quanta_il1_hp_automute(codec); 10271 break; 10272 case ALC880_MIC_EVENT: 10273 alc267_quanta_il1_mic_automute(codec); 10274 break; 10275 } 10276 } 10277 10278 /* 10279 * generic initialization of ADC, input mixers and output mixers 10280 */ 10281 static struct hda_verb alc268_base_init_verbs[] = { 10282 /* Unmute DAC0-1 and set vol = 0 */ 10283 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10284 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10285 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10286 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10287 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10288 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10289 10290 /* 10291 * Set up output mixers (0x0c - 0x0e) 10292 */ 10293 /* set vol=0 to output mixers */ 10294 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10295 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10296 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10297 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00}, 10298 10299 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10300 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10301 10302 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 10303 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 10304 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 10305 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 10306 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 10307 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 10308 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 10309 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 10310 10311 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10312 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10313 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10314 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10315 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10316 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10317 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10318 10319 /* set PCBEEP vol = 0, mute connections */ 10320 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10321 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 10322 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 10323 10324 /* Unmute Selector 23h,24h and set the default input to mic-in */ 10325 10326 {0x23, AC_VERB_SET_CONNECT_SEL, 0x00}, 10327 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 10328 {0x24, AC_VERB_SET_CONNECT_SEL, 0x00}, 10329 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 10330 10331 { } 10332 }; 10333 10334 /* 10335 * generic initialization of ADC, input mixers and output mixers 10336 */ 10337 static struct hda_verb alc268_volume_init_verbs[] = { 10338 /* set output DAC */ 10339 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10340 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10341 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10342 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10343 10344 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 10345 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 10346 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 10347 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 10348 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 10349 10350 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10351 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10352 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10353 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10354 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10355 10356 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10357 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10358 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10359 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10360 10361 /* set PCBEEP vol = 0, mute connections */ 10362 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10363 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 10364 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 10365 10366 { } 10367 }; 10368 10369 #define alc268_mux_enum_info alc_mux_enum_info 10370 #define alc268_mux_enum_get alc_mux_enum_get 10371 #define alc268_mux_enum_put alc_mux_enum_put 10372 10373 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = { 10374 HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT), 10375 HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT), 10376 { 10377 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 10378 /* The multiple "Capture Source" controls confuse alsamixer 10379 * So call somewhat different.. 10380 */ 10381 /* .name = "Capture Source", */ 10382 .name = "Input Source", 10383 .count = 1, 10384 .info = alc268_mux_enum_info, 10385 .get = alc268_mux_enum_get, 10386 .put = alc268_mux_enum_put, 10387 }, 10388 { } /* end */ 10389 }; 10390 10391 static struct snd_kcontrol_new alc268_capture_mixer[] = { 10392 HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT), 10393 HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT), 10394 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT), 10395 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT), 10396 { 10397 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 10398 /* The multiple "Capture Source" controls confuse alsamixer 10399 * So call somewhat different.. 10400 */ 10401 /* .name = "Capture Source", */ 10402 .name = "Input Source", 10403 .count = 2, 10404 .info = alc268_mux_enum_info, 10405 .get = alc268_mux_enum_get, 10406 .put = alc268_mux_enum_put, 10407 }, 10408 { } /* end */ 10409 }; 10410 10411 static struct hda_input_mux alc268_capture_source = { 10412 .num_items = 4, 10413 .items = { 10414 { "Mic", 0x0 }, 10415 { "Front Mic", 0x1 }, 10416 { "Line", 0x2 }, 10417 { "CD", 0x3 }, 10418 }, 10419 }; 10420 10421 static struct hda_input_mux alc268_acer_capture_source = { 10422 .num_items = 3, 10423 .items = { 10424 { "Mic", 0x0 }, 10425 { "Internal Mic", 0x6 }, 10426 { "Line", 0x2 }, 10427 }, 10428 }; 10429 10430 #ifdef CONFIG_SND_DEBUG 10431 static struct snd_kcontrol_new alc268_test_mixer[] = { 10432 /* Volume widgets */ 10433 HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT), 10434 HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT), 10435 HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT), 10436 HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT), 10437 HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT), 10438 HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT), 10439 HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT), 10440 HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT), 10441 HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT), 10442 HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT), 10443 HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT), 10444 HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT), 10445 HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT), 10446 /* The below appears problematic on some hardwares */ 10447 /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/ 10448 HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT), 10449 HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT), 10450 HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT), 10451 HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT), 10452 10453 /* Modes for retasking pin widgets */ 10454 ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT), 10455 ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT), 10456 ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT), 10457 ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT), 10458 10459 /* Controls for GPIO pins, assuming they are configured as outputs */ 10460 ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01), 10461 ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02), 10462 ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04), 10463 ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08), 10464 10465 /* Switches to allow the digital SPDIF output pin to be enabled. 10466 * The ALC268 does not have an SPDIF input. 10467 */ 10468 ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01), 10469 10470 /* A switch allowing EAPD to be enabled. Some laptops seem to use 10471 * this output to turn on an external amplifier. 10472 */ 10473 ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02), 10474 ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02), 10475 10476 { } /* end */ 10477 }; 10478 #endif 10479 10480 /* create input playback/capture controls for the given pin */ 10481 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid, 10482 const char *ctlname, int idx) 10483 { 10484 char name[32]; 10485 int err; 10486 10487 sprintf(name, "%s Playback Volume", ctlname); 10488 if (nid == 0x14) { 10489 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 10490 HDA_COMPOSE_AMP_VAL(0x02, 3, idx, 10491 HDA_OUTPUT)); 10492 if (err < 0) 10493 return err; 10494 } else if (nid == 0x15) { 10495 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 10496 HDA_COMPOSE_AMP_VAL(0x03, 3, idx, 10497 HDA_OUTPUT)); 10498 if (err < 0) 10499 return err; 10500 } else 10501 return -1; 10502 sprintf(name, "%s Playback Switch", ctlname); 10503 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 10504 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT)); 10505 if (err < 0) 10506 return err; 10507 return 0; 10508 } 10509 10510 /* add playback controls from the parsed DAC table */ 10511 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec, 10512 const struct auto_pin_cfg *cfg) 10513 { 10514 hda_nid_t nid; 10515 int err; 10516 10517 spec->multiout.num_dacs = 2; /* only use one dac */ 10518 spec->multiout.dac_nids = spec->private_dac_nids; 10519 spec->multiout.dac_nids[0] = 2; 10520 spec->multiout.dac_nids[1] = 3; 10521 10522 nid = cfg->line_out_pins[0]; 10523 if (nid) 10524 alc268_new_analog_output(spec, nid, "Front", 0); 10525 10526 nid = cfg->speaker_pins[0]; 10527 if (nid == 0x1d) { 10528 err = add_control(spec, ALC_CTL_WIDGET_VOL, 10529 "Speaker Playback Volume", 10530 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT)); 10531 if (err < 0) 10532 return err; 10533 } 10534 nid = cfg->hp_pins[0]; 10535 if (nid) 10536 alc268_new_analog_output(spec, nid, "Headphone", 0); 10537 10538 nid = cfg->line_out_pins[1] | cfg->line_out_pins[2]; 10539 if (nid == 0x16) { 10540 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 10541 "Mono Playback Switch", 10542 HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT)); 10543 if (err < 0) 10544 return err; 10545 } 10546 return 0; 10547 } 10548 10549 /* create playback/capture controls for input pins */ 10550 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec, 10551 const struct auto_pin_cfg *cfg) 10552 { 10553 struct hda_input_mux *imux = &spec->private_imux; 10554 int i, idx1; 10555 10556 for (i = 0; i < AUTO_PIN_LAST; i++) { 10557 switch(cfg->input_pins[i]) { 10558 case 0x18: 10559 idx1 = 0; /* Mic 1 */ 10560 break; 10561 case 0x19: 10562 idx1 = 1; /* Mic 2 */ 10563 break; 10564 case 0x1a: 10565 idx1 = 2; /* Line In */ 10566 break; 10567 case 0x1c: 10568 idx1 = 3; /* CD */ 10569 break; 10570 case 0x12: 10571 case 0x13: 10572 idx1 = 6; /* digital mics */ 10573 break; 10574 default: 10575 continue; 10576 } 10577 imux->items[imux->num_items].label = auto_pin_cfg_labels[i]; 10578 imux->items[imux->num_items].index = idx1; 10579 imux->num_items++; 10580 } 10581 return 0; 10582 } 10583 10584 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec) 10585 { 10586 struct alc_spec *spec = codec->spec; 10587 hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0]; 10588 hda_nid_t hp_nid = spec->autocfg.hp_pins[0]; 10589 hda_nid_t line_nid = spec->autocfg.line_out_pins[0]; 10590 unsigned int dac_vol1, dac_vol2; 10591 10592 if (speaker_nid) { 10593 snd_hda_codec_write(codec, speaker_nid, 0, 10594 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 10595 snd_hda_codec_write(codec, 0x0f, 0, 10596 AC_VERB_SET_AMP_GAIN_MUTE, 10597 AMP_IN_UNMUTE(1)); 10598 snd_hda_codec_write(codec, 0x10, 0, 10599 AC_VERB_SET_AMP_GAIN_MUTE, 10600 AMP_IN_UNMUTE(1)); 10601 } else { 10602 snd_hda_codec_write(codec, 0x0f, 0, 10603 AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)); 10604 snd_hda_codec_write(codec, 0x10, 0, 10605 AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)); 10606 } 10607 10608 dac_vol1 = dac_vol2 = 0xb000 | 0x40; /* set max volume */ 10609 if (line_nid == 0x14) 10610 dac_vol2 = AMP_OUT_ZERO; 10611 else if (line_nid == 0x15) 10612 dac_vol1 = AMP_OUT_ZERO; 10613 if (hp_nid == 0x14) 10614 dac_vol2 = AMP_OUT_ZERO; 10615 else if (hp_nid == 0x15) 10616 dac_vol1 = AMP_OUT_ZERO; 10617 if (line_nid != 0x16 || hp_nid != 0x16 || 10618 spec->autocfg.line_out_pins[1] != 0x16 || 10619 spec->autocfg.line_out_pins[2] != 0x16) 10620 dac_vol1 = dac_vol2 = AMP_OUT_ZERO; 10621 10622 snd_hda_codec_write(codec, 0x02, 0, 10623 AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1); 10624 snd_hda_codec_write(codec, 0x03, 0, 10625 AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2); 10626 } 10627 10628 /* pcm configuration: identiacal with ALC880 */ 10629 #define alc268_pcm_analog_playback alc880_pcm_analog_playback 10630 #define alc268_pcm_analog_capture alc880_pcm_analog_capture 10631 #define alc268_pcm_analog_alt_capture alc880_pcm_analog_alt_capture 10632 #define alc268_pcm_digital_playback alc880_pcm_digital_playback 10633 10634 /* 10635 * BIOS auto configuration 10636 */ 10637 static int alc268_parse_auto_config(struct hda_codec *codec) 10638 { 10639 struct alc_spec *spec = codec->spec; 10640 int err; 10641 static hda_nid_t alc268_ignore[] = { 0 }; 10642 10643 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 10644 alc268_ignore); 10645 if (err < 0) 10646 return err; 10647 if (!spec->autocfg.line_outs) 10648 return 0; /* can't find valid BIOS pin config */ 10649 10650 err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg); 10651 if (err < 0) 10652 return err; 10653 err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg); 10654 if (err < 0) 10655 return err; 10656 10657 spec->multiout.max_channels = 2; 10658 10659 /* digital only support output */ 10660 if (spec->autocfg.dig_out_pin) 10661 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID; 10662 10663 if (spec->kctl_alloc) 10664 spec->mixers[spec->num_mixers++] = spec->kctl_alloc; 10665 10666 if (spec->autocfg.speaker_pins[0] != 0x1d) 10667 spec->mixers[spec->num_mixers++] = alc268_beep_mixer; 10668 10669 spec->init_verbs[spec->num_init_verbs++] = alc268_volume_init_verbs; 10670 spec->num_mux_defs = 1; 10671 spec->input_mux = &spec->private_imux; 10672 10673 err = alc_auto_add_mic_boost(codec); 10674 if (err < 0) 10675 return err; 10676 10677 return 1; 10678 } 10679 10680 #define alc268_auto_init_multi_out alc882_auto_init_multi_out 10681 #define alc268_auto_init_hp_out alc882_auto_init_hp_out 10682 #define alc268_auto_init_analog_input alc882_auto_init_analog_input 10683 10684 /* init callback for auto-configuration model -- overriding the default init */ 10685 static void alc268_auto_init(struct hda_codec *codec) 10686 { 10687 struct alc_spec *spec = codec->spec; 10688 alc268_auto_init_multi_out(codec); 10689 alc268_auto_init_hp_out(codec); 10690 alc268_auto_init_mono_speaker_out(codec); 10691 alc268_auto_init_analog_input(codec); 10692 if (spec->unsol_event) 10693 alc_sku_automute(codec); 10694 } 10695 10696 /* 10697 * configuration and preset 10698 */ 10699 static const char *alc268_models[ALC268_MODEL_LAST] = { 10700 [ALC267_QUANTA_IL1] = "quanta-il1", 10701 [ALC268_3ST] = "3stack", 10702 [ALC268_TOSHIBA] = "toshiba", 10703 [ALC268_ACER] = "acer", 10704 [ALC268_DELL] = "dell", 10705 [ALC268_ZEPTO] = "zepto", 10706 #ifdef CONFIG_SND_DEBUG 10707 [ALC268_TEST] = "test", 10708 #endif 10709 [ALC268_AUTO] = "auto", 10710 }; 10711 10712 static struct snd_pci_quirk alc268_cfg_tbl[] = { 10713 SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER), 10714 SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER), 10715 SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER), 10716 SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER), 10717 SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER), 10718 SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL), 10719 SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA), 10720 SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST), 10721 SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA), 10722 SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA), 10723 SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA), 10724 SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER), 10725 SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1), 10726 SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO), 10727 {} 10728 }; 10729 10730 static struct alc_config_preset alc268_presets[] = { 10731 [ALC267_QUANTA_IL1] = { 10732 .mixers = { alc267_quanta_il1_mixer }, 10733 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 10734 alc267_quanta_il1_verbs }, 10735 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 10736 .dac_nids = alc268_dac_nids, 10737 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 10738 .adc_nids = alc268_adc_nids_alt, 10739 .hp_nid = 0x03, 10740 .num_channel_mode = ARRAY_SIZE(alc268_modes), 10741 .channel_mode = alc268_modes, 10742 .input_mux = &alc268_capture_source, 10743 .unsol_event = alc267_quanta_il1_unsol_event, 10744 .init_hook = alc267_quanta_il1_automute, 10745 }, 10746 [ALC268_3ST] = { 10747 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer, 10748 alc268_beep_mixer }, 10749 .init_verbs = { alc268_base_init_verbs }, 10750 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 10751 .dac_nids = alc268_dac_nids, 10752 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 10753 .adc_nids = alc268_adc_nids_alt, 10754 .capsrc_nids = alc268_capsrc_nids, 10755 .hp_nid = 0x03, 10756 .dig_out_nid = ALC268_DIGOUT_NID, 10757 .num_channel_mode = ARRAY_SIZE(alc268_modes), 10758 .channel_mode = alc268_modes, 10759 .input_mux = &alc268_capture_source, 10760 }, 10761 [ALC268_TOSHIBA] = { 10762 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer, 10763 alc268_beep_mixer }, 10764 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 10765 alc268_toshiba_verbs }, 10766 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 10767 .dac_nids = alc268_dac_nids, 10768 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 10769 .adc_nids = alc268_adc_nids_alt, 10770 .capsrc_nids = alc268_capsrc_nids, 10771 .hp_nid = 0x03, 10772 .num_channel_mode = ARRAY_SIZE(alc268_modes), 10773 .channel_mode = alc268_modes, 10774 .input_mux = &alc268_capture_source, 10775 .unsol_event = alc268_toshiba_unsol_event, 10776 .init_hook = alc268_toshiba_automute, 10777 }, 10778 [ALC268_ACER] = { 10779 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer, 10780 alc268_beep_mixer }, 10781 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 10782 alc268_acer_verbs }, 10783 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 10784 .dac_nids = alc268_dac_nids, 10785 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 10786 .adc_nids = alc268_adc_nids_alt, 10787 .capsrc_nids = alc268_capsrc_nids, 10788 .hp_nid = 0x02, 10789 .num_channel_mode = ARRAY_SIZE(alc268_modes), 10790 .channel_mode = alc268_modes, 10791 .input_mux = &alc268_acer_capture_source, 10792 .unsol_event = alc268_acer_unsol_event, 10793 .init_hook = alc268_acer_init_hook, 10794 }, 10795 [ALC268_DELL] = { 10796 .mixers = { alc268_dell_mixer, alc268_beep_mixer }, 10797 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 10798 alc268_dell_verbs }, 10799 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 10800 .dac_nids = alc268_dac_nids, 10801 .hp_nid = 0x02, 10802 .num_channel_mode = ARRAY_SIZE(alc268_modes), 10803 .channel_mode = alc268_modes, 10804 .unsol_event = alc268_dell_unsol_event, 10805 .init_hook = alc268_dell_init_hook, 10806 .input_mux = &alc268_capture_source, 10807 }, 10808 [ALC268_ZEPTO] = { 10809 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer, 10810 alc268_beep_mixer }, 10811 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 10812 alc268_toshiba_verbs }, 10813 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 10814 .dac_nids = alc268_dac_nids, 10815 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 10816 .adc_nids = alc268_adc_nids_alt, 10817 .capsrc_nids = alc268_capsrc_nids, 10818 .hp_nid = 0x03, 10819 .dig_out_nid = ALC268_DIGOUT_NID, 10820 .num_channel_mode = ARRAY_SIZE(alc268_modes), 10821 .channel_mode = alc268_modes, 10822 .input_mux = &alc268_capture_source, 10823 .unsol_event = alc268_toshiba_unsol_event, 10824 .init_hook = alc268_toshiba_automute 10825 }, 10826 #ifdef CONFIG_SND_DEBUG 10827 [ALC268_TEST] = { 10828 .mixers = { alc268_test_mixer, alc268_capture_mixer }, 10829 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 10830 alc268_volume_init_verbs }, 10831 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 10832 .dac_nids = alc268_dac_nids, 10833 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 10834 .adc_nids = alc268_adc_nids_alt, 10835 .capsrc_nids = alc268_capsrc_nids, 10836 .hp_nid = 0x03, 10837 .dig_out_nid = ALC268_DIGOUT_NID, 10838 .num_channel_mode = ARRAY_SIZE(alc268_modes), 10839 .channel_mode = alc268_modes, 10840 .input_mux = &alc268_capture_source, 10841 }, 10842 #endif 10843 }; 10844 10845 static int patch_alc268(struct hda_codec *codec) 10846 { 10847 struct alc_spec *spec; 10848 int board_config; 10849 int err; 10850 10851 spec = kcalloc(1, sizeof(*spec), GFP_KERNEL); 10852 if (spec == NULL) 10853 return -ENOMEM; 10854 10855 codec->spec = spec; 10856 10857 board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST, 10858 alc268_models, 10859 alc268_cfg_tbl); 10860 10861 if (board_config < 0 || board_config >= ALC268_MODEL_LAST) { 10862 printk(KERN_INFO "hda_codec: Unknown model for ALC268, " 10863 "trying auto-probe from BIOS...\n"); 10864 board_config = ALC268_AUTO; 10865 } 10866 10867 if (board_config == ALC268_AUTO) { 10868 /* automatic parse from the BIOS config */ 10869 err = alc268_parse_auto_config(codec); 10870 if (err < 0) { 10871 alc_free(codec); 10872 return err; 10873 } else if (!err) { 10874 printk(KERN_INFO 10875 "hda_codec: Cannot set up configuration " 10876 "from BIOS. Using base mode...\n"); 10877 board_config = ALC268_3ST; 10878 } 10879 } 10880 10881 if (board_config != ALC268_AUTO) 10882 setup_preset(spec, &alc268_presets[board_config]); 10883 10884 if (codec->vendor_id == 0x10ec0267) { 10885 spec->stream_name_analog = "ALC267 Analog"; 10886 spec->stream_name_digital = "ALC267 Digital"; 10887 } else { 10888 spec->stream_name_analog = "ALC268 Analog"; 10889 spec->stream_name_digital = "ALC268 Digital"; 10890 } 10891 10892 spec->stream_analog_playback = &alc268_pcm_analog_playback; 10893 spec->stream_analog_capture = &alc268_pcm_analog_capture; 10894 spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture; 10895 10896 spec->stream_digital_playback = &alc268_pcm_digital_playback; 10897 10898 if (!query_amp_caps(codec, 0x1d, HDA_INPUT)) 10899 /* override the amp caps for beep generator */ 10900 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT, 10901 (0x0c << AC_AMPCAP_OFFSET_SHIFT) | 10902 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) | 10903 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) | 10904 (0 << AC_AMPCAP_MUTE_SHIFT)); 10905 10906 if (!spec->adc_nids && spec->input_mux) { 10907 /* check whether NID 0x07 is valid */ 10908 unsigned int wcap = get_wcaps(codec, 0x07); 10909 int i; 10910 10911 /* get type */ 10912 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 10913 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) { 10914 spec->adc_nids = alc268_adc_nids_alt; 10915 spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt); 10916 spec->mixers[spec->num_mixers] = 10917 alc268_capture_alt_mixer; 10918 spec->num_mixers++; 10919 } else { 10920 spec->adc_nids = alc268_adc_nids; 10921 spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids); 10922 spec->mixers[spec->num_mixers] = 10923 alc268_capture_mixer; 10924 spec->num_mixers++; 10925 } 10926 spec->capsrc_nids = alc268_capsrc_nids; 10927 /* set default input source */ 10928 for (i = 0; i < spec->num_adc_nids; i++) 10929 snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i], 10930 0, AC_VERB_SET_CONNECT_SEL, 10931 spec->input_mux->items[0].index); 10932 } 10933 10934 spec->vmaster_nid = 0x02; 10935 10936 codec->patch_ops = alc_patch_ops; 10937 if (board_config == ALC268_AUTO) 10938 spec->init_hook = alc268_auto_init; 10939 10940 return 0; 10941 } 10942 10943 /* 10944 * ALC269 channel source setting (2 channel) 10945 */ 10946 #define ALC269_DIGOUT_NID ALC880_DIGOUT_NID 10947 10948 #define alc269_dac_nids alc260_dac_nids 10949 10950 static hda_nid_t alc269_adc_nids[1] = { 10951 /* ADC1 */ 10952 0x08, 10953 }; 10954 10955 static struct hda_input_mux alc269_eeepc_dmic_capture_source = { 10956 .num_items = 2, 10957 .items = { 10958 { "i-Mic", 0x5 }, 10959 { "e-Mic", 0x0 }, 10960 }, 10961 }; 10962 10963 static struct hda_input_mux alc269_eeepc_amic_capture_source = { 10964 .num_items = 2, 10965 .items = { 10966 { "i-Mic", 0x1 }, 10967 { "e-Mic", 0x0 }, 10968 }, 10969 }; 10970 10971 #define alc269_modes alc260_modes 10972 #define alc269_capture_source alc880_lg_lw_capture_source 10973 10974 static struct snd_kcontrol_new alc269_base_mixer[] = { 10975 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 10976 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 10977 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 10978 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 10979 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 10980 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 10981 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 10982 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 10983 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 10984 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 10985 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 10986 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT), 10987 { } /* end */ 10988 }; 10989 10990 /* bind volumes of both NID 0x0c and 0x0d */ 10991 static struct hda_bind_ctls alc269_epc_bind_vol = { 10992 .ops = &snd_hda_bind_vol, 10993 .values = { 10994 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT), 10995 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT), 10996 0 10997 }, 10998 }; 10999 11000 static struct snd_kcontrol_new alc269_eeepc_mixer[] = { 11001 HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 11002 HDA_BIND_VOL("LineOut Playback Volume", &alc269_epc_bind_vol), 11003 HDA_CODEC_MUTE("LineOut Playback Switch", 0x15, 0x0, HDA_OUTPUT), 11004 { } /* end */ 11005 }; 11006 11007 /* capture mixer elements */ 11008 static struct snd_kcontrol_new alc269_capture_mixer[] = { 11009 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 11010 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 11011 { 11012 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11013 /* The multiple "Capture Source" controls confuse alsamixer 11014 * So call somewhat different.. 11015 */ 11016 /* .name = "Capture Source", */ 11017 .name = "Input Source", 11018 .count = 1, 11019 .info = alc_mux_enum_info, 11020 .get = alc_mux_enum_get, 11021 .put = alc_mux_enum_put, 11022 }, 11023 { } /* end */ 11024 }; 11025 11026 /* capture mixer elements */ 11027 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = { 11028 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 11029 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 11030 { } /* end */ 11031 }; 11032 11033 /* 11034 * generic initialization of ADC, input mixers and output mixers 11035 */ 11036 static struct hda_verb alc269_init_verbs[] = { 11037 /* 11038 * Unmute ADC0 and set the default input to mic-in 11039 */ 11040 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11041 11042 /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the 11043 * analog-loopback mixer widget 11044 * Note: PASD motherboards uses the Line In 2 as the input for 11045 * front panel mic (mic 2) 11046 */ 11047 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 11048 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 11049 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 11050 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 11051 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 11052 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 11053 11054 /* 11055 * Set up output mixers (0x0c - 0x0e) 11056 */ 11057 /* set vol=0 to output mixers */ 11058 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 11059 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 11060 11061 /* set up input amps for analog loopback */ 11062 /* Amp Indices: DAC = 0, mixer = 1 */ 11063 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11064 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11065 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11066 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11067 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11068 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11069 11070 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 11071 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 11072 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 11073 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 11074 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 11075 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 11076 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 11077 11078 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11079 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11080 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11081 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11082 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11083 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11084 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11085 11086 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 11087 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 11088 11089 /* FIXME: use matrix-type input source selection */ 11090 /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */ 11091 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 11092 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11093 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 11094 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 11095 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 11096 11097 /* set EAPD */ 11098 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 11099 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 11100 { } 11101 }; 11102 11103 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = { 11104 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 11105 {0x23, AC_VERB_SET_CONNECT_SEL, 0x05}, 11106 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 }, 11107 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))}, 11108 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 11109 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 11110 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 11111 {} 11112 }; 11113 11114 static struct hda_verb alc269_eeepc_amic_init_verbs[] = { 11115 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 11116 {0x23, AC_VERB_SET_CONNECT_SEL, 0x01}, 11117 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 }, 11118 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))}, 11119 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 11120 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 11121 {} 11122 }; 11123 11124 /* toggle speaker-output according to the hp-jack state */ 11125 static void alc269_speaker_automute(struct hda_codec *codec) 11126 { 11127 unsigned int present; 11128 unsigned int bits; 11129 11130 present = snd_hda_codec_read(codec, 0x15, 0, 11131 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 11132 bits = present ? AMP_IN_MUTE(0) : 0; 11133 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 11134 AMP_IN_MUTE(0), bits); 11135 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 11136 AMP_IN_MUTE(0), bits); 11137 } 11138 11139 static void alc269_eeepc_dmic_automute(struct hda_codec *codec) 11140 { 11141 unsigned int present; 11142 11143 present = snd_hda_codec_read(codec, 0x18, 0, AC_VERB_GET_PIN_SENSE, 0) 11144 & AC_PINSENSE_PRESENCE; 11145 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL, 11146 present ? 0 : 5); 11147 } 11148 11149 static void alc269_eeepc_amic_automute(struct hda_codec *codec) 11150 { 11151 unsigned int present; 11152 11153 present = snd_hda_codec_read(codec, 0x18, 0, AC_VERB_GET_PIN_SENSE, 0) 11154 & AC_PINSENSE_PRESENCE; 11155 snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE, 11156 present ? AMP_IN_UNMUTE(0) : AMP_IN_MUTE(0)); 11157 snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE, 11158 present ? AMP_IN_MUTE(1) : AMP_IN_UNMUTE(1)); 11159 } 11160 11161 /* unsolicited event for HP jack sensing */ 11162 static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec, 11163 unsigned int res) 11164 { 11165 if ((res >> 26) == ALC880_HP_EVENT) 11166 alc269_speaker_automute(codec); 11167 11168 if ((res >> 26) == ALC880_MIC_EVENT) 11169 alc269_eeepc_dmic_automute(codec); 11170 } 11171 11172 static void alc269_eeepc_dmic_inithook(struct hda_codec *codec) 11173 { 11174 alc269_speaker_automute(codec); 11175 alc269_eeepc_dmic_automute(codec); 11176 } 11177 11178 /* unsolicited event for HP jack sensing */ 11179 static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec, 11180 unsigned int res) 11181 { 11182 if ((res >> 26) == ALC880_HP_EVENT) 11183 alc269_speaker_automute(codec); 11184 11185 if ((res >> 26) == ALC880_MIC_EVENT) 11186 alc269_eeepc_amic_automute(codec); 11187 } 11188 11189 static void alc269_eeepc_amic_inithook(struct hda_codec *codec) 11190 { 11191 alc269_speaker_automute(codec); 11192 alc269_eeepc_amic_automute(codec); 11193 } 11194 11195 /* add playback controls from the parsed DAC table */ 11196 static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec, 11197 const struct auto_pin_cfg *cfg) 11198 { 11199 hda_nid_t nid; 11200 int err; 11201 11202 spec->multiout.num_dacs = 1; /* only use one dac */ 11203 spec->multiout.dac_nids = spec->private_dac_nids; 11204 spec->multiout.dac_nids[0] = 2; 11205 11206 nid = cfg->line_out_pins[0]; 11207 if (nid) { 11208 err = add_control(spec, ALC_CTL_WIDGET_VOL, 11209 "Front Playback Volume", 11210 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT)); 11211 if (err < 0) 11212 return err; 11213 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 11214 "Front Playback Switch", 11215 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 11216 if (err < 0) 11217 return err; 11218 } 11219 11220 nid = cfg->speaker_pins[0]; 11221 if (nid) { 11222 if (!cfg->line_out_pins[0]) { 11223 err = add_control(spec, ALC_CTL_WIDGET_VOL, 11224 "Speaker Playback Volume", 11225 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, 11226 HDA_OUTPUT)); 11227 if (err < 0) 11228 return err; 11229 } 11230 if (nid == 0x16) { 11231 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 11232 "Speaker Playback Switch", 11233 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 11234 HDA_OUTPUT)); 11235 if (err < 0) 11236 return err; 11237 } else { 11238 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 11239 "Speaker Playback Switch", 11240 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 11241 HDA_OUTPUT)); 11242 if (err < 0) 11243 return err; 11244 } 11245 } 11246 nid = cfg->hp_pins[0]; 11247 if (nid) { 11248 /* spec->multiout.hp_nid = 2; */ 11249 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) { 11250 err = add_control(spec, ALC_CTL_WIDGET_VOL, 11251 "Headphone Playback Volume", 11252 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, 11253 HDA_OUTPUT)); 11254 if (err < 0) 11255 return err; 11256 } 11257 if (nid == 0x16) { 11258 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 11259 "Headphone Playback Switch", 11260 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 11261 HDA_OUTPUT)); 11262 if (err < 0) 11263 return err; 11264 } else { 11265 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 11266 "Headphone Playback Switch", 11267 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 11268 HDA_OUTPUT)); 11269 if (err < 0) 11270 return err; 11271 } 11272 } 11273 return 0; 11274 } 11275 11276 #define alc269_auto_create_analog_input_ctls \ 11277 alc880_auto_create_analog_input_ctls 11278 11279 #ifdef CONFIG_SND_HDA_POWER_SAVE 11280 #define alc269_loopbacks alc880_loopbacks 11281 #endif 11282 11283 /* pcm configuration: identiacal with ALC880 */ 11284 #define alc269_pcm_analog_playback alc880_pcm_analog_playback 11285 #define alc269_pcm_analog_capture alc880_pcm_analog_capture 11286 #define alc269_pcm_digital_playback alc880_pcm_digital_playback 11287 #define alc269_pcm_digital_capture alc880_pcm_digital_capture 11288 11289 /* 11290 * BIOS auto configuration 11291 */ 11292 static int alc269_parse_auto_config(struct hda_codec *codec) 11293 { 11294 struct alc_spec *spec = codec->spec; 11295 int err; 11296 static hda_nid_t alc269_ignore[] = { 0x1d, 0 }; 11297 11298 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 11299 alc269_ignore); 11300 if (err < 0) 11301 return err; 11302 11303 err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg); 11304 if (err < 0) 11305 return err; 11306 err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg); 11307 if (err < 0) 11308 return err; 11309 11310 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 11311 11312 if (spec->autocfg.dig_out_pin) 11313 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID; 11314 11315 if (spec->kctl_alloc) 11316 spec->mixers[spec->num_mixers++] = spec->kctl_alloc; 11317 11318 spec->init_verbs[spec->num_init_verbs++] = alc269_init_verbs; 11319 spec->num_mux_defs = 1; 11320 spec->input_mux = &spec->private_imux; 11321 11322 err = alc_auto_add_mic_boost(codec); 11323 if (err < 0) 11324 return err; 11325 11326 spec->mixers[spec->num_mixers] = alc269_capture_mixer; 11327 spec->num_mixers++; 11328 11329 return 1; 11330 } 11331 11332 #define alc269_auto_init_multi_out alc882_auto_init_multi_out 11333 #define alc269_auto_init_hp_out alc882_auto_init_hp_out 11334 #define alc269_auto_init_analog_input alc882_auto_init_analog_input 11335 11336 11337 /* init callback for auto-configuration model -- overriding the default init */ 11338 static void alc269_auto_init(struct hda_codec *codec) 11339 { 11340 struct alc_spec *spec = codec->spec; 11341 alc269_auto_init_multi_out(codec); 11342 alc269_auto_init_hp_out(codec); 11343 alc269_auto_init_analog_input(codec); 11344 if (spec->unsol_event) 11345 alc_sku_automute(codec); 11346 } 11347 11348 /* 11349 * configuration and preset 11350 */ 11351 static const char *alc269_models[ALC269_MODEL_LAST] = { 11352 [ALC269_BASIC] = "basic", 11353 }; 11354 11355 static struct snd_pci_quirk alc269_cfg_tbl[] = { 11356 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A", 11357 ALC269_ASUS_EEEPC_P703), 11358 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901", 11359 ALC269_ASUS_EEEPC_P901), 11360 {} 11361 }; 11362 11363 static struct alc_config_preset alc269_presets[] = { 11364 [ALC269_BASIC] = { 11365 .mixers = { alc269_base_mixer, alc269_capture_mixer }, 11366 .init_verbs = { alc269_init_verbs }, 11367 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 11368 .dac_nids = alc269_dac_nids, 11369 .hp_nid = 0x03, 11370 .num_channel_mode = ARRAY_SIZE(alc269_modes), 11371 .channel_mode = alc269_modes, 11372 .input_mux = &alc269_capture_source, 11373 }, 11374 [ALC269_ASUS_EEEPC_P703] = { 11375 .mixers = { alc269_eeepc_mixer, alc269_epc_capture_mixer }, 11376 .init_verbs = { alc269_init_verbs, 11377 alc269_eeepc_amic_init_verbs }, 11378 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 11379 .dac_nids = alc269_dac_nids, 11380 .hp_nid = 0x03, 11381 .num_channel_mode = ARRAY_SIZE(alc269_modes), 11382 .channel_mode = alc269_modes, 11383 .input_mux = &alc269_eeepc_amic_capture_source, 11384 .unsol_event = alc269_eeepc_amic_unsol_event, 11385 .init_hook = alc269_eeepc_amic_inithook, 11386 }, 11387 [ALC269_ASUS_EEEPC_P901] = { 11388 .mixers = { alc269_eeepc_mixer, alc269_epc_capture_mixer}, 11389 .init_verbs = { alc269_init_verbs, 11390 alc269_eeepc_dmic_init_verbs }, 11391 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 11392 .dac_nids = alc269_dac_nids, 11393 .hp_nid = 0x03, 11394 .num_channel_mode = ARRAY_SIZE(alc269_modes), 11395 .channel_mode = alc269_modes, 11396 .input_mux = &alc269_eeepc_dmic_capture_source, 11397 .unsol_event = alc269_eeepc_dmic_unsol_event, 11398 .init_hook = alc269_eeepc_dmic_inithook, 11399 }, 11400 }; 11401 11402 static int patch_alc269(struct hda_codec *codec) 11403 { 11404 struct alc_spec *spec; 11405 int board_config; 11406 int err; 11407 11408 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 11409 if (spec == NULL) 11410 return -ENOMEM; 11411 11412 codec->spec = spec; 11413 11414 alc_fix_pll_init(codec, 0x20, 0x04, 15); 11415 11416 board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST, 11417 alc269_models, 11418 alc269_cfg_tbl); 11419 11420 if (board_config < 0) { 11421 printk(KERN_INFO "hda_codec: Unknown model for ALC269, " 11422 "trying auto-probe from BIOS...\n"); 11423 board_config = ALC269_AUTO; 11424 } 11425 11426 if (board_config == ALC269_AUTO) { 11427 /* automatic parse from the BIOS config */ 11428 err = alc269_parse_auto_config(codec); 11429 if (err < 0) { 11430 alc_free(codec); 11431 return err; 11432 } else if (!err) { 11433 printk(KERN_INFO 11434 "hda_codec: Cannot set up configuration " 11435 "from BIOS. Using base mode...\n"); 11436 board_config = ALC269_BASIC; 11437 } 11438 } 11439 11440 if (board_config != ALC269_AUTO) 11441 setup_preset(spec, &alc269_presets[board_config]); 11442 11443 spec->stream_name_analog = "ALC269 Analog"; 11444 spec->stream_analog_playback = &alc269_pcm_analog_playback; 11445 spec->stream_analog_capture = &alc269_pcm_analog_capture; 11446 11447 spec->stream_name_digital = "ALC269 Digital"; 11448 spec->stream_digital_playback = &alc269_pcm_digital_playback; 11449 spec->stream_digital_capture = &alc269_pcm_digital_capture; 11450 11451 spec->adc_nids = alc269_adc_nids; 11452 spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids); 11453 11454 codec->patch_ops = alc_patch_ops; 11455 if (board_config == ALC269_AUTO) 11456 spec->init_hook = alc269_auto_init; 11457 #ifdef CONFIG_SND_HDA_POWER_SAVE 11458 if (!spec->loopback.amplist) 11459 spec->loopback.amplist = alc269_loopbacks; 11460 #endif 11461 11462 return 0; 11463 } 11464 11465 /* 11466 * ALC861 channel source setting (2/6 channel selection for 3-stack) 11467 */ 11468 11469 /* 11470 * set the path ways for 2 channel output 11471 * need to set the codec line out and mic 1 pin widgets to inputs 11472 */ 11473 static struct hda_verb alc861_threestack_ch2_init[] = { 11474 /* set pin widget 1Ah (line in) for input */ 11475 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 11476 /* set pin widget 18h (mic1/2) for input, for mic also enable 11477 * the vref 11478 */ 11479 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 11480 11481 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c }, 11482 #if 0 11483 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/ 11484 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/ 11485 #endif 11486 { } /* end */ 11487 }; 11488 /* 11489 * 6ch mode 11490 * need to set the codec line out and mic 1 pin widgets to outputs 11491 */ 11492 static struct hda_verb alc861_threestack_ch6_init[] = { 11493 /* set pin widget 1Ah (line in) for output (Back Surround)*/ 11494 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 11495 /* set pin widget 18h (mic1) for output (CLFE)*/ 11496 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 11497 11498 { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 }, 11499 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 }, 11500 11501 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 }, 11502 #if 0 11503 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/ 11504 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/ 11505 #endif 11506 { } /* end */ 11507 }; 11508 11509 static struct hda_channel_mode alc861_threestack_modes[2] = { 11510 { 2, alc861_threestack_ch2_init }, 11511 { 6, alc861_threestack_ch6_init }, 11512 }; 11513 /* Set mic1 as input and unmute the mixer */ 11514 static struct hda_verb alc861_uniwill_m31_ch2_init[] = { 11515 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 11516 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/ 11517 { } /* end */ 11518 }; 11519 /* Set mic1 as output and mute mixer */ 11520 static struct hda_verb alc861_uniwill_m31_ch4_init[] = { 11521 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 11522 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/ 11523 { } /* end */ 11524 }; 11525 11526 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = { 11527 { 2, alc861_uniwill_m31_ch2_init }, 11528 { 4, alc861_uniwill_m31_ch4_init }, 11529 }; 11530 11531 /* Set mic1 and line-in as input and unmute the mixer */ 11532 static struct hda_verb alc861_asus_ch2_init[] = { 11533 /* set pin widget 1Ah (line in) for input */ 11534 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 11535 /* set pin widget 18h (mic1/2) for input, for mic also enable 11536 * the vref 11537 */ 11538 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 11539 11540 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c }, 11541 #if 0 11542 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/ 11543 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/ 11544 #endif 11545 { } /* end */ 11546 }; 11547 /* Set mic1 nad line-in as output and mute mixer */ 11548 static struct hda_verb alc861_asus_ch6_init[] = { 11549 /* set pin widget 1Ah (line in) for output (Back Surround)*/ 11550 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 11551 /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */ 11552 /* set pin widget 18h (mic1) for output (CLFE)*/ 11553 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 11554 /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */ 11555 { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 }, 11556 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 }, 11557 11558 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 }, 11559 #if 0 11560 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/ 11561 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/ 11562 #endif 11563 { } /* end */ 11564 }; 11565 11566 static struct hda_channel_mode alc861_asus_modes[2] = { 11567 { 2, alc861_asus_ch2_init }, 11568 { 6, alc861_asus_ch6_init }, 11569 }; 11570 11571 /* patch-ALC861 */ 11572 11573 static struct snd_kcontrol_new alc861_base_mixer[] = { 11574 /* output mixer control */ 11575 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT), 11576 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT), 11577 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT), 11578 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT), 11579 HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), 11580 11581 /*Input mixer control */ 11582 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT), 11583 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */ 11584 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 11585 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 11586 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT), 11587 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT), 11588 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 11589 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 11590 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT), 11591 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT), 11592 11593 /* Capture mixer control */ 11594 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 11595 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 11596 { 11597 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11598 .name = "Capture Source", 11599 .count = 1, 11600 .info = alc_mux_enum_info, 11601 .get = alc_mux_enum_get, 11602 .put = alc_mux_enum_put, 11603 }, 11604 { } /* end */ 11605 }; 11606 11607 static struct snd_kcontrol_new alc861_3ST_mixer[] = { 11608 /* output mixer control */ 11609 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT), 11610 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT), 11611 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT), 11612 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT), 11613 /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */ 11614 11615 /* Input mixer control */ 11616 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT), 11617 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */ 11618 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 11619 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 11620 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT), 11621 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT), 11622 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 11623 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 11624 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT), 11625 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT), 11626 11627 /* Capture mixer control */ 11628 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 11629 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 11630 { 11631 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11632 .name = "Capture Source", 11633 .count = 1, 11634 .info = alc_mux_enum_info, 11635 .get = alc_mux_enum_get, 11636 .put = alc_mux_enum_put, 11637 }, 11638 { 11639 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11640 .name = "Channel Mode", 11641 .info = alc_ch_mode_info, 11642 .get = alc_ch_mode_get, 11643 .put = alc_ch_mode_put, 11644 .private_value = ARRAY_SIZE(alc861_threestack_modes), 11645 }, 11646 { } /* end */ 11647 }; 11648 11649 static struct snd_kcontrol_new alc861_toshiba_mixer[] = { 11650 /* output mixer control */ 11651 HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT), 11652 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 11653 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 11654 11655 /*Capture mixer control */ 11656 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 11657 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 11658 { 11659 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11660 .name = "Capture Source", 11661 .count = 1, 11662 .info = alc_mux_enum_info, 11663 .get = alc_mux_enum_get, 11664 .put = alc_mux_enum_put, 11665 }, 11666 11667 { } /* end */ 11668 }; 11669 11670 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = { 11671 /* output mixer control */ 11672 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT), 11673 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT), 11674 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT), 11675 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT), 11676 /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */ 11677 11678 /* Input mixer control */ 11679 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT), 11680 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */ 11681 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 11682 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 11683 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT), 11684 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT), 11685 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 11686 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 11687 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT), 11688 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT), 11689 11690 /* Capture mixer control */ 11691 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 11692 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 11693 { 11694 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11695 .name = "Capture Source", 11696 .count = 1, 11697 .info = alc_mux_enum_info, 11698 .get = alc_mux_enum_get, 11699 .put = alc_mux_enum_put, 11700 }, 11701 { 11702 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11703 .name = "Channel Mode", 11704 .info = alc_ch_mode_info, 11705 .get = alc_ch_mode_get, 11706 .put = alc_ch_mode_put, 11707 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes), 11708 }, 11709 { } /* end */ 11710 }; 11711 11712 static struct snd_kcontrol_new alc861_asus_mixer[] = { 11713 /* output mixer control */ 11714 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT), 11715 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT), 11716 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT), 11717 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT), 11718 HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), 11719 11720 /* Input mixer control */ 11721 HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT), 11722 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), 11723 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 11724 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 11725 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT), 11726 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT), 11727 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 11728 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 11729 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT), 11730 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT), 11731 11732 /* Capture mixer control */ 11733 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 11734 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 11735 { 11736 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11737 .name = "Capture Source", 11738 .count = 1, 11739 .info = alc_mux_enum_info, 11740 .get = alc_mux_enum_get, 11741 .put = alc_mux_enum_put, 11742 }, 11743 { 11744 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11745 .name = "Channel Mode", 11746 .info = alc_ch_mode_info, 11747 .get = alc_ch_mode_get, 11748 .put = alc_ch_mode_put, 11749 .private_value = ARRAY_SIZE(alc861_asus_modes), 11750 }, 11751 { } 11752 }; 11753 11754 /* additional mixer */ 11755 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = { 11756 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 11757 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 11758 HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x23, 0x0, HDA_OUTPUT), 11759 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x23, 0x0, HDA_OUTPUT), 11760 { } 11761 }; 11762 11763 /* 11764 * generic initialization of ADC, input mixers and output mixers 11765 */ 11766 static struct hda_verb alc861_base_init_verbs[] = { 11767 /* 11768 * Unmute ADC0 and set the default input to mic-in 11769 */ 11770 /* port-A for surround (rear panel) */ 11771 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 11772 { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 }, 11773 /* port-B for mic-in (rear panel) with vref */ 11774 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 11775 /* port-C for line-in (rear panel) */ 11776 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 11777 /* port-D for Front */ 11778 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 11779 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 }, 11780 /* port-E for HP out (front panel) */ 11781 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 11782 /* route front PCM to HP */ 11783 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 11784 /* port-F for mic-in (front panel) with vref */ 11785 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 11786 /* port-G for CLFE (rear panel) */ 11787 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 11788 { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 11789 /* port-H for side (rear panel) */ 11790 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 11791 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 }, 11792 /* CD-in */ 11793 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 11794 /* route front mic to ADC1*/ 11795 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 11796 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11797 11798 /* Unmute DAC0~3 & spdif out*/ 11799 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11800 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11801 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11802 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11803 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11804 11805 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 11806 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11807 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11808 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11809 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11810 11811 /* Unmute Stereo Mixer 15 */ 11812 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11813 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11814 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 11815 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */ 11816 11817 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11818 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11819 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11820 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11821 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11822 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11823 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11824 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11825 /* hp used DAC 3 (Front) */ 11826 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 11827 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 11828 11829 { } 11830 }; 11831 11832 static struct hda_verb alc861_threestack_init_verbs[] = { 11833 /* 11834 * Unmute ADC0 and set the default input to mic-in 11835 */ 11836 /* port-A for surround (rear panel) */ 11837 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 11838 /* port-B for mic-in (rear panel) with vref */ 11839 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 11840 /* port-C for line-in (rear panel) */ 11841 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 11842 /* port-D for Front */ 11843 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 11844 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 }, 11845 /* port-E for HP out (front panel) */ 11846 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 11847 /* route front PCM to HP */ 11848 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 11849 /* port-F for mic-in (front panel) with vref */ 11850 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 11851 /* port-G for CLFE (rear panel) */ 11852 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 11853 /* port-H for side (rear panel) */ 11854 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 11855 /* CD-in */ 11856 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 11857 /* route front mic to ADC1*/ 11858 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 11859 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11860 /* Unmute DAC0~3 & spdif out*/ 11861 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11862 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11863 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11864 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11865 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11866 11867 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 11868 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11869 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11870 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11871 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11872 11873 /* Unmute Stereo Mixer 15 */ 11874 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11875 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11876 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 11877 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */ 11878 11879 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11880 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11881 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11882 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11883 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11884 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11885 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11886 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11887 /* hp used DAC 3 (Front) */ 11888 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 11889 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 11890 { } 11891 }; 11892 11893 static struct hda_verb alc861_uniwill_m31_init_verbs[] = { 11894 /* 11895 * Unmute ADC0 and set the default input to mic-in 11896 */ 11897 /* port-A for surround (rear panel) */ 11898 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 11899 /* port-B for mic-in (rear panel) with vref */ 11900 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 11901 /* port-C for line-in (rear panel) */ 11902 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 11903 /* port-D for Front */ 11904 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 11905 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 }, 11906 /* port-E for HP out (front panel) */ 11907 /* this has to be set to VREF80 */ 11908 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 11909 /* route front PCM to HP */ 11910 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 11911 /* port-F for mic-in (front panel) with vref */ 11912 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 11913 /* port-G for CLFE (rear panel) */ 11914 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 11915 /* port-H for side (rear panel) */ 11916 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 11917 /* CD-in */ 11918 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 11919 /* route front mic to ADC1*/ 11920 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 11921 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11922 /* Unmute DAC0~3 & spdif out*/ 11923 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11924 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11925 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11926 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11927 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11928 11929 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 11930 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11931 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11932 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11933 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11934 11935 /* Unmute Stereo Mixer 15 */ 11936 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11937 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11938 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 11939 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */ 11940 11941 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11942 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11943 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11944 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11945 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11946 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11947 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11948 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11949 /* hp used DAC 3 (Front) */ 11950 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 11951 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 11952 { } 11953 }; 11954 11955 static struct hda_verb alc861_asus_init_verbs[] = { 11956 /* 11957 * Unmute ADC0 and set the default input to mic-in 11958 */ 11959 /* port-A for surround (rear panel) 11960 * according to codec#0 this is the HP jack 11961 */ 11962 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */ 11963 /* route front PCM to HP */ 11964 { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 }, 11965 /* port-B for mic-in (rear panel) with vref */ 11966 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 11967 /* port-C for line-in (rear panel) */ 11968 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 11969 /* port-D for Front */ 11970 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 11971 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 }, 11972 /* port-E for HP out (front panel) */ 11973 /* this has to be set to VREF80 */ 11974 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 11975 /* route front PCM to HP */ 11976 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 11977 /* port-F for mic-in (front panel) with vref */ 11978 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 11979 /* port-G for CLFE (rear panel) */ 11980 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 11981 /* port-H for side (rear panel) */ 11982 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 11983 /* CD-in */ 11984 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 11985 /* route front mic to ADC1*/ 11986 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 11987 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11988 /* Unmute DAC0~3 & spdif out*/ 11989 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11990 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11991 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11992 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11993 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11994 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 11995 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11996 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11997 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11998 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11999 12000 /* Unmute Stereo Mixer 15 */ 12001 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12002 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12003 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 12004 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */ 12005 12006 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12007 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12008 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12009 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12010 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12011 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12012 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12013 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12014 /* hp used DAC 3 (Front) */ 12015 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 12016 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 12017 { } 12018 }; 12019 12020 /* additional init verbs for ASUS laptops */ 12021 static struct hda_verb alc861_asus_laptop_init_verbs[] = { 12022 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */ 12023 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */ 12024 { } 12025 }; 12026 12027 /* 12028 * generic initialization of ADC, input mixers and output mixers 12029 */ 12030 static struct hda_verb alc861_auto_init_verbs[] = { 12031 /* 12032 * Unmute ADC0 and set the default input to mic-in 12033 */ 12034 /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */ 12035 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12036 12037 /* Unmute DAC0~3 & spdif out*/ 12038 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12039 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12040 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12041 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12042 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12043 12044 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 12045 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12046 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12047 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12048 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12049 12050 /* Unmute Stereo Mixer 15 */ 12051 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12052 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12053 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 12054 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, 12055 12056 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12057 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12058 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12059 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12060 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12061 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12062 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12063 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12064 12065 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 12066 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 12067 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 12068 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 12069 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 12070 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 12071 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 12072 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 12073 12074 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, /* set Mic 1 */ 12075 12076 { } 12077 }; 12078 12079 static struct hda_verb alc861_toshiba_init_verbs[] = { 12080 {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 12081 12082 { } 12083 }; 12084 12085 /* toggle speaker-output according to the hp-jack state */ 12086 static void alc861_toshiba_automute(struct hda_codec *codec) 12087 { 12088 unsigned int present; 12089 12090 present = snd_hda_codec_read(codec, 0x0f, 0, 12091 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 12092 snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0, 12093 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 12094 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3, 12095 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE); 12096 } 12097 12098 static void alc861_toshiba_unsol_event(struct hda_codec *codec, 12099 unsigned int res) 12100 { 12101 if ((res >> 26) == ALC880_HP_EVENT) 12102 alc861_toshiba_automute(codec); 12103 } 12104 12105 /* pcm configuration: identiacal with ALC880 */ 12106 #define alc861_pcm_analog_playback alc880_pcm_analog_playback 12107 #define alc861_pcm_analog_capture alc880_pcm_analog_capture 12108 #define alc861_pcm_digital_playback alc880_pcm_digital_playback 12109 #define alc861_pcm_digital_capture alc880_pcm_digital_capture 12110 12111 12112 #define ALC861_DIGOUT_NID 0x07 12113 12114 static struct hda_channel_mode alc861_8ch_modes[1] = { 12115 { 8, NULL } 12116 }; 12117 12118 static hda_nid_t alc861_dac_nids[4] = { 12119 /* front, surround, clfe, side */ 12120 0x03, 0x06, 0x05, 0x04 12121 }; 12122 12123 static hda_nid_t alc660_dac_nids[3] = { 12124 /* front, clfe, surround */ 12125 0x03, 0x05, 0x06 12126 }; 12127 12128 static hda_nid_t alc861_adc_nids[1] = { 12129 /* ADC0-2 */ 12130 0x08, 12131 }; 12132 12133 static struct hda_input_mux alc861_capture_source = { 12134 .num_items = 5, 12135 .items = { 12136 { "Mic", 0x0 }, 12137 { "Front Mic", 0x3 }, 12138 { "Line", 0x1 }, 12139 { "CD", 0x4 }, 12140 { "Mixer", 0x5 }, 12141 }, 12142 }; 12143 12144 /* fill in the dac_nids table from the parsed pin configuration */ 12145 static int alc861_auto_fill_dac_nids(struct alc_spec *spec, 12146 const struct auto_pin_cfg *cfg) 12147 { 12148 int i; 12149 hda_nid_t nid; 12150 12151 spec->multiout.dac_nids = spec->private_dac_nids; 12152 for (i = 0; i < cfg->line_outs; i++) { 12153 nid = cfg->line_out_pins[i]; 12154 if (nid) { 12155 if (i >= ARRAY_SIZE(alc861_dac_nids)) 12156 continue; 12157 spec->multiout.dac_nids[i] = alc861_dac_nids[i]; 12158 } 12159 } 12160 spec->multiout.num_dacs = cfg->line_outs; 12161 return 0; 12162 } 12163 12164 /* add playback controls from the parsed DAC table */ 12165 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec, 12166 const struct auto_pin_cfg *cfg) 12167 { 12168 char name[32]; 12169 static const char *chname[4] = { 12170 "Front", "Surround", NULL /*CLFE*/, "Side" 12171 }; 12172 hda_nid_t nid; 12173 int i, idx, err; 12174 12175 for (i = 0; i < cfg->line_outs; i++) { 12176 nid = spec->multiout.dac_nids[i]; 12177 if (!nid) 12178 continue; 12179 if (nid == 0x05) { 12180 /* Center/LFE */ 12181 err = add_control(spec, ALC_CTL_BIND_MUTE, 12182 "Center Playback Switch", 12183 HDA_COMPOSE_AMP_VAL(nid, 1, 0, 12184 HDA_OUTPUT)); 12185 if (err < 0) 12186 return err; 12187 err = add_control(spec, ALC_CTL_BIND_MUTE, 12188 "LFE Playback Switch", 12189 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 12190 HDA_OUTPUT)); 12191 if (err < 0) 12192 return err; 12193 } else { 12194 for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1; 12195 idx++) 12196 if (nid == alc861_dac_nids[idx]) 12197 break; 12198 sprintf(name, "%s Playback Switch", chname[idx]); 12199 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 12200 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 12201 HDA_OUTPUT)); 12202 if (err < 0) 12203 return err; 12204 } 12205 } 12206 return 0; 12207 } 12208 12209 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin) 12210 { 12211 int err; 12212 hda_nid_t nid; 12213 12214 if (!pin) 12215 return 0; 12216 12217 if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) { 12218 nid = 0x03; 12219 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 12220 "Headphone Playback Switch", 12221 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 12222 if (err < 0) 12223 return err; 12224 spec->multiout.hp_nid = nid; 12225 } 12226 return 0; 12227 } 12228 12229 /* create playback/capture controls for input pins */ 12230 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec, 12231 const struct auto_pin_cfg *cfg) 12232 { 12233 struct hda_input_mux *imux = &spec->private_imux; 12234 int i, err, idx, idx1; 12235 12236 for (i = 0; i < AUTO_PIN_LAST; i++) { 12237 switch (cfg->input_pins[i]) { 12238 case 0x0c: 12239 idx1 = 1; 12240 idx = 2; /* Line In */ 12241 break; 12242 case 0x0f: 12243 idx1 = 2; 12244 idx = 2; /* Line In */ 12245 break; 12246 case 0x0d: 12247 idx1 = 0; 12248 idx = 1; /* Mic In */ 12249 break; 12250 case 0x10: 12251 idx1 = 3; 12252 idx = 1; /* Mic In */ 12253 break; 12254 case 0x11: 12255 idx1 = 4; 12256 idx = 0; /* CD */ 12257 break; 12258 default: 12259 continue; 12260 } 12261 12262 err = new_analog_input(spec, cfg->input_pins[i], 12263 auto_pin_cfg_labels[i], idx, 0x15); 12264 if (err < 0) 12265 return err; 12266 12267 imux->items[imux->num_items].label = auto_pin_cfg_labels[i]; 12268 imux->items[imux->num_items].index = idx1; 12269 imux->num_items++; 12270 } 12271 return 0; 12272 } 12273 12274 static struct snd_kcontrol_new alc861_capture_mixer[] = { 12275 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 12276 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 12277 12278 { 12279 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 12280 /* The multiple "Capture Source" controls confuse alsamixer 12281 * So call somewhat different.. 12282 */ 12283 /* .name = "Capture Source", */ 12284 .name = "Input Source", 12285 .count = 1, 12286 .info = alc_mux_enum_info, 12287 .get = alc_mux_enum_get, 12288 .put = alc_mux_enum_put, 12289 }, 12290 { } /* end */ 12291 }; 12292 12293 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec, 12294 hda_nid_t nid, 12295 int pin_type, int dac_idx) 12296 { 12297 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 12298 pin_type); 12299 snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE, 12300 AMP_OUT_UNMUTE); 12301 } 12302 12303 static void alc861_auto_init_multi_out(struct hda_codec *codec) 12304 { 12305 struct alc_spec *spec = codec->spec; 12306 int i; 12307 12308 alc_subsystem_id(codec, 0x0e, 0x0f, 0x0b); 12309 for (i = 0; i < spec->autocfg.line_outs; i++) { 12310 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 12311 int pin_type = get_pin_type(spec->autocfg.line_out_type); 12312 if (nid) 12313 alc861_auto_set_output_and_unmute(codec, nid, pin_type, 12314 spec->multiout.dac_nids[i]); 12315 } 12316 } 12317 12318 static void alc861_auto_init_hp_out(struct hda_codec *codec) 12319 { 12320 struct alc_spec *spec = codec->spec; 12321 hda_nid_t pin; 12322 12323 pin = spec->autocfg.hp_pins[0]; 12324 if (pin) /* connect to front */ 12325 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP, 12326 spec->multiout.dac_nids[0]); 12327 pin = spec->autocfg.speaker_pins[0]; 12328 if (pin) 12329 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 12330 } 12331 12332 static void alc861_auto_init_analog_input(struct hda_codec *codec) 12333 { 12334 struct alc_spec *spec = codec->spec; 12335 int i; 12336 12337 for (i = 0; i < AUTO_PIN_LAST; i++) { 12338 hda_nid_t nid = spec->autocfg.input_pins[i]; 12339 if (nid >= 0x0c && nid <= 0x11) { 12340 snd_hda_codec_write(codec, nid, 0, 12341 AC_VERB_SET_PIN_WIDGET_CONTROL, 12342 i <= AUTO_PIN_FRONT_MIC ? 12343 PIN_VREF80 : PIN_IN); 12344 } 12345 } 12346 } 12347 12348 /* parse the BIOS configuration and set up the alc_spec */ 12349 /* return 1 if successful, 0 if the proper config is not found, 12350 * or a negative error code 12351 */ 12352 static int alc861_parse_auto_config(struct hda_codec *codec) 12353 { 12354 struct alc_spec *spec = codec->spec; 12355 int err; 12356 static hda_nid_t alc861_ignore[] = { 0x1d, 0 }; 12357 12358 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 12359 alc861_ignore); 12360 if (err < 0) 12361 return err; 12362 if (!spec->autocfg.line_outs) 12363 return 0; /* can't find valid BIOS pin config */ 12364 12365 err = alc861_auto_fill_dac_nids(spec, &spec->autocfg); 12366 if (err < 0) 12367 return err; 12368 err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg); 12369 if (err < 0) 12370 return err; 12371 err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); 12372 if (err < 0) 12373 return err; 12374 err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg); 12375 if (err < 0) 12376 return err; 12377 12378 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 12379 12380 if (spec->autocfg.dig_out_pin) 12381 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID; 12382 12383 if (spec->kctl_alloc) 12384 spec->mixers[spec->num_mixers++] = spec->kctl_alloc; 12385 12386 spec->init_verbs[spec->num_init_verbs++] = alc861_auto_init_verbs; 12387 12388 spec->num_mux_defs = 1; 12389 spec->input_mux = &spec->private_imux; 12390 12391 spec->adc_nids = alc861_adc_nids; 12392 spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids); 12393 spec->mixers[spec->num_mixers] = alc861_capture_mixer; 12394 spec->num_mixers++; 12395 12396 return 1; 12397 } 12398 12399 /* additional initialization for auto-configuration model */ 12400 static void alc861_auto_init(struct hda_codec *codec) 12401 { 12402 struct alc_spec *spec = codec->spec; 12403 alc861_auto_init_multi_out(codec); 12404 alc861_auto_init_hp_out(codec); 12405 alc861_auto_init_analog_input(codec); 12406 if (spec->unsol_event) 12407 alc_sku_automute(codec); 12408 } 12409 12410 #ifdef CONFIG_SND_HDA_POWER_SAVE 12411 static struct hda_amp_list alc861_loopbacks[] = { 12412 { 0x15, HDA_INPUT, 0 }, 12413 { 0x15, HDA_INPUT, 1 }, 12414 { 0x15, HDA_INPUT, 2 }, 12415 { 0x15, HDA_INPUT, 3 }, 12416 { } /* end */ 12417 }; 12418 #endif 12419 12420 12421 /* 12422 * configuration and preset 12423 */ 12424 static const char *alc861_models[ALC861_MODEL_LAST] = { 12425 [ALC861_3ST] = "3stack", 12426 [ALC660_3ST] = "3stack-660", 12427 [ALC861_3ST_DIG] = "3stack-dig", 12428 [ALC861_6ST_DIG] = "6stack-dig", 12429 [ALC861_UNIWILL_M31] = "uniwill-m31", 12430 [ALC861_TOSHIBA] = "toshiba", 12431 [ALC861_ASUS] = "asus", 12432 [ALC861_ASUS_LAPTOP] = "asus-laptop", 12433 [ALC861_AUTO] = "auto", 12434 }; 12435 12436 static struct snd_pci_quirk alc861_cfg_tbl[] = { 12437 SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST), 12438 SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP), 12439 SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP), 12440 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS), 12441 SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP), 12442 SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG), 12443 SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA), 12444 /* FIXME: the entry below breaks Toshiba A100 (model=auto works!) 12445 * Any other models that need this preset? 12446 */ 12447 /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */ 12448 SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST), 12449 SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST), 12450 SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31), 12451 SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31), 12452 SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP), 12453 /* FIXME: the below seems conflict */ 12454 /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */ 12455 SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST), 12456 SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST), 12457 {} 12458 }; 12459 12460 static struct alc_config_preset alc861_presets[] = { 12461 [ALC861_3ST] = { 12462 .mixers = { alc861_3ST_mixer }, 12463 .init_verbs = { alc861_threestack_init_verbs }, 12464 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 12465 .dac_nids = alc861_dac_nids, 12466 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes), 12467 .channel_mode = alc861_threestack_modes, 12468 .need_dac_fix = 1, 12469 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 12470 .adc_nids = alc861_adc_nids, 12471 .input_mux = &alc861_capture_source, 12472 }, 12473 [ALC861_3ST_DIG] = { 12474 .mixers = { alc861_base_mixer }, 12475 .init_verbs = { alc861_threestack_init_verbs }, 12476 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 12477 .dac_nids = alc861_dac_nids, 12478 .dig_out_nid = ALC861_DIGOUT_NID, 12479 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes), 12480 .channel_mode = alc861_threestack_modes, 12481 .need_dac_fix = 1, 12482 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 12483 .adc_nids = alc861_adc_nids, 12484 .input_mux = &alc861_capture_source, 12485 }, 12486 [ALC861_6ST_DIG] = { 12487 .mixers = { alc861_base_mixer }, 12488 .init_verbs = { alc861_base_init_verbs }, 12489 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 12490 .dac_nids = alc861_dac_nids, 12491 .dig_out_nid = ALC861_DIGOUT_NID, 12492 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes), 12493 .channel_mode = alc861_8ch_modes, 12494 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 12495 .adc_nids = alc861_adc_nids, 12496 .input_mux = &alc861_capture_source, 12497 }, 12498 [ALC660_3ST] = { 12499 .mixers = { alc861_3ST_mixer }, 12500 .init_verbs = { alc861_threestack_init_verbs }, 12501 .num_dacs = ARRAY_SIZE(alc660_dac_nids), 12502 .dac_nids = alc660_dac_nids, 12503 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes), 12504 .channel_mode = alc861_threestack_modes, 12505 .need_dac_fix = 1, 12506 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 12507 .adc_nids = alc861_adc_nids, 12508 .input_mux = &alc861_capture_source, 12509 }, 12510 [ALC861_UNIWILL_M31] = { 12511 .mixers = { alc861_uniwill_m31_mixer }, 12512 .init_verbs = { alc861_uniwill_m31_init_verbs }, 12513 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 12514 .dac_nids = alc861_dac_nids, 12515 .dig_out_nid = ALC861_DIGOUT_NID, 12516 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes), 12517 .channel_mode = alc861_uniwill_m31_modes, 12518 .need_dac_fix = 1, 12519 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 12520 .adc_nids = alc861_adc_nids, 12521 .input_mux = &alc861_capture_source, 12522 }, 12523 [ALC861_TOSHIBA] = { 12524 .mixers = { alc861_toshiba_mixer }, 12525 .init_verbs = { alc861_base_init_verbs, 12526 alc861_toshiba_init_verbs }, 12527 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 12528 .dac_nids = alc861_dac_nids, 12529 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 12530 .channel_mode = alc883_3ST_2ch_modes, 12531 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 12532 .adc_nids = alc861_adc_nids, 12533 .input_mux = &alc861_capture_source, 12534 .unsol_event = alc861_toshiba_unsol_event, 12535 .init_hook = alc861_toshiba_automute, 12536 }, 12537 [ALC861_ASUS] = { 12538 .mixers = { alc861_asus_mixer }, 12539 .init_verbs = { alc861_asus_init_verbs }, 12540 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 12541 .dac_nids = alc861_dac_nids, 12542 .dig_out_nid = ALC861_DIGOUT_NID, 12543 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes), 12544 .channel_mode = alc861_asus_modes, 12545 .need_dac_fix = 1, 12546 .hp_nid = 0x06, 12547 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 12548 .adc_nids = alc861_adc_nids, 12549 .input_mux = &alc861_capture_source, 12550 }, 12551 [ALC861_ASUS_LAPTOP] = { 12552 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer }, 12553 .init_verbs = { alc861_asus_init_verbs, 12554 alc861_asus_laptop_init_verbs }, 12555 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 12556 .dac_nids = alc861_dac_nids, 12557 .dig_out_nid = ALC861_DIGOUT_NID, 12558 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 12559 .channel_mode = alc883_3ST_2ch_modes, 12560 .need_dac_fix = 1, 12561 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 12562 .adc_nids = alc861_adc_nids, 12563 .input_mux = &alc861_capture_source, 12564 }, 12565 }; 12566 12567 12568 static int patch_alc861(struct hda_codec *codec) 12569 { 12570 struct alc_spec *spec; 12571 int board_config; 12572 int err; 12573 12574 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 12575 if (spec == NULL) 12576 return -ENOMEM; 12577 12578 codec->spec = spec; 12579 12580 board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST, 12581 alc861_models, 12582 alc861_cfg_tbl); 12583 12584 if (board_config < 0) { 12585 printk(KERN_INFO "hda_codec: Unknown model for ALC861, " 12586 "trying auto-probe from BIOS...\n"); 12587 board_config = ALC861_AUTO; 12588 } 12589 12590 if (board_config == ALC861_AUTO) { 12591 /* automatic parse from the BIOS config */ 12592 err = alc861_parse_auto_config(codec); 12593 if (err < 0) { 12594 alc_free(codec); 12595 return err; 12596 } else if (!err) { 12597 printk(KERN_INFO 12598 "hda_codec: Cannot set up configuration " 12599 "from BIOS. Using base mode...\n"); 12600 board_config = ALC861_3ST_DIG; 12601 } 12602 } 12603 12604 if (board_config != ALC861_AUTO) 12605 setup_preset(spec, &alc861_presets[board_config]); 12606 12607 spec->stream_name_analog = "ALC861 Analog"; 12608 spec->stream_analog_playback = &alc861_pcm_analog_playback; 12609 spec->stream_analog_capture = &alc861_pcm_analog_capture; 12610 12611 spec->stream_name_digital = "ALC861 Digital"; 12612 spec->stream_digital_playback = &alc861_pcm_digital_playback; 12613 spec->stream_digital_capture = &alc861_pcm_digital_capture; 12614 12615 spec->vmaster_nid = 0x03; 12616 12617 codec->patch_ops = alc_patch_ops; 12618 if (board_config == ALC861_AUTO) 12619 spec->init_hook = alc861_auto_init; 12620 #ifdef CONFIG_SND_HDA_POWER_SAVE 12621 if (!spec->loopback.amplist) 12622 spec->loopback.amplist = alc861_loopbacks; 12623 #endif 12624 12625 return 0; 12626 } 12627 12628 /* 12629 * ALC861-VD support 12630 * 12631 * Based on ALC882 12632 * 12633 * In addition, an independent DAC 12634 */ 12635 #define ALC861VD_DIGOUT_NID 0x06 12636 12637 static hda_nid_t alc861vd_dac_nids[4] = { 12638 /* front, surr, clfe, side surr */ 12639 0x02, 0x03, 0x04, 0x05 12640 }; 12641 12642 /* dac_nids for ALC660vd are in a different order - according to 12643 * Realtek's driver. 12644 * This should probably tesult in a different mixer for 6stack models 12645 * of ALC660vd codecs, but for now there is only 3stack mixer 12646 * - and it is the same as in 861vd. 12647 * adc_nids in ALC660vd are (is) the same as in 861vd 12648 */ 12649 static hda_nid_t alc660vd_dac_nids[3] = { 12650 /* front, rear, clfe, rear_surr */ 12651 0x02, 0x04, 0x03 12652 }; 12653 12654 static hda_nid_t alc861vd_adc_nids[1] = { 12655 /* ADC0 */ 12656 0x09, 12657 }; 12658 12659 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 }; 12660 12661 /* input MUX */ 12662 /* FIXME: should be a matrix-type input source selection */ 12663 static struct hda_input_mux alc861vd_capture_source = { 12664 .num_items = 4, 12665 .items = { 12666 { "Mic", 0x0 }, 12667 { "Front Mic", 0x1 }, 12668 { "Line", 0x2 }, 12669 { "CD", 0x4 }, 12670 }, 12671 }; 12672 12673 static struct hda_input_mux alc861vd_dallas_capture_source = { 12674 .num_items = 2, 12675 .items = { 12676 { "Ext Mic", 0x0 }, 12677 { "Int Mic", 0x1 }, 12678 }, 12679 }; 12680 12681 static struct hda_input_mux alc861vd_hp_capture_source = { 12682 .num_items = 2, 12683 .items = { 12684 { "Front Mic", 0x0 }, 12685 { "ATAPI Mic", 0x1 }, 12686 }, 12687 }; 12688 12689 #define alc861vd_mux_enum_info alc_mux_enum_info 12690 #define alc861vd_mux_enum_get alc_mux_enum_get 12691 /* ALC861VD has the ALC882-type input selection (but has only one ADC) */ 12692 #define alc861vd_mux_enum_put alc882_mux_enum_put 12693 12694 /* 12695 * 2ch mode 12696 */ 12697 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = { 12698 { 2, NULL } 12699 }; 12700 12701 /* 12702 * 6ch mode 12703 */ 12704 static struct hda_verb alc861vd_6stack_ch6_init[] = { 12705 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 12706 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 12707 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 12708 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 12709 { } /* end */ 12710 }; 12711 12712 /* 12713 * 8ch mode 12714 */ 12715 static struct hda_verb alc861vd_6stack_ch8_init[] = { 12716 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 12717 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 12718 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 12719 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 12720 { } /* end */ 12721 }; 12722 12723 static struct hda_channel_mode alc861vd_6stack_modes[2] = { 12724 { 6, alc861vd_6stack_ch6_init }, 12725 { 8, alc861vd_6stack_ch8_init }, 12726 }; 12727 12728 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = { 12729 { 12730 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 12731 .name = "Channel Mode", 12732 .info = alc_ch_mode_info, 12733 .get = alc_ch_mode_get, 12734 .put = alc_ch_mode_put, 12735 }, 12736 { } /* end */ 12737 }; 12738 12739 static struct snd_kcontrol_new alc861vd_capture_mixer[] = { 12740 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT), 12741 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT), 12742 12743 { 12744 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 12745 /* The multiple "Capture Source" controls confuse alsamixer 12746 * So call somewhat different.. 12747 */ 12748 /* .name = "Capture Source", */ 12749 .name = "Input Source", 12750 .count = 1, 12751 .info = alc861vd_mux_enum_info, 12752 .get = alc861vd_mux_enum_get, 12753 .put = alc861vd_mux_enum_put, 12754 }, 12755 { } /* end */ 12756 }; 12757 12758 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17 12759 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b 12760 */ 12761 static struct snd_kcontrol_new alc861vd_6st_mixer[] = { 12762 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 12763 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 12764 12765 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT), 12766 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 12767 12768 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, 12769 HDA_OUTPUT), 12770 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, 12771 HDA_OUTPUT), 12772 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 12773 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 12774 12775 HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT), 12776 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 12777 12778 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 12779 12780 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 12781 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 12782 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 12783 12784 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 12785 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 12786 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 12787 12788 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 12789 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 12790 12791 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 12792 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 12793 12794 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 12795 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 12796 12797 { } /* end */ 12798 }; 12799 12800 static struct snd_kcontrol_new alc861vd_3st_mixer[] = { 12801 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 12802 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 12803 12804 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 12805 12806 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 12807 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 12808 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 12809 12810 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 12811 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 12812 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 12813 12814 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 12815 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 12816 12817 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 12818 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 12819 12820 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 12821 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 12822 12823 { } /* end */ 12824 }; 12825 12826 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = { 12827 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 12828 /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/ 12829 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 12830 12831 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 12832 12833 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 12834 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 12835 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 12836 12837 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 12838 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 12839 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 12840 12841 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 12842 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 12843 12844 { } /* end */ 12845 }; 12846 12847 /* Pin assignment: Speaker=0x14, HP = 0x15, 12848 * Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d 12849 */ 12850 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = { 12851 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 12852 HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT), 12853 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 12854 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT), 12855 HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT), 12856 HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 12857 HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 12858 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 12859 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 12860 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 12861 HDA_CODEC_VOLUME("PC Beep Volume", 0x0b, 0x05, HDA_INPUT), 12862 HDA_CODEC_MUTE("PC Beep Switch", 0x0b, 0x05, HDA_INPUT), 12863 { } /* end */ 12864 }; 12865 12866 /* Pin assignment: Speaker=0x14, Line-out = 0x15, 12867 * Front Mic=0x18, ATAPI Mic = 0x19, 12868 */ 12869 static struct snd_kcontrol_new alc861vd_hp_mixer[] = { 12870 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 12871 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 12872 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 12873 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT), 12874 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 12875 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 12876 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 12877 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 12878 12879 { } /* end */ 12880 }; 12881 12882 /* 12883 * generic initialization of ADC, input mixers and output mixers 12884 */ 12885 static struct hda_verb alc861vd_volume_init_verbs[] = { 12886 /* 12887 * Unmute ADC0 and set the default input to mic-in 12888 */ 12889 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 12890 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12891 12892 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of 12893 * the analog-loopback mixer widget 12894 */ 12895 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 12896 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 12897 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 12898 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 12899 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 12900 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 12901 12902 /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */ 12903 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12904 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12905 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 12906 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 12907 12908 /* 12909 * Set up output mixers (0x02 - 0x05) 12910 */ 12911 /* set vol=0 to output mixers */ 12912 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 12913 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 12914 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 12915 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 12916 12917 /* set up input amps for analog loopback */ 12918 /* Amp Indices: DAC = 0, mixer = 1 */ 12919 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 12920 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 12921 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 12922 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 12923 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 12924 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 12925 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 12926 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 12927 12928 { } 12929 }; 12930 12931 /* 12932 * 3-stack pin configuration: 12933 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b 12934 */ 12935 static struct hda_verb alc861vd_3stack_init_verbs[] = { 12936 /* 12937 * Set pin mode and muting 12938 */ 12939 /* set front pin widgets 0x14 for output */ 12940 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 12941 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12942 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 12943 12944 /* Mic (rear) pin: input vref at 80% */ 12945 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 12946 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12947 /* Front Mic pin: input vref at 80% */ 12948 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 12949 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12950 /* Line In pin: input */ 12951 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 12952 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12953 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 12954 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 12955 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12956 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 12957 /* CD pin widget for input */ 12958 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 12959 12960 { } 12961 }; 12962 12963 /* 12964 * 6-stack pin configuration: 12965 */ 12966 static struct hda_verb alc861vd_6stack_init_verbs[] = { 12967 /* 12968 * Set pin mode and muting 12969 */ 12970 /* set front pin widgets 0x14 for output */ 12971 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 12972 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12973 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 12974 12975 /* Rear Pin: output 1 (0x0d) */ 12976 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 12977 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12978 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 12979 /* CLFE Pin: output 2 (0x0e) */ 12980 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 12981 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12982 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02}, 12983 /* Side Pin: output 3 (0x0f) */ 12984 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 12985 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12986 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 12987 12988 /* Mic (rear) pin: input vref at 80% */ 12989 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 12990 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12991 /* Front Mic pin: input vref at 80% */ 12992 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 12993 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12994 /* Line In pin: input */ 12995 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 12996 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12997 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 12998 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 12999 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13000 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 13001 /* CD pin widget for input */ 13002 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 13003 13004 { } 13005 }; 13006 13007 static struct hda_verb alc861vd_eapd_verbs[] = { 13008 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 13009 { } 13010 }; 13011 13012 static struct hda_verb alc660vd_eapd_verbs[] = { 13013 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 13014 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 13015 { } 13016 }; 13017 13018 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = { 13019 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13020 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13021 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 13022 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 13023 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 13024 {} 13025 }; 13026 13027 /* toggle speaker-output according to the hp-jack state */ 13028 static void alc861vd_lenovo_hp_automute(struct hda_codec *codec) 13029 { 13030 unsigned int present; 13031 unsigned char bits; 13032 13033 present = snd_hda_codec_read(codec, 0x1b, 0, 13034 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 13035 bits = present ? HDA_AMP_MUTE : 0; 13036 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 13037 HDA_AMP_MUTE, bits); 13038 } 13039 13040 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec) 13041 { 13042 unsigned int present; 13043 unsigned char bits; 13044 13045 present = snd_hda_codec_read(codec, 0x18, 0, 13046 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 13047 bits = present ? HDA_AMP_MUTE : 0; 13048 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, 13049 HDA_AMP_MUTE, bits); 13050 } 13051 13052 static void alc861vd_lenovo_automute(struct hda_codec *codec) 13053 { 13054 alc861vd_lenovo_hp_automute(codec); 13055 alc861vd_lenovo_mic_automute(codec); 13056 } 13057 13058 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec, 13059 unsigned int res) 13060 { 13061 switch (res >> 26) { 13062 case ALC880_HP_EVENT: 13063 alc861vd_lenovo_hp_automute(codec); 13064 break; 13065 case ALC880_MIC_EVENT: 13066 alc861vd_lenovo_mic_automute(codec); 13067 break; 13068 } 13069 } 13070 13071 static struct hda_verb alc861vd_dallas_verbs[] = { 13072 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 13073 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 13074 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 13075 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 13076 13077 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13078 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13079 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 13080 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 13081 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 13082 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 13083 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 13084 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 13085 13086 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 13087 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13088 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 13089 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13090 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 13091 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13092 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 13093 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13094 13095 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50}, 13096 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13097 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50}, 13098 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13099 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 13100 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 13101 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 13102 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 13103 13104 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13105 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 13106 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 13107 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 13108 13109 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 13110 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 13111 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 13112 13113 { } /* end */ 13114 }; 13115 13116 /* toggle speaker-output according to the hp-jack state */ 13117 static void alc861vd_dallas_automute(struct hda_codec *codec) 13118 { 13119 unsigned int present; 13120 13121 present = snd_hda_codec_read(codec, 0x15, 0, 13122 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 13123 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 13124 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 13125 } 13126 13127 static void alc861vd_dallas_unsol_event(struct hda_codec *codec, unsigned int res) 13128 { 13129 if ((res >> 26) == ALC880_HP_EVENT) 13130 alc861vd_dallas_automute(codec); 13131 } 13132 13133 #ifdef CONFIG_SND_HDA_POWER_SAVE 13134 #define alc861vd_loopbacks alc880_loopbacks 13135 #endif 13136 13137 /* pcm configuration: identiacal with ALC880 */ 13138 #define alc861vd_pcm_analog_playback alc880_pcm_analog_playback 13139 #define alc861vd_pcm_analog_capture alc880_pcm_analog_capture 13140 #define alc861vd_pcm_digital_playback alc880_pcm_digital_playback 13141 #define alc861vd_pcm_digital_capture alc880_pcm_digital_capture 13142 13143 /* 13144 * configuration and preset 13145 */ 13146 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = { 13147 [ALC660VD_3ST] = "3stack-660", 13148 [ALC660VD_3ST_DIG] = "3stack-660-digout", 13149 [ALC861VD_3ST] = "3stack", 13150 [ALC861VD_3ST_DIG] = "3stack-digout", 13151 [ALC861VD_6ST_DIG] = "6stack-digout", 13152 [ALC861VD_LENOVO] = "lenovo", 13153 [ALC861VD_DALLAS] = "dallas", 13154 [ALC861VD_HP] = "hp", 13155 [ALC861VD_AUTO] = "auto", 13156 }; 13157 13158 static struct snd_pci_quirk alc861vd_cfg_tbl[] = { 13159 SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST), 13160 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP), 13161 SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST), 13162 SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST), 13163 SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC861VD_LENOVO), 13164 SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG), 13165 SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST), 13166 SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO), 13167 /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/ 13168 SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS), 13169 SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO), 13170 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS), 13171 SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG), 13172 SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo", ALC861VD_LENOVO), 13173 SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo 3000 C200", ALC861VD_LENOVO), 13174 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 N200", ALC861VD_LENOVO), 13175 SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG), 13176 {} 13177 }; 13178 13179 static struct alc_config_preset alc861vd_presets[] = { 13180 [ALC660VD_3ST] = { 13181 .mixers = { alc861vd_3st_mixer }, 13182 .init_verbs = { alc861vd_volume_init_verbs, 13183 alc861vd_3stack_init_verbs }, 13184 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids), 13185 .dac_nids = alc660vd_dac_nids, 13186 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 13187 .channel_mode = alc861vd_3stack_2ch_modes, 13188 .input_mux = &alc861vd_capture_source, 13189 }, 13190 [ALC660VD_3ST_DIG] = { 13191 .mixers = { alc861vd_3st_mixer }, 13192 .init_verbs = { alc861vd_volume_init_verbs, 13193 alc861vd_3stack_init_verbs }, 13194 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids), 13195 .dac_nids = alc660vd_dac_nids, 13196 .dig_out_nid = ALC861VD_DIGOUT_NID, 13197 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 13198 .channel_mode = alc861vd_3stack_2ch_modes, 13199 .input_mux = &alc861vd_capture_source, 13200 }, 13201 [ALC861VD_3ST] = { 13202 .mixers = { alc861vd_3st_mixer }, 13203 .init_verbs = { alc861vd_volume_init_verbs, 13204 alc861vd_3stack_init_verbs }, 13205 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 13206 .dac_nids = alc861vd_dac_nids, 13207 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 13208 .channel_mode = alc861vd_3stack_2ch_modes, 13209 .input_mux = &alc861vd_capture_source, 13210 }, 13211 [ALC861VD_3ST_DIG] = { 13212 .mixers = { alc861vd_3st_mixer }, 13213 .init_verbs = { alc861vd_volume_init_verbs, 13214 alc861vd_3stack_init_verbs }, 13215 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 13216 .dac_nids = alc861vd_dac_nids, 13217 .dig_out_nid = ALC861VD_DIGOUT_NID, 13218 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 13219 .channel_mode = alc861vd_3stack_2ch_modes, 13220 .input_mux = &alc861vd_capture_source, 13221 }, 13222 [ALC861VD_6ST_DIG] = { 13223 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer }, 13224 .init_verbs = { alc861vd_volume_init_verbs, 13225 alc861vd_6stack_init_verbs }, 13226 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 13227 .dac_nids = alc861vd_dac_nids, 13228 .dig_out_nid = ALC861VD_DIGOUT_NID, 13229 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes), 13230 .channel_mode = alc861vd_6stack_modes, 13231 .input_mux = &alc861vd_capture_source, 13232 }, 13233 [ALC861VD_LENOVO] = { 13234 .mixers = { alc861vd_lenovo_mixer }, 13235 .init_verbs = { alc861vd_volume_init_verbs, 13236 alc861vd_3stack_init_verbs, 13237 alc861vd_eapd_verbs, 13238 alc861vd_lenovo_unsol_verbs }, 13239 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids), 13240 .dac_nids = alc660vd_dac_nids, 13241 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 13242 .channel_mode = alc861vd_3stack_2ch_modes, 13243 .input_mux = &alc861vd_capture_source, 13244 .unsol_event = alc861vd_lenovo_unsol_event, 13245 .init_hook = alc861vd_lenovo_automute, 13246 }, 13247 [ALC861VD_DALLAS] = { 13248 .mixers = { alc861vd_dallas_mixer }, 13249 .init_verbs = { alc861vd_dallas_verbs }, 13250 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 13251 .dac_nids = alc861vd_dac_nids, 13252 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 13253 .channel_mode = alc861vd_3stack_2ch_modes, 13254 .input_mux = &alc861vd_dallas_capture_source, 13255 .unsol_event = alc861vd_dallas_unsol_event, 13256 .init_hook = alc861vd_dallas_automute, 13257 }, 13258 [ALC861VD_HP] = { 13259 .mixers = { alc861vd_hp_mixer }, 13260 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs }, 13261 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 13262 .dac_nids = alc861vd_dac_nids, 13263 .dig_out_nid = ALC861VD_DIGOUT_NID, 13264 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 13265 .channel_mode = alc861vd_3stack_2ch_modes, 13266 .input_mux = &alc861vd_hp_capture_source, 13267 .unsol_event = alc861vd_dallas_unsol_event, 13268 .init_hook = alc861vd_dallas_automute, 13269 }, 13270 }; 13271 13272 /* 13273 * BIOS auto configuration 13274 */ 13275 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec, 13276 hda_nid_t nid, int pin_type, int dac_idx) 13277 { 13278 alc_set_pin_output(codec, nid, pin_type); 13279 } 13280 13281 static void alc861vd_auto_init_multi_out(struct hda_codec *codec) 13282 { 13283 struct alc_spec *spec = codec->spec; 13284 int i; 13285 13286 alc_subsystem_id(codec, 0x15, 0x1b, 0x14); 13287 for (i = 0; i <= HDA_SIDE; i++) { 13288 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 13289 int pin_type = get_pin_type(spec->autocfg.line_out_type); 13290 if (nid) 13291 alc861vd_auto_set_output_and_unmute(codec, nid, 13292 pin_type, i); 13293 } 13294 } 13295 13296 13297 static void alc861vd_auto_init_hp_out(struct hda_codec *codec) 13298 { 13299 struct alc_spec *spec = codec->spec; 13300 hda_nid_t pin; 13301 13302 pin = spec->autocfg.hp_pins[0]; 13303 if (pin) /* connect to front and use dac 0 */ 13304 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 13305 pin = spec->autocfg.speaker_pins[0]; 13306 if (pin) 13307 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 13308 } 13309 13310 #define alc861vd_is_input_pin(nid) alc880_is_input_pin(nid) 13311 #define ALC861VD_PIN_CD_NID ALC880_PIN_CD_NID 13312 13313 static void alc861vd_auto_init_analog_input(struct hda_codec *codec) 13314 { 13315 struct alc_spec *spec = codec->spec; 13316 int i; 13317 13318 for (i = 0; i < AUTO_PIN_LAST; i++) { 13319 hda_nid_t nid = spec->autocfg.input_pins[i]; 13320 if (alc861vd_is_input_pin(nid)) { 13321 snd_hda_codec_write(codec, nid, 0, 13322 AC_VERB_SET_PIN_WIDGET_CONTROL, 13323 i <= AUTO_PIN_FRONT_MIC ? 13324 PIN_VREF80 : PIN_IN); 13325 if (nid != ALC861VD_PIN_CD_NID) 13326 snd_hda_codec_write(codec, nid, 0, 13327 AC_VERB_SET_AMP_GAIN_MUTE, 13328 AMP_OUT_MUTE); 13329 } 13330 } 13331 } 13332 13333 #define alc861vd_idx_to_mixer_vol(nid) ((nid) + 0x02) 13334 #define alc861vd_idx_to_mixer_switch(nid) ((nid) + 0x0c) 13335 13336 /* add playback controls from the parsed DAC table */ 13337 /* Based on ALC880 version. But ALC861VD has separate, 13338 * different NIDs for mute/unmute switch and volume control */ 13339 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec, 13340 const struct auto_pin_cfg *cfg) 13341 { 13342 char name[32]; 13343 static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"}; 13344 hda_nid_t nid_v, nid_s; 13345 int i, err; 13346 13347 for (i = 0; i < cfg->line_outs; i++) { 13348 if (!spec->multiout.dac_nids[i]) 13349 continue; 13350 nid_v = alc861vd_idx_to_mixer_vol( 13351 alc880_dac_to_idx( 13352 spec->multiout.dac_nids[i])); 13353 nid_s = alc861vd_idx_to_mixer_switch( 13354 alc880_dac_to_idx( 13355 spec->multiout.dac_nids[i])); 13356 13357 if (i == 2) { 13358 /* Center/LFE */ 13359 err = add_control(spec, ALC_CTL_WIDGET_VOL, 13360 "Center Playback Volume", 13361 HDA_COMPOSE_AMP_VAL(nid_v, 1, 0, 13362 HDA_OUTPUT)); 13363 if (err < 0) 13364 return err; 13365 err = add_control(spec, ALC_CTL_WIDGET_VOL, 13366 "LFE Playback Volume", 13367 HDA_COMPOSE_AMP_VAL(nid_v, 2, 0, 13368 HDA_OUTPUT)); 13369 if (err < 0) 13370 return err; 13371 err = add_control(spec, ALC_CTL_BIND_MUTE, 13372 "Center Playback Switch", 13373 HDA_COMPOSE_AMP_VAL(nid_s, 1, 2, 13374 HDA_INPUT)); 13375 if (err < 0) 13376 return err; 13377 err = add_control(spec, ALC_CTL_BIND_MUTE, 13378 "LFE Playback Switch", 13379 HDA_COMPOSE_AMP_VAL(nid_s, 2, 2, 13380 HDA_INPUT)); 13381 if (err < 0) 13382 return err; 13383 } else { 13384 sprintf(name, "%s Playback Volume", chname[i]); 13385 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 13386 HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, 13387 HDA_OUTPUT)); 13388 if (err < 0) 13389 return err; 13390 sprintf(name, "%s Playback Switch", chname[i]); 13391 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 13392 HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, 13393 HDA_INPUT)); 13394 if (err < 0) 13395 return err; 13396 } 13397 } 13398 return 0; 13399 } 13400 13401 /* add playback controls for speaker and HP outputs */ 13402 /* Based on ALC880 version. But ALC861VD has separate, 13403 * different NIDs for mute/unmute switch and volume control */ 13404 static int alc861vd_auto_create_extra_out(struct alc_spec *spec, 13405 hda_nid_t pin, const char *pfx) 13406 { 13407 hda_nid_t nid_v, nid_s; 13408 int err; 13409 char name[32]; 13410 13411 if (!pin) 13412 return 0; 13413 13414 if (alc880_is_fixed_pin(pin)) { 13415 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin)); 13416 /* specify the DAC as the extra output */ 13417 if (!spec->multiout.hp_nid) 13418 spec->multiout.hp_nid = nid_v; 13419 else 13420 spec->multiout.extra_out_nid[0] = nid_v; 13421 /* control HP volume/switch on the output mixer amp */ 13422 nid_v = alc861vd_idx_to_mixer_vol( 13423 alc880_fixed_pin_idx(pin)); 13424 nid_s = alc861vd_idx_to_mixer_switch( 13425 alc880_fixed_pin_idx(pin)); 13426 13427 sprintf(name, "%s Playback Volume", pfx); 13428 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 13429 HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT)); 13430 if (err < 0) 13431 return err; 13432 sprintf(name, "%s Playback Switch", pfx); 13433 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 13434 HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT)); 13435 if (err < 0) 13436 return err; 13437 } else if (alc880_is_multi_pin(pin)) { 13438 /* set manual connection */ 13439 /* we have only a switch on HP-out PIN */ 13440 sprintf(name, "%s Playback Switch", pfx); 13441 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 13442 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 13443 if (err < 0) 13444 return err; 13445 } 13446 return 0; 13447 } 13448 13449 /* parse the BIOS configuration and set up the alc_spec 13450 * return 1 if successful, 0 if the proper config is not found, 13451 * or a negative error code 13452 * Based on ALC880 version - had to change it to override 13453 * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */ 13454 static int alc861vd_parse_auto_config(struct hda_codec *codec) 13455 { 13456 struct alc_spec *spec = codec->spec; 13457 int err; 13458 static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 }; 13459 13460 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 13461 alc861vd_ignore); 13462 if (err < 0) 13463 return err; 13464 if (!spec->autocfg.line_outs) 13465 return 0; /* can't find valid BIOS pin config */ 13466 13467 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg); 13468 if (err < 0) 13469 return err; 13470 err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg); 13471 if (err < 0) 13472 return err; 13473 err = alc861vd_auto_create_extra_out(spec, 13474 spec->autocfg.speaker_pins[0], 13475 "Speaker"); 13476 if (err < 0) 13477 return err; 13478 err = alc861vd_auto_create_extra_out(spec, 13479 spec->autocfg.hp_pins[0], 13480 "Headphone"); 13481 if (err < 0) 13482 return err; 13483 err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg); 13484 if (err < 0) 13485 return err; 13486 13487 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 13488 13489 if (spec->autocfg.dig_out_pin) 13490 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID; 13491 13492 if (spec->kctl_alloc) 13493 spec->mixers[spec->num_mixers++] = spec->kctl_alloc; 13494 13495 spec->init_verbs[spec->num_init_verbs++] 13496 = alc861vd_volume_init_verbs; 13497 13498 spec->num_mux_defs = 1; 13499 spec->input_mux = &spec->private_imux; 13500 13501 err = alc_auto_add_mic_boost(codec); 13502 if (err < 0) 13503 return err; 13504 13505 return 1; 13506 } 13507 13508 /* additional initialization for auto-configuration model */ 13509 static void alc861vd_auto_init(struct hda_codec *codec) 13510 { 13511 struct alc_spec *spec = codec->spec; 13512 alc861vd_auto_init_multi_out(codec); 13513 alc861vd_auto_init_hp_out(codec); 13514 alc861vd_auto_init_analog_input(codec); 13515 if (spec->unsol_event) 13516 alc_sku_automute(codec); 13517 } 13518 13519 static int patch_alc861vd(struct hda_codec *codec) 13520 { 13521 struct alc_spec *spec; 13522 int err, board_config; 13523 13524 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 13525 if (spec == NULL) 13526 return -ENOMEM; 13527 13528 codec->spec = spec; 13529 13530 board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST, 13531 alc861vd_models, 13532 alc861vd_cfg_tbl); 13533 13534 if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) { 13535 printk(KERN_INFO "hda_codec: Unknown model for ALC660VD/" 13536 "ALC861VD, trying auto-probe from BIOS...\n"); 13537 board_config = ALC861VD_AUTO; 13538 } 13539 13540 if (board_config == ALC861VD_AUTO) { 13541 /* automatic parse from the BIOS config */ 13542 err = alc861vd_parse_auto_config(codec); 13543 if (err < 0) { 13544 alc_free(codec); 13545 return err; 13546 } else if (!err) { 13547 printk(KERN_INFO 13548 "hda_codec: Cannot set up configuration " 13549 "from BIOS. Using base mode...\n"); 13550 board_config = ALC861VD_3ST; 13551 } 13552 } 13553 13554 if (board_config != ALC861VD_AUTO) 13555 setup_preset(spec, &alc861vd_presets[board_config]); 13556 13557 if (codec->vendor_id == 0x10ec0660) { 13558 spec->stream_name_analog = "ALC660-VD Analog"; 13559 spec->stream_name_digital = "ALC660-VD Digital"; 13560 /* always turn on EAPD */ 13561 spec->init_verbs[spec->num_init_verbs++] = alc660vd_eapd_verbs; 13562 } else { 13563 spec->stream_name_analog = "ALC861VD Analog"; 13564 spec->stream_name_digital = "ALC861VD Digital"; 13565 } 13566 13567 spec->stream_analog_playback = &alc861vd_pcm_analog_playback; 13568 spec->stream_analog_capture = &alc861vd_pcm_analog_capture; 13569 13570 spec->stream_digital_playback = &alc861vd_pcm_digital_playback; 13571 spec->stream_digital_capture = &alc861vd_pcm_digital_capture; 13572 13573 spec->adc_nids = alc861vd_adc_nids; 13574 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids); 13575 spec->capsrc_nids = alc861vd_capsrc_nids; 13576 13577 spec->mixers[spec->num_mixers] = alc861vd_capture_mixer; 13578 spec->num_mixers++; 13579 13580 spec->vmaster_nid = 0x02; 13581 13582 codec->patch_ops = alc_patch_ops; 13583 13584 if (board_config == ALC861VD_AUTO) 13585 spec->init_hook = alc861vd_auto_init; 13586 #ifdef CONFIG_SND_HDA_POWER_SAVE 13587 if (!spec->loopback.amplist) 13588 spec->loopback.amplist = alc861vd_loopbacks; 13589 #endif 13590 13591 return 0; 13592 } 13593 13594 /* 13595 * ALC662 support 13596 * 13597 * ALC662 is almost identical with ALC880 but has cleaner and more flexible 13598 * configuration. Each pin widget can choose any input DACs and a mixer. 13599 * Each ADC is connected from a mixer of all inputs. This makes possible 13600 * 6-channel independent captures. 13601 * 13602 * In addition, an independent DAC for the multi-playback (not used in this 13603 * driver yet). 13604 */ 13605 #define ALC662_DIGOUT_NID 0x06 13606 #define ALC662_DIGIN_NID 0x0a 13607 13608 static hda_nid_t alc662_dac_nids[4] = { 13609 /* front, rear, clfe, rear_surr */ 13610 0x02, 0x03, 0x04 13611 }; 13612 13613 static hda_nid_t alc662_adc_nids[1] = { 13614 /* ADC1-2 */ 13615 0x09, 13616 }; 13617 13618 static hda_nid_t alc662_capsrc_nids[1] = { 0x22 }; 13619 13620 /* input MUX */ 13621 /* FIXME: should be a matrix-type input source selection */ 13622 static struct hda_input_mux alc662_capture_source = { 13623 .num_items = 4, 13624 .items = { 13625 { "Mic", 0x0 }, 13626 { "Front Mic", 0x1 }, 13627 { "Line", 0x2 }, 13628 { "CD", 0x4 }, 13629 }, 13630 }; 13631 13632 static struct hda_input_mux alc662_lenovo_101e_capture_source = { 13633 .num_items = 2, 13634 .items = { 13635 { "Mic", 0x1 }, 13636 { "Line", 0x2 }, 13637 }, 13638 }; 13639 13640 static struct hda_input_mux alc662_eeepc_capture_source = { 13641 .num_items = 2, 13642 .items = { 13643 { "i-Mic", 0x1 }, 13644 { "e-Mic", 0x0 }, 13645 }, 13646 }; 13647 13648 static struct hda_input_mux alc663_capture_source = { 13649 .num_items = 3, 13650 .items = { 13651 { "Mic", 0x0 }, 13652 { "Front Mic", 0x1 }, 13653 { "Line", 0x2 }, 13654 }, 13655 }; 13656 13657 static struct hda_input_mux alc663_m51va_capture_source = { 13658 .num_items = 2, 13659 .items = { 13660 { "Ext-Mic", 0x0 }, 13661 { "D-Mic", 0x9 }, 13662 }, 13663 }; 13664 13665 #define alc662_mux_enum_info alc_mux_enum_info 13666 #define alc662_mux_enum_get alc_mux_enum_get 13667 #define alc662_mux_enum_put alc882_mux_enum_put 13668 13669 /* 13670 * 2ch mode 13671 */ 13672 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = { 13673 { 2, NULL } 13674 }; 13675 13676 /* 13677 * 2ch mode 13678 */ 13679 static struct hda_verb alc662_3ST_ch2_init[] = { 13680 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 13681 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 13682 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 13683 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 13684 { } /* end */ 13685 }; 13686 13687 /* 13688 * 6ch mode 13689 */ 13690 static struct hda_verb alc662_3ST_ch6_init[] = { 13691 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 13692 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 13693 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 }, 13694 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 13695 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 13696 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 13697 { } /* end */ 13698 }; 13699 13700 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = { 13701 { 2, alc662_3ST_ch2_init }, 13702 { 6, alc662_3ST_ch6_init }, 13703 }; 13704 13705 /* 13706 * 2ch mode 13707 */ 13708 static struct hda_verb alc662_sixstack_ch6_init[] = { 13709 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 13710 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 13711 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 13712 { } /* end */ 13713 }; 13714 13715 /* 13716 * 6ch mode 13717 */ 13718 static struct hda_verb alc662_sixstack_ch8_init[] = { 13719 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 13720 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 13721 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 13722 { } /* end */ 13723 }; 13724 13725 static struct hda_channel_mode alc662_5stack_modes[2] = { 13726 { 2, alc662_sixstack_ch6_init }, 13727 { 6, alc662_sixstack_ch8_init }, 13728 }; 13729 13730 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17 13731 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b 13732 */ 13733 13734 static struct snd_kcontrol_new alc662_base_mixer[] = { 13735 /* output mixer control */ 13736 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT), 13737 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT), 13738 HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT), 13739 HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT), 13740 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT), 13741 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT), 13742 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT), 13743 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT), 13744 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 13745 13746 /*Input mixer control */ 13747 HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT), 13748 HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT), 13749 HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT), 13750 HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT), 13751 HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT), 13752 HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT), 13753 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT), 13754 HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT), 13755 { } /* end */ 13756 }; 13757 13758 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = { 13759 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 13760 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT), 13761 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 13762 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 13763 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 13764 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 13765 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 13766 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 13767 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 13768 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 13769 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 13770 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 13771 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 13772 { } /* end */ 13773 }; 13774 13775 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = { 13776 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 13777 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT), 13778 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT), 13779 HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT), 13780 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT), 13781 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT), 13782 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT), 13783 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT), 13784 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 13785 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 13786 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 13787 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 13788 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 13789 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 13790 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 13791 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 13792 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 13793 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 13794 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 13795 { } /* end */ 13796 }; 13797 13798 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = { 13799 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 13800 HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT), 13801 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT), 13802 HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT), 13803 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 13804 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 13805 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 13806 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 13807 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 13808 { } /* end */ 13809 }; 13810 13811 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = { 13812 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 13813 13814 HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT), 13815 HDA_CODEC_MUTE("Line-Out Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 13816 13817 HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT), 13818 HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 13819 HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 13820 13821 HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT), 13822 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 13823 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 13824 { } /* end */ 13825 }; 13826 13827 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = { 13828 HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT), 13829 HDA_CODEC_MUTE("Line-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT), 13830 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT), 13831 HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT), 13832 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT), 13833 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT), 13834 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT), 13835 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT), 13836 HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 13837 HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT), 13838 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 13839 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 13840 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 13841 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 13842 { } /* end */ 13843 }; 13844 13845 static struct snd_kcontrol_new alc663_m51va_mixer[] = { 13846 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 13847 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 13848 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT), 13849 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 13850 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 13851 HDA_CODEC_MUTE("DMic Playback Switch", 0x23, 0x9, HDA_INPUT), 13852 { } /* end */ 13853 }; 13854 13855 static struct snd_kcontrol_new alc663_g71v_mixer[] = { 13856 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 13857 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 13858 HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT), 13859 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT), 13860 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT), 13861 13862 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 13863 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 13864 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 13865 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 13866 { } /* end */ 13867 }; 13868 13869 static struct snd_kcontrol_new alc663_g50v_mixer[] = { 13870 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 13871 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 13872 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT), 13873 13874 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 13875 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 13876 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 13877 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 13878 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 13879 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 13880 { } /* end */ 13881 }; 13882 13883 static struct snd_kcontrol_new alc662_chmode_mixer[] = { 13884 { 13885 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 13886 .name = "Channel Mode", 13887 .info = alc_ch_mode_info, 13888 .get = alc_ch_mode_get, 13889 .put = alc_ch_mode_put, 13890 }, 13891 { } /* end */ 13892 }; 13893 13894 static struct hda_verb alc662_init_verbs[] = { 13895 /* ADC: mute amp left and right */ 13896 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 13897 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 13898 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 13899 13900 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 13901 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 13902 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 13903 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 13904 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 13905 13906 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13907 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13908 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13909 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13910 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13911 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13912 13913 /* Front Pin: output 0 (0x0c) */ 13914 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 13915 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13916 13917 /* Rear Pin: output 1 (0x0d) */ 13918 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 13919 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13920 13921 /* CLFE Pin: output 2 (0x0e) */ 13922 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 13923 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13924 13925 /* Mic (rear) pin: input vref at 80% */ 13926 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 13927 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13928 /* Front Mic pin: input vref at 80% */ 13929 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 13930 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13931 /* Line In pin: input */ 13932 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 13933 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13934 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 13935 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 13936 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13937 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 13938 /* CD pin widget for input */ 13939 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 13940 13941 /* FIXME: use matrix-type input source selection */ 13942 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 13943 /* Input mixer */ 13944 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13945 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13946 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13947 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 13948 13949 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13950 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13951 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13952 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 13953 13954 /* always trun on EAPD */ 13955 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 13956 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 13957 13958 { } 13959 }; 13960 13961 static struct hda_verb alc662_sue_init_verbs[] = { 13962 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT}, 13963 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT}, 13964 {} 13965 }; 13966 13967 static struct hda_verb alc662_eeepc_sue_init_verbs[] = { 13968 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 13969 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 13970 {} 13971 }; 13972 13973 /* Set Unsolicited Event*/ 13974 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = { 13975 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 13976 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 13977 {} 13978 }; 13979 13980 /* 13981 * generic initialization of ADC, input mixers and output mixers 13982 */ 13983 static struct hda_verb alc662_auto_init_verbs[] = { 13984 /* 13985 * Unmute ADC and set the default input to mic-in 13986 */ 13987 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 13988 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13989 13990 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 13991 * mixer widget 13992 * Note: PASD motherboards uses the Line In 2 as the input for front 13993 * panel mic (mic 2) 13994 */ 13995 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 13996 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 13997 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 13998 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 13999 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 14000 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 14001 14002 /* 14003 * Set up output mixers (0x0c - 0x0f) 14004 */ 14005 /* set vol=0 to output mixers */ 14006 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14007 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14008 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14009 14010 /* set up input amps for analog loopback */ 14011 /* Amp Indices: DAC = 0, mixer = 1 */ 14012 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14013 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14014 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14015 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14016 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14017 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14018 14019 14020 /* FIXME: use matrix-type input source selection */ 14021 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 14022 /* Input mixer */ 14023 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14024 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14025 { } 14026 }; 14027 14028 static struct hda_verb alc663_m51va_init_verbs[] = { 14029 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 14030 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14031 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */ 14032 14033 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)}, 14034 14035 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 14036 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 14037 {} 14038 }; 14039 14040 static struct hda_verb alc663_g71v_init_verbs[] = { 14041 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 14042 /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */ 14043 /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */ 14044 14045 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 14046 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14047 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */ 14048 14049 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT}, 14050 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT}, 14051 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT}, 14052 {} 14053 }; 14054 14055 static struct hda_verb alc663_g50v_init_verbs[] = { 14056 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 14057 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14058 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */ 14059 14060 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 14061 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 14062 {} 14063 }; 14064 14065 /* capture mixer elements */ 14066 static struct snd_kcontrol_new alc662_capture_mixer[] = { 14067 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT), 14068 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT), 14069 { 14070 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 14071 /* The multiple "Capture Source" controls confuse alsamixer 14072 * So call somewhat different.. 14073 */ 14074 /* .name = "Capture Source", */ 14075 .name = "Input Source", 14076 .count = 1, 14077 .info = alc662_mux_enum_info, 14078 .get = alc662_mux_enum_get, 14079 .put = alc662_mux_enum_put, 14080 }, 14081 { } /* end */ 14082 }; 14083 14084 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec) 14085 { 14086 unsigned int present; 14087 unsigned char bits; 14088 14089 present = snd_hda_codec_read(codec, 0x14, 0, 14090 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 14091 bits = present ? HDA_AMP_MUTE : 0; 14092 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 14093 HDA_AMP_MUTE, bits); 14094 } 14095 14096 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec) 14097 { 14098 unsigned int present; 14099 unsigned char bits; 14100 14101 present = snd_hda_codec_read(codec, 0x1b, 0, 14102 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 14103 bits = present ? HDA_AMP_MUTE : 0; 14104 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 14105 HDA_AMP_MUTE, bits); 14106 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 14107 HDA_AMP_MUTE, bits); 14108 } 14109 14110 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec, 14111 unsigned int res) 14112 { 14113 if ((res >> 26) == ALC880_HP_EVENT) 14114 alc662_lenovo_101e_all_automute(codec); 14115 if ((res >> 26) == ALC880_FRONT_EVENT) 14116 alc662_lenovo_101e_ispeaker_automute(codec); 14117 } 14118 14119 static void alc662_eeepc_mic_automute(struct hda_codec *codec) 14120 { 14121 unsigned int present; 14122 14123 present = snd_hda_codec_read(codec, 0x18, 0, 14124 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 14125 snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE, 14126 0x7000 | (0x00 << 8) | (present ? 0 : 0x80)); 14127 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE, 14128 0x7000 | (0x00 << 8) | (present ? 0 : 0x80)); 14129 snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE, 14130 0x7000 | (0x01 << 8) | (present ? 0x80 : 0)); 14131 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE, 14132 0x7000 | (0x01 << 8) | (present ? 0x80 : 0)); 14133 } 14134 14135 /* unsolicited event for HP jack sensing */ 14136 static void alc662_eeepc_unsol_event(struct hda_codec *codec, 14137 unsigned int res) 14138 { 14139 if ((res >> 26) == ALC880_HP_EVENT) 14140 alc262_hippo1_automute( codec ); 14141 14142 if ((res >> 26) == ALC880_MIC_EVENT) 14143 alc662_eeepc_mic_automute(codec); 14144 } 14145 14146 static void alc662_eeepc_inithook(struct hda_codec *codec) 14147 { 14148 alc262_hippo1_automute( codec ); 14149 alc662_eeepc_mic_automute(codec); 14150 } 14151 14152 static void alc662_eeepc_ep20_automute(struct hda_codec *codec) 14153 { 14154 unsigned int mute; 14155 unsigned int present; 14156 14157 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0); 14158 present = snd_hda_codec_read(codec, 0x14, 0, 14159 AC_VERB_GET_PIN_SENSE, 0); 14160 present = (present & 0x80000000) != 0; 14161 if (present) { 14162 /* mute internal speaker */ 14163 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 14164 HDA_AMP_MUTE, HDA_AMP_MUTE); 14165 } else { 14166 /* unmute internal speaker if necessary */ 14167 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0); 14168 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 14169 HDA_AMP_MUTE, mute); 14170 } 14171 } 14172 14173 /* unsolicited event for HP jack sensing */ 14174 static void alc662_eeepc_ep20_unsol_event(struct hda_codec *codec, 14175 unsigned int res) 14176 { 14177 if ((res >> 26) == ALC880_HP_EVENT) 14178 alc662_eeepc_ep20_automute(codec); 14179 } 14180 14181 static void alc662_eeepc_ep20_inithook(struct hda_codec *codec) 14182 { 14183 alc662_eeepc_ep20_automute(codec); 14184 } 14185 14186 static void alc663_m51va_speaker_automute(struct hda_codec *codec) 14187 { 14188 unsigned int present; 14189 unsigned char bits; 14190 14191 present = snd_hda_codec_read(codec, 0x21, 0, 14192 AC_VERB_GET_PIN_SENSE, 0) 14193 & AC_PINSENSE_PRESENCE; 14194 bits = present ? HDA_AMP_MUTE : 0; 14195 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 14196 HDA_AMP_MUTE, bits); 14197 } 14198 14199 static void alc663_m51va_mic_automute(struct hda_codec *codec) 14200 { 14201 unsigned int present; 14202 14203 present = snd_hda_codec_read(codec, 0x18, 0, 14204 AC_VERB_GET_PIN_SENSE, 0) 14205 & AC_PINSENSE_PRESENCE; 14206 snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE, 14207 0x7000 | (0x00 << 8) | (present ? 0 : 0x80)); 14208 snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE, 14209 0x7000 | (0x00 << 8) | (present ? 0 : 0x80)); 14210 snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE, 14211 0x7000 | (0x09 << 8) | (present ? 0x80 : 0)); 14212 snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE, 14213 0x7000 | (0x09 << 8) | (present ? 0x80 : 0)); 14214 } 14215 14216 static void alc663_m51va_unsol_event(struct hda_codec *codec, 14217 unsigned int res) 14218 { 14219 switch (res >> 26) { 14220 case ALC880_HP_EVENT: 14221 alc663_m51va_speaker_automute(codec); 14222 break; 14223 case ALC880_MIC_EVENT: 14224 alc663_m51va_mic_automute(codec); 14225 break; 14226 } 14227 } 14228 14229 static void alc663_m51va_inithook(struct hda_codec *codec) 14230 { 14231 alc663_m51va_speaker_automute(codec); 14232 alc663_m51va_mic_automute(codec); 14233 } 14234 14235 static void alc663_g71v_hp_automute(struct hda_codec *codec) 14236 { 14237 unsigned int present; 14238 unsigned char bits; 14239 14240 present = snd_hda_codec_read(codec, 0x21, 0, 14241 AC_VERB_GET_PIN_SENSE, 0) 14242 & AC_PINSENSE_PRESENCE; 14243 bits = present ? HDA_AMP_MUTE : 0; 14244 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 14245 HDA_AMP_MUTE, bits); 14246 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 14247 HDA_AMP_MUTE, bits); 14248 } 14249 14250 static void alc663_g71v_front_automute(struct hda_codec *codec) 14251 { 14252 unsigned int present; 14253 unsigned char bits; 14254 14255 present = snd_hda_codec_read(codec, 0x15, 0, 14256 AC_VERB_GET_PIN_SENSE, 0) 14257 & AC_PINSENSE_PRESENCE; 14258 bits = present ? HDA_AMP_MUTE : 0; 14259 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 14260 HDA_AMP_MUTE, bits); 14261 } 14262 14263 static void alc663_g71v_unsol_event(struct hda_codec *codec, 14264 unsigned int res) 14265 { 14266 switch (res >> 26) { 14267 case ALC880_HP_EVENT: 14268 alc663_g71v_hp_automute(codec); 14269 break; 14270 case ALC880_FRONT_EVENT: 14271 alc663_g71v_front_automute(codec); 14272 break; 14273 case ALC880_MIC_EVENT: 14274 alc662_eeepc_mic_automute(codec); 14275 break; 14276 } 14277 } 14278 14279 static void alc663_g71v_inithook(struct hda_codec *codec) 14280 { 14281 alc663_g71v_front_automute(codec); 14282 alc663_g71v_hp_automute(codec); 14283 alc662_eeepc_mic_automute(codec); 14284 } 14285 14286 static void alc663_g50v_unsol_event(struct hda_codec *codec, 14287 unsigned int res) 14288 { 14289 switch (res >> 26) { 14290 case ALC880_HP_EVENT: 14291 alc663_m51va_speaker_automute(codec); 14292 break; 14293 case ALC880_MIC_EVENT: 14294 alc662_eeepc_mic_automute(codec); 14295 break; 14296 } 14297 } 14298 14299 static void alc663_g50v_inithook(struct hda_codec *codec) 14300 { 14301 alc663_m51va_speaker_automute(codec); 14302 alc662_eeepc_mic_automute(codec); 14303 } 14304 14305 #ifdef CONFIG_SND_HDA_POWER_SAVE 14306 #define alc662_loopbacks alc880_loopbacks 14307 #endif 14308 14309 14310 /* pcm configuration: identiacal with ALC880 */ 14311 #define alc662_pcm_analog_playback alc880_pcm_analog_playback 14312 #define alc662_pcm_analog_capture alc880_pcm_analog_capture 14313 #define alc662_pcm_digital_playback alc880_pcm_digital_playback 14314 #define alc662_pcm_digital_capture alc880_pcm_digital_capture 14315 14316 /* 14317 * configuration and preset 14318 */ 14319 static const char *alc662_models[ALC662_MODEL_LAST] = { 14320 [ALC662_3ST_2ch_DIG] = "3stack-dig", 14321 [ALC662_3ST_6ch_DIG] = "3stack-6ch-dig", 14322 [ALC662_3ST_6ch] = "3stack-6ch", 14323 [ALC662_5ST_DIG] = "6stack-dig", 14324 [ALC662_LENOVO_101E] = "lenovo-101e", 14325 [ALC662_ASUS_EEEPC_P701] = "eeepc-p701", 14326 [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20", 14327 [ALC663_ASUS_M51VA] = "m51va", 14328 [ALC663_ASUS_G71V] = "g71v", 14329 [ALC663_ASUS_H13] = "h13", 14330 [ALC663_ASUS_G50V] = "g50v", 14331 [ALC662_AUTO] = "auto", 14332 }; 14333 14334 static struct snd_pci_quirk alc662_cfg_tbl[] = { 14335 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS G71V", ALC663_ASUS_G71V), 14336 SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA), 14337 SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS M51VA", ALC663_ASUS_G50V), 14338 SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG), 14339 SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701), 14340 SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20), 14341 SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E), 14342 SND_PCI_QUIRK(0x1854, 0x2000, "ASUS H13-2000", ALC663_ASUS_H13), 14343 SND_PCI_QUIRK(0x1854, 0x2001, "ASUS H13-2001", ALC663_ASUS_H13), 14344 SND_PCI_QUIRK(0x1854, 0x2002, "ASUS H13-2002", ALC663_ASUS_H13), 14345 {} 14346 }; 14347 14348 static struct alc_config_preset alc662_presets[] = { 14349 [ALC662_3ST_2ch_DIG] = { 14350 .mixers = { alc662_3ST_2ch_mixer, alc662_capture_mixer }, 14351 .init_verbs = { alc662_init_verbs }, 14352 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 14353 .dac_nids = alc662_dac_nids, 14354 .dig_out_nid = ALC662_DIGOUT_NID, 14355 .dig_in_nid = ALC662_DIGIN_NID, 14356 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 14357 .channel_mode = alc662_3ST_2ch_modes, 14358 .input_mux = &alc662_capture_source, 14359 }, 14360 [ALC662_3ST_6ch_DIG] = { 14361 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer, 14362 alc662_capture_mixer }, 14363 .init_verbs = { alc662_init_verbs }, 14364 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 14365 .dac_nids = alc662_dac_nids, 14366 .dig_out_nid = ALC662_DIGOUT_NID, 14367 .dig_in_nid = ALC662_DIGIN_NID, 14368 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes), 14369 .channel_mode = alc662_3ST_6ch_modes, 14370 .need_dac_fix = 1, 14371 .input_mux = &alc662_capture_source, 14372 }, 14373 [ALC662_3ST_6ch] = { 14374 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer, 14375 alc662_capture_mixer }, 14376 .init_verbs = { alc662_init_verbs }, 14377 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 14378 .dac_nids = alc662_dac_nids, 14379 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes), 14380 .channel_mode = alc662_3ST_6ch_modes, 14381 .need_dac_fix = 1, 14382 .input_mux = &alc662_capture_source, 14383 }, 14384 [ALC662_5ST_DIG] = { 14385 .mixers = { alc662_base_mixer, alc662_chmode_mixer, 14386 alc662_capture_mixer }, 14387 .init_verbs = { alc662_init_verbs }, 14388 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 14389 .dac_nids = alc662_dac_nids, 14390 .dig_out_nid = ALC662_DIGOUT_NID, 14391 .dig_in_nid = ALC662_DIGIN_NID, 14392 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes), 14393 .channel_mode = alc662_5stack_modes, 14394 .input_mux = &alc662_capture_source, 14395 }, 14396 [ALC662_LENOVO_101E] = { 14397 .mixers = { alc662_lenovo_101e_mixer, alc662_capture_mixer }, 14398 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs }, 14399 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 14400 .dac_nids = alc662_dac_nids, 14401 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 14402 .channel_mode = alc662_3ST_2ch_modes, 14403 .input_mux = &alc662_lenovo_101e_capture_source, 14404 .unsol_event = alc662_lenovo_101e_unsol_event, 14405 .init_hook = alc662_lenovo_101e_all_automute, 14406 }, 14407 [ALC662_ASUS_EEEPC_P701] = { 14408 .mixers = { alc662_eeepc_p701_mixer, alc662_capture_mixer }, 14409 .init_verbs = { alc662_init_verbs, 14410 alc662_eeepc_sue_init_verbs }, 14411 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 14412 .dac_nids = alc662_dac_nids, 14413 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 14414 .channel_mode = alc662_3ST_2ch_modes, 14415 .input_mux = &alc662_eeepc_capture_source, 14416 .unsol_event = alc662_eeepc_unsol_event, 14417 .init_hook = alc662_eeepc_inithook, 14418 }, 14419 [ALC662_ASUS_EEEPC_EP20] = { 14420 .mixers = { alc662_eeepc_ep20_mixer, alc662_capture_mixer, 14421 alc662_chmode_mixer }, 14422 .init_verbs = { alc662_init_verbs, 14423 alc662_eeepc_ep20_sue_init_verbs }, 14424 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 14425 .dac_nids = alc662_dac_nids, 14426 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes), 14427 .channel_mode = alc662_3ST_6ch_modes, 14428 .input_mux = &alc662_lenovo_101e_capture_source, 14429 .unsol_event = alc662_eeepc_ep20_unsol_event, 14430 .init_hook = alc662_eeepc_ep20_inithook, 14431 }, 14432 [ALC663_ASUS_M51VA] = { 14433 .mixers = { alc663_m51va_mixer, alc662_capture_mixer}, 14434 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs }, 14435 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 14436 .dac_nids = alc662_dac_nids, 14437 .dig_out_nid = ALC662_DIGOUT_NID, 14438 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 14439 .channel_mode = alc662_3ST_2ch_modes, 14440 .input_mux = &alc663_m51va_capture_source, 14441 .unsol_event = alc663_m51va_unsol_event, 14442 .init_hook = alc663_m51va_inithook, 14443 }, 14444 [ALC663_ASUS_G71V] = { 14445 .mixers = { alc663_g71v_mixer, alc662_capture_mixer}, 14446 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs }, 14447 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 14448 .dac_nids = alc662_dac_nids, 14449 .dig_out_nid = ALC662_DIGOUT_NID, 14450 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 14451 .channel_mode = alc662_3ST_2ch_modes, 14452 .input_mux = &alc662_eeepc_capture_source, 14453 .unsol_event = alc663_g71v_unsol_event, 14454 .init_hook = alc663_g71v_inithook, 14455 }, 14456 [ALC663_ASUS_H13] = { 14457 .mixers = { alc663_m51va_mixer, alc662_capture_mixer}, 14458 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs }, 14459 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 14460 .dac_nids = alc662_dac_nids, 14461 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 14462 .channel_mode = alc662_3ST_2ch_modes, 14463 .input_mux = &alc663_m51va_capture_source, 14464 .unsol_event = alc663_m51va_unsol_event, 14465 .init_hook = alc663_m51va_inithook, 14466 }, 14467 [ALC663_ASUS_G50V] = { 14468 .mixers = { alc663_g50v_mixer, alc662_capture_mixer}, 14469 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs }, 14470 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 14471 .dac_nids = alc662_dac_nids, 14472 .dig_out_nid = ALC662_DIGOUT_NID, 14473 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes), 14474 .channel_mode = alc662_3ST_6ch_modes, 14475 .input_mux = &alc663_capture_source, 14476 .unsol_event = alc663_g50v_unsol_event, 14477 .init_hook = alc663_g50v_inithook, 14478 }, 14479 }; 14480 14481 14482 /* 14483 * BIOS auto configuration 14484 */ 14485 14486 /* add playback controls from the parsed DAC table */ 14487 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec, 14488 const struct auto_pin_cfg *cfg) 14489 { 14490 char name[32]; 14491 static const char *chname[4] = { 14492 "Front", "Surround", NULL /*CLFE*/, "Side" 14493 }; 14494 hda_nid_t nid; 14495 int i, err; 14496 14497 for (i = 0; i < cfg->line_outs; i++) { 14498 if (!spec->multiout.dac_nids[i]) 14499 continue; 14500 nid = alc880_idx_to_dac(i); 14501 if (i == 2) { 14502 /* Center/LFE */ 14503 err = add_control(spec, ALC_CTL_WIDGET_VOL, 14504 "Center Playback Volume", 14505 HDA_COMPOSE_AMP_VAL(nid, 1, 0, 14506 HDA_OUTPUT)); 14507 if (err < 0) 14508 return err; 14509 err = add_control(spec, ALC_CTL_WIDGET_VOL, 14510 "LFE Playback Volume", 14511 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 14512 HDA_OUTPUT)); 14513 if (err < 0) 14514 return err; 14515 err = add_control(spec, ALC_CTL_BIND_MUTE, 14516 "Center Playback Switch", 14517 HDA_COMPOSE_AMP_VAL(nid, 1, 2, 14518 HDA_INPUT)); 14519 if (err < 0) 14520 return err; 14521 err = add_control(spec, ALC_CTL_BIND_MUTE, 14522 "LFE Playback Switch", 14523 HDA_COMPOSE_AMP_VAL(nid, 2, 2, 14524 HDA_INPUT)); 14525 if (err < 0) 14526 return err; 14527 } else { 14528 sprintf(name, "%s Playback Volume", chname[i]); 14529 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 14530 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 14531 HDA_OUTPUT)); 14532 if (err < 0) 14533 return err; 14534 sprintf(name, "%s Playback Switch", chname[i]); 14535 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 14536 HDA_COMPOSE_AMP_VAL(nid, 3, 2, 14537 HDA_INPUT)); 14538 if (err < 0) 14539 return err; 14540 } 14541 } 14542 return 0; 14543 } 14544 14545 /* add playback controls for speaker and HP outputs */ 14546 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin, 14547 const char *pfx) 14548 { 14549 hda_nid_t nid; 14550 int err; 14551 char name[32]; 14552 14553 if (!pin) 14554 return 0; 14555 14556 if (alc880_is_fixed_pin(pin)) { 14557 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin)); 14558 /* printk("DAC nid=%x\n",nid); */ 14559 /* specify the DAC as the extra output */ 14560 if (!spec->multiout.hp_nid) 14561 spec->multiout.hp_nid = nid; 14562 else 14563 spec->multiout.extra_out_nid[0] = nid; 14564 /* control HP volume/switch on the output mixer amp */ 14565 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin)); 14566 sprintf(name, "%s Playback Volume", pfx); 14567 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 14568 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 14569 if (err < 0) 14570 return err; 14571 sprintf(name, "%s Playback Switch", pfx); 14572 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 14573 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT)); 14574 if (err < 0) 14575 return err; 14576 } else if (alc880_is_multi_pin(pin)) { 14577 /* set manual connection */ 14578 /* we have only a switch on HP-out PIN */ 14579 sprintf(name, "%s Playback Switch", pfx); 14580 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 14581 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 14582 if (err < 0) 14583 return err; 14584 } 14585 return 0; 14586 } 14587 14588 /* create playback/capture controls for input pins */ 14589 static int alc662_auto_create_analog_input_ctls(struct alc_spec *spec, 14590 const struct auto_pin_cfg *cfg) 14591 { 14592 struct hda_input_mux *imux = &spec->private_imux; 14593 int i, err, idx; 14594 14595 for (i = 0; i < AUTO_PIN_LAST; i++) { 14596 if (alc880_is_input_pin(cfg->input_pins[i])) { 14597 idx = alc880_input_pin_idx(cfg->input_pins[i]); 14598 err = new_analog_input(spec, cfg->input_pins[i], 14599 auto_pin_cfg_labels[i], 14600 idx, 0x0b); 14601 if (err < 0) 14602 return err; 14603 imux->items[imux->num_items].label = 14604 auto_pin_cfg_labels[i]; 14605 imux->items[imux->num_items].index = 14606 alc880_input_pin_idx(cfg->input_pins[i]); 14607 imux->num_items++; 14608 } 14609 } 14610 return 0; 14611 } 14612 14613 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec, 14614 hda_nid_t nid, int pin_type, 14615 int dac_idx) 14616 { 14617 alc_set_pin_output(codec, nid, pin_type); 14618 /* need the manual connection? */ 14619 if (alc880_is_multi_pin(nid)) { 14620 struct alc_spec *spec = codec->spec; 14621 int idx = alc880_multi_pin_idx(nid); 14622 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0, 14623 AC_VERB_SET_CONNECT_SEL, 14624 alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx])); 14625 } 14626 } 14627 14628 static void alc662_auto_init_multi_out(struct hda_codec *codec) 14629 { 14630 struct alc_spec *spec = codec->spec; 14631 int i; 14632 14633 alc_subsystem_id(codec, 0x15, 0x1b, 0x14); 14634 for (i = 0; i <= HDA_SIDE; i++) { 14635 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 14636 int pin_type = get_pin_type(spec->autocfg.line_out_type); 14637 if (nid) 14638 alc662_auto_set_output_and_unmute(codec, nid, pin_type, 14639 i); 14640 } 14641 } 14642 14643 static void alc662_auto_init_hp_out(struct hda_codec *codec) 14644 { 14645 struct alc_spec *spec = codec->spec; 14646 hda_nid_t pin; 14647 14648 pin = spec->autocfg.hp_pins[0]; 14649 if (pin) /* connect to front */ 14650 /* use dac 0 */ 14651 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 14652 pin = spec->autocfg.speaker_pins[0]; 14653 if (pin) 14654 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 14655 } 14656 14657 #define alc662_is_input_pin(nid) alc880_is_input_pin(nid) 14658 #define ALC662_PIN_CD_NID ALC880_PIN_CD_NID 14659 14660 static void alc662_auto_init_analog_input(struct hda_codec *codec) 14661 { 14662 struct alc_spec *spec = codec->spec; 14663 int i; 14664 14665 for (i = 0; i < AUTO_PIN_LAST; i++) { 14666 hda_nid_t nid = spec->autocfg.input_pins[i]; 14667 if (alc662_is_input_pin(nid)) { 14668 snd_hda_codec_write(codec, nid, 0, 14669 AC_VERB_SET_PIN_WIDGET_CONTROL, 14670 (i <= AUTO_PIN_FRONT_MIC ? 14671 PIN_VREF80 : PIN_IN)); 14672 if (nid != ALC662_PIN_CD_NID) 14673 snd_hda_codec_write(codec, nid, 0, 14674 AC_VERB_SET_AMP_GAIN_MUTE, 14675 AMP_OUT_MUTE); 14676 } 14677 } 14678 } 14679 14680 static int alc662_parse_auto_config(struct hda_codec *codec) 14681 { 14682 struct alc_spec *spec = codec->spec; 14683 int err; 14684 static hda_nid_t alc662_ignore[] = { 0x1d, 0 }; 14685 14686 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 14687 alc662_ignore); 14688 if (err < 0) 14689 return err; 14690 if (!spec->autocfg.line_outs) 14691 return 0; /* can't find valid BIOS pin config */ 14692 14693 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg); 14694 if (err < 0) 14695 return err; 14696 err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg); 14697 if (err < 0) 14698 return err; 14699 err = alc662_auto_create_extra_out(spec, 14700 spec->autocfg.speaker_pins[0], 14701 "Speaker"); 14702 if (err < 0) 14703 return err; 14704 err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0], 14705 "Headphone"); 14706 if (err < 0) 14707 return err; 14708 err = alc662_auto_create_analog_input_ctls(spec, &spec->autocfg); 14709 if (err < 0) 14710 return err; 14711 14712 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 14713 14714 if (spec->autocfg.dig_out_pin) 14715 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID; 14716 14717 if (spec->kctl_alloc) 14718 spec->mixers[spec->num_mixers++] = spec->kctl_alloc; 14719 14720 spec->num_mux_defs = 1; 14721 spec->input_mux = &spec->private_imux; 14722 14723 spec->init_verbs[spec->num_init_verbs++] = alc662_auto_init_verbs; 14724 spec->mixers[spec->num_mixers] = alc662_capture_mixer; 14725 spec->num_mixers++; 14726 return 1; 14727 } 14728 14729 /* additional initialization for auto-configuration model */ 14730 static void alc662_auto_init(struct hda_codec *codec) 14731 { 14732 struct alc_spec *spec = codec->spec; 14733 alc662_auto_init_multi_out(codec); 14734 alc662_auto_init_hp_out(codec); 14735 alc662_auto_init_analog_input(codec); 14736 if (spec->unsol_event) 14737 alc_sku_automute(codec); 14738 } 14739 14740 static int patch_alc662(struct hda_codec *codec) 14741 { 14742 struct alc_spec *spec; 14743 int err, board_config; 14744 14745 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 14746 if (!spec) 14747 return -ENOMEM; 14748 14749 codec->spec = spec; 14750 14751 alc_fix_pll_init(codec, 0x20, 0x04, 15); 14752 14753 board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST, 14754 alc662_models, 14755 alc662_cfg_tbl); 14756 if (board_config < 0) { 14757 printk(KERN_INFO "hda_codec: Unknown model for ALC662, " 14758 "trying auto-probe from BIOS...\n"); 14759 board_config = ALC662_AUTO; 14760 } 14761 14762 if (board_config == ALC662_AUTO) { 14763 /* automatic parse from the BIOS config */ 14764 err = alc662_parse_auto_config(codec); 14765 if (err < 0) { 14766 alc_free(codec); 14767 return err; 14768 } else if (!err) { 14769 printk(KERN_INFO 14770 "hda_codec: Cannot set up configuration " 14771 "from BIOS. Using base mode...\n"); 14772 board_config = ALC662_3ST_2ch_DIG; 14773 } 14774 } 14775 14776 if (board_config != ALC662_AUTO) 14777 setup_preset(spec, &alc662_presets[board_config]); 14778 14779 if (codec->vendor_id == 0x10ec0663) { 14780 spec->stream_name_analog = "ALC663 Analog"; 14781 spec->stream_name_digital = "ALC663 Digital"; 14782 } else { 14783 spec->stream_name_analog = "ALC662 Analog"; 14784 spec->stream_name_digital = "ALC662 Digital"; 14785 } 14786 14787 spec->stream_analog_playback = &alc662_pcm_analog_playback; 14788 spec->stream_analog_capture = &alc662_pcm_analog_capture; 14789 14790 spec->stream_digital_playback = &alc662_pcm_digital_playback; 14791 spec->stream_digital_capture = &alc662_pcm_digital_capture; 14792 14793 spec->adc_nids = alc662_adc_nids; 14794 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids); 14795 spec->capsrc_nids = alc662_capsrc_nids; 14796 14797 spec->vmaster_nid = 0x02; 14798 14799 codec->patch_ops = alc_patch_ops; 14800 if (board_config == ALC662_AUTO) 14801 spec->init_hook = alc662_auto_init; 14802 #ifdef CONFIG_SND_HDA_POWER_SAVE 14803 if (!spec->loopback.amplist) 14804 spec->loopback.amplist = alc662_loopbacks; 14805 #endif 14806 14807 return 0; 14808 } 14809 14810 /* 14811 * patch entries 14812 */ 14813 struct hda_codec_preset snd_hda_preset_realtek[] = { 14814 { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 }, 14815 { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 }, 14816 { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 }, 14817 { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 }, 14818 { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 }, 14819 { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660", 14820 .patch = patch_alc861 }, 14821 { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd }, 14822 { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 }, 14823 { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd }, 14824 { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2", 14825 .patch = patch_alc883 }, 14826 { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1", 14827 .patch = patch_alc662 }, 14828 { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 }, 14829 { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 }, 14830 { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 }, 14831 { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 }, 14832 { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A", 14833 .patch = patch_alc882 }, /* should be patch_alc883() in future */ 14834 { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 }, 14835 { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 }, 14836 { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 }, 14837 {} /* terminator */ 14838 }; 14839