patch_realtek.c revision 45bdd1c1bbac56876cb9c71649300013281e4b22
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_beep.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 */ 41enum { 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 */ 72enum { 73 ALC260_BASIC, 74 ALC260_HP, 75 ALC260_HP_DC7600, 76 ALC260_HP_3013, 77 ALC260_FUJITSU_S702X, 78 ALC260_ACER, 79 ALC260_WILL, 80 ALC260_REPLACER_672V, 81#ifdef CONFIG_SND_DEBUG 82 ALC260_TEST, 83#endif 84 ALC260_AUTO, 85 ALC260_MODEL_LAST /* last tag */ 86}; 87 88/* ALC262 models */ 89enum { 90 ALC262_BASIC, 91 ALC262_HIPPO, 92 ALC262_HIPPO_1, 93 ALC262_FUJITSU, 94 ALC262_HP_BPC, 95 ALC262_HP_BPC_D7000_WL, 96 ALC262_HP_BPC_D7000_WF, 97 ALC262_HP_TC_T5735, 98 ALC262_HP_RP5700, 99 ALC262_BENQ_ED8, 100 ALC262_SONY_ASSAMD, 101 ALC262_BENQ_T31, 102 ALC262_ULTRA, 103 ALC262_LENOVO_3000, 104 ALC262_NEC, 105 ALC262_TOSHIBA_S06, 106 ALC262_TOSHIBA_RX1, 107 ALC262_TYAN, 108 ALC262_AUTO, 109 ALC262_MODEL_LAST /* last tag */ 110}; 111 112/* ALC268 models */ 113enum { 114 ALC267_QUANTA_IL1, 115 ALC268_3ST, 116 ALC268_TOSHIBA, 117 ALC268_ACER, 118 ALC268_ACER_DMIC, 119 ALC268_ACER_ASPIRE_ONE, 120 ALC268_DELL, 121 ALC268_ZEPTO, 122#ifdef CONFIG_SND_DEBUG 123 ALC268_TEST, 124#endif 125 ALC268_AUTO, 126 ALC268_MODEL_LAST /* last tag */ 127}; 128 129/* ALC269 models */ 130enum { 131 ALC269_BASIC, 132 ALC269_QUANTA_FL1, 133 ALC269_ASUS_EEEPC_P703, 134 ALC269_ASUS_EEEPC_P901, 135 ALC269_FUJITSU, 136 ALC269_LIFEBOOK, 137 ALC269_AUTO, 138 ALC269_MODEL_LAST /* last tag */ 139}; 140 141/* ALC861 models */ 142enum { 143 ALC861_3ST, 144 ALC660_3ST, 145 ALC861_3ST_DIG, 146 ALC861_6ST_DIG, 147 ALC861_UNIWILL_M31, 148 ALC861_TOSHIBA, 149 ALC861_ASUS, 150 ALC861_ASUS_LAPTOP, 151 ALC861_AUTO, 152 ALC861_MODEL_LAST, 153}; 154 155/* ALC861-VD models */ 156enum { 157 ALC660VD_3ST, 158 ALC660VD_3ST_DIG, 159 ALC660VD_ASUS_V1S, 160 ALC861VD_3ST, 161 ALC861VD_3ST_DIG, 162 ALC861VD_6ST_DIG, 163 ALC861VD_LENOVO, 164 ALC861VD_DALLAS, 165 ALC861VD_HP, 166 ALC861VD_AUTO, 167 ALC861VD_MODEL_LAST, 168}; 169 170/* ALC662 models */ 171enum { 172 ALC662_3ST_2ch_DIG, 173 ALC662_3ST_6ch_DIG, 174 ALC662_3ST_6ch, 175 ALC662_5ST_DIG, 176 ALC662_LENOVO_101E, 177 ALC662_ASUS_EEEPC_P701, 178 ALC662_ASUS_EEEPC_EP20, 179 ALC663_ASUS_M51VA, 180 ALC663_ASUS_G71V, 181 ALC663_ASUS_H13, 182 ALC663_ASUS_G50V, 183 ALC662_ECS, 184 ALC663_ASUS_MODE1, 185 ALC662_ASUS_MODE2, 186 ALC663_ASUS_MODE3, 187 ALC663_ASUS_MODE4, 188 ALC663_ASUS_MODE5, 189 ALC663_ASUS_MODE6, 190 ALC662_AUTO, 191 ALC662_MODEL_LAST, 192}; 193 194/* ALC882 models */ 195enum { 196 ALC882_3ST_DIG, 197 ALC882_6ST_DIG, 198 ALC882_ARIMA, 199 ALC882_W2JC, 200 ALC882_TARGA, 201 ALC882_ASUS_A7J, 202 ALC882_ASUS_A7M, 203 ALC885_MACPRO, 204 ALC885_MBP3, 205 ALC885_IMAC24, 206 ALC882_AUTO, 207 ALC882_MODEL_LAST, 208}; 209 210/* ALC883 models */ 211enum { 212 ALC883_3ST_2ch_DIG, 213 ALC883_3ST_6ch_DIG, 214 ALC883_3ST_6ch, 215 ALC883_6ST_DIG, 216 ALC883_TARGA_DIG, 217 ALC883_TARGA_2ch_DIG, 218 ALC883_ACER, 219 ALC883_ACER_ASPIRE, 220 ALC888_ACER_ASPIRE_4930G, 221 ALC883_MEDION, 222 ALC883_MEDION_MD2, 223 ALC883_LAPTOP_EAPD, 224 ALC883_LENOVO_101E_2ch, 225 ALC883_LENOVO_NB0763, 226 ALC888_LENOVO_MS7195_DIG, 227 ALC888_LENOVO_SKY, 228 ALC883_HAIER_W66, 229 ALC888_3ST_HP, 230 ALC888_6ST_DELL, 231 ALC883_MITAC, 232 ALC883_CLEVO_M720, 233 ALC883_FUJITSU_PI2515, 234 ALC888_FUJITSU_XA3530, 235 ALC883_3ST_6ch_INTEL, 236 ALC888_ASUS_M90V, 237 ALC888_ASUS_EEE1601, 238 ALC1200_ASUS_P5Q, 239 ALC883_AUTO, 240 ALC883_MODEL_LAST, 241}; 242 243/* styles of capture selection */ 244enum { 245 CAPT_MUX = 0, /* only mux based */ 246 CAPT_MIX, /* only mixer based */ 247 CAPT_1MUX_MIX, /* first mux and other mixers */ 248}; 249 250/* for GPIO Poll */ 251#define GPIO_MASK 0x03 252 253struct alc_spec { 254 /* codec parameterization */ 255 struct snd_kcontrol_new *mixers[5]; /* mixer arrays */ 256 unsigned int num_mixers; 257 struct snd_kcontrol_new *cap_mixer; /* capture mixer */ 258 unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */ 259 260 const struct hda_verb *init_verbs[5]; /* initialization verbs 261 * don't forget NULL 262 * termination! 263 */ 264 unsigned int num_init_verbs; 265 266 char *stream_name_analog; /* analog PCM stream */ 267 struct hda_pcm_stream *stream_analog_playback; 268 struct hda_pcm_stream *stream_analog_capture; 269 struct hda_pcm_stream *stream_analog_alt_playback; 270 struct hda_pcm_stream *stream_analog_alt_capture; 271 272 char *stream_name_digital; /* digital PCM stream */ 273 struct hda_pcm_stream *stream_digital_playback; 274 struct hda_pcm_stream *stream_digital_capture; 275 276 /* playback */ 277 struct hda_multi_out multiout; /* playback set-up 278 * max_channels, dacs must be set 279 * dig_out_nid and hp_nid are optional 280 */ 281 hda_nid_t alt_dac_nid; 282 int dig_out_type; 283 284 /* capture */ 285 unsigned int num_adc_nids; 286 hda_nid_t *adc_nids; 287 hda_nid_t *capsrc_nids; 288 hda_nid_t dig_in_nid; /* digital-in NID; optional */ 289 int capture_style; /* capture style (CAPT_*) */ 290 291 /* capture source */ 292 unsigned int num_mux_defs; 293 const struct hda_input_mux *input_mux; 294 unsigned int cur_mux[3]; 295 296 /* channel model */ 297 const struct hda_channel_mode *channel_mode; 298 int num_channel_mode; 299 int need_dac_fix; 300 301 /* PCM information */ 302 struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */ 303 304 /* dynamic controls, init_verbs and input_mux */ 305 struct auto_pin_cfg autocfg; 306 struct snd_array kctls; 307 struct hda_input_mux private_imux[3]; 308 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS]; 309 310 /* hooks */ 311 void (*init_hook)(struct hda_codec *codec); 312 void (*unsol_event)(struct hda_codec *codec, unsigned int res); 313 314 /* for pin sensing */ 315 unsigned int sense_updated: 1; 316 unsigned int jack_present: 1; 317 unsigned int master_sw: 1; 318 319 /* other flags */ 320 unsigned int no_analog :1; /* digital I/O only */ 321 322 /* for virtual master */ 323 hda_nid_t vmaster_nid; 324#ifdef CONFIG_SND_HDA_POWER_SAVE 325 struct hda_loopback_check loopback; 326#endif 327 328 /* for PLL fix */ 329 hda_nid_t pll_nid; 330 unsigned int pll_coef_idx, pll_coef_bit; 331 332#ifdef SND_HDA_NEEDS_RESUME 333#define ALC_MAX_PINS 16 334 unsigned int num_pins; 335 hda_nid_t pin_nids[ALC_MAX_PINS]; 336 unsigned int pin_cfgs[ALC_MAX_PINS]; 337#endif 338}; 339 340/* 341 * configuration template - to be copied to the spec instance 342 */ 343struct alc_config_preset { 344 struct snd_kcontrol_new *mixers[5]; /* should be identical size 345 * with spec 346 */ 347 struct snd_kcontrol_new *cap_mixer; /* capture mixer */ 348 const struct hda_verb *init_verbs[5]; 349 unsigned int num_dacs; 350 hda_nid_t *dac_nids; 351 hda_nid_t dig_out_nid; /* optional */ 352 hda_nid_t hp_nid; /* optional */ 353 hda_nid_t *slave_dig_outs; 354 unsigned int num_adc_nids; 355 hda_nid_t *adc_nids; 356 hda_nid_t *capsrc_nids; 357 hda_nid_t dig_in_nid; 358 unsigned int num_channel_mode; 359 const struct hda_channel_mode *channel_mode; 360 int need_dac_fix; 361 unsigned int num_mux_defs; 362 const struct hda_input_mux *input_mux; 363 void (*unsol_event)(struct hda_codec *, unsigned int); 364 void (*init_hook)(struct hda_codec *); 365#ifdef CONFIG_SND_HDA_POWER_SAVE 366 struct hda_amp_list *loopbacks; 367#endif 368}; 369 370 371/* 372 * input MUX handling 373 */ 374static int alc_mux_enum_info(struct snd_kcontrol *kcontrol, 375 struct snd_ctl_elem_info *uinfo) 376{ 377 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 378 struct alc_spec *spec = codec->spec; 379 unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id); 380 if (mux_idx >= spec->num_mux_defs) 381 mux_idx = 0; 382 return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo); 383} 384 385static int alc_mux_enum_get(struct snd_kcontrol *kcontrol, 386 struct snd_ctl_elem_value *ucontrol) 387{ 388 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 389 struct alc_spec *spec = codec->spec; 390 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 391 392 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx]; 393 return 0; 394} 395 396static int alc_mux_enum_put(struct snd_kcontrol *kcontrol, 397 struct snd_ctl_elem_value *ucontrol) 398{ 399 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 400 struct alc_spec *spec = codec->spec; 401 const struct hda_input_mux *imux; 402 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 403 unsigned int mux_idx; 404 hda_nid_t nid = spec->capsrc_nids ? 405 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx]; 406 407 mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx; 408 imux = &spec->input_mux[mux_idx]; 409 410 if (spec->capture_style && 411 !(spec->capture_style == CAPT_1MUX_MIX && !adc_idx)) { 412 /* Matrix-mixer style (e.g. ALC882) */ 413 unsigned int *cur_val = &spec->cur_mux[adc_idx]; 414 unsigned int i, idx; 415 416 idx = ucontrol->value.enumerated.item[0]; 417 if (idx >= imux->num_items) 418 idx = imux->num_items - 1; 419 if (*cur_val == idx) 420 return 0; 421 for (i = 0; i < imux->num_items; i++) { 422 unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE; 423 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 424 imux->items[i].index, 425 HDA_AMP_MUTE, v); 426 } 427 *cur_val = idx; 428 return 1; 429 } else { 430 /* MUX style (e.g. ALC880) */ 431 return snd_hda_input_mux_put(codec, imux, ucontrol, nid, 432 &spec->cur_mux[adc_idx]); 433 } 434} 435 436/* 437 * channel mode setting 438 */ 439static int alc_ch_mode_info(struct snd_kcontrol *kcontrol, 440 struct snd_ctl_elem_info *uinfo) 441{ 442 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 443 struct alc_spec *spec = codec->spec; 444 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode, 445 spec->num_channel_mode); 446} 447 448static int alc_ch_mode_get(struct snd_kcontrol *kcontrol, 449 struct snd_ctl_elem_value *ucontrol) 450{ 451 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 452 struct alc_spec *spec = codec->spec; 453 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode, 454 spec->num_channel_mode, 455 spec->multiout.max_channels); 456} 457 458static int alc_ch_mode_put(struct snd_kcontrol *kcontrol, 459 struct snd_ctl_elem_value *ucontrol) 460{ 461 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 462 struct alc_spec *spec = codec->spec; 463 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode, 464 spec->num_channel_mode, 465 &spec->multiout.max_channels); 466 if (err >= 0 && spec->need_dac_fix) 467 spec->multiout.num_dacs = spec->multiout.max_channels / 2; 468 return err; 469} 470 471/* 472 * Control the mode of pin widget settings via the mixer. "pc" is used 473 * instead of "%" to avoid consequences of accidently treating the % as 474 * being part of a format specifier. Maximum allowed length of a value is 475 * 63 characters plus NULL terminator. 476 * 477 * Note: some retasking pin complexes seem to ignore requests for input 478 * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these 479 * are requested. Therefore order this list so that this behaviour will not 480 * cause problems when mixer clients move through the enum sequentially. 481 * NIDs 0x0f and 0x10 have been observed to have this behaviour as of 482 * March 2006. 483 */ 484static char *alc_pin_mode_names[] = { 485 "Mic 50pc bias", "Mic 80pc bias", 486 "Line in", "Line out", "Headphone out", 487}; 488static unsigned char alc_pin_mode_values[] = { 489 PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP, 490}; 491/* The control can present all 5 options, or it can limit the options based 492 * in the pin being assumed to be exclusively an input or an output pin. In 493 * addition, "input" pins may or may not process the mic bias option 494 * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to 495 * accept requests for bias as of chip versions up to March 2006) and/or 496 * wiring in the computer. 497 */ 498#define ALC_PIN_DIR_IN 0x00 499#define ALC_PIN_DIR_OUT 0x01 500#define ALC_PIN_DIR_INOUT 0x02 501#define ALC_PIN_DIR_IN_NOMICBIAS 0x03 502#define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04 503 504/* Info about the pin modes supported by the different pin direction modes. 505 * For each direction the minimum and maximum values are given. 506 */ 507static signed char alc_pin_mode_dir_info[5][2] = { 508 { 0, 2 }, /* ALC_PIN_DIR_IN */ 509 { 3, 4 }, /* ALC_PIN_DIR_OUT */ 510 { 0, 4 }, /* ALC_PIN_DIR_INOUT */ 511 { 2, 2 }, /* ALC_PIN_DIR_IN_NOMICBIAS */ 512 { 2, 4 }, /* ALC_PIN_DIR_INOUT_NOMICBIAS */ 513}; 514#define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0]) 515#define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1]) 516#define alc_pin_mode_n_items(_dir) \ 517 (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1) 518 519static int alc_pin_mode_info(struct snd_kcontrol *kcontrol, 520 struct snd_ctl_elem_info *uinfo) 521{ 522 unsigned int item_num = uinfo->value.enumerated.item; 523 unsigned char dir = (kcontrol->private_value >> 16) & 0xff; 524 525 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 526 uinfo->count = 1; 527 uinfo->value.enumerated.items = alc_pin_mode_n_items(dir); 528 529 if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir)) 530 item_num = alc_pin_mode_min(dir); 531 strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]); 532 return 0; 533} 534 535static int alc_pin_mode_get(struct snd_kcontrol *kcontrol, 536 struct snd_ctl_elem_value *ucontrol) 537{ 538 unsigned int i; 539 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 540 hda_nid_t nid = kcontrol->private_value & 0xffff; 541 unsigned char dir = (kcontrol->private_value >> 16) & 0xff; 542 long *valp = ucontrol->value.integer.value; 543 unsigned int pinctl = snd_hda_codec_read(codec, nid, 0, 544 AC_VERB_GET_PIN_WIDGET_CONTROL, 545 0x00); 546 547 /* Find enumerated value for current pinctl setting */ 548 i = alc_pin_mode_min(dir); 549 while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir)) 550 i++; 551 *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir); 552 return 0; 553} 554 555static int alc_pin_mode_put(struct snd_kcontrol *kcontrol, 556 struct snd_ctl_elem_value *ucontrol) 557{ 558 signed int change; 559 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 560 hda_nid_t nid = kcontrol->private_value & 0xffff; 561 unsigned char dir = (kcontrol->private_value >> 16) & 0xff; 562 long val = *ucontrol->value.integer.value; 563 unsigned int pinctl = snd_hda_codec_read(codec, nid, 0, 564 AC_VERB_GET_PIN_WIDGET_CONTROL, 565 0x00); 566 567 if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir)) 568 val = alc_pin_mode_min(dir); 569 570 change = pinctl != alc_pin_mode_values[val]; 571 if (change) { 572 /* Set pin mode to that requested */ 573 snd_hda_codec_write_cache(codec, nid, 0, 574 AC_VERB_SET_PIN_WIDGET_CONTROL, 575 alc_pin_mode_values[val]); 576 577 /* Also enable the retasking pin's input/output as required 578 * for the requested pin mode. Enum values of 2 or less are 579 * input modes. 580 * 581 * Dynamically switching the input/output buffers probably 582 * reduces noise slightly (particularly on input) so we'll 583 * do it. However, having both input and output buffers 584 * enabled simultaneously doesn't seem to be problematic if 585 * this turns out to be necessary in the future. 586 */ 587 if (val <= 2) { 588 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 589 HDA_AMP_MUTE, HDA_AMP_MUTE); 590 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0, 591 HDA_AMP_MUTE, 0); 592 } else { 593 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0, 594 HDA_AMP_MUTE, HDA_AMP_MUTE); 595 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 596 HDA_AMP_MUTE, 0); 597 } 598 } 599 return change; 600} 601 602#define ALC_PIN_MODE(xname, nid, dir) \ 603 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 604 .info = alc_pin_mode_info, \ 605 .get = alc_pin_mode_get, \ 606 .put = alc_pin_mode_put, \ 607 .private_value = nid | (dir<<16) } 608 609/* A switch control for ALC260 GPIO pins. Multiple GPIOs can be ganged 610 * together using a mask with more than one bit set. This control is 611 * currently used only by the ALC260 test model. At this stage they are not 612 * needed for any "production" models. 613 */ 614#ifdef CONFIG_SND_DEBUG 615#define alc_gpio_data_info snd_ctl_boolean_mono_info 616 617static int alc_gpio_data_get(struct snd_kcontrol *kcontrol, 618 struct snd_ctl_elem_value *ucontrol) 619{ 620 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 621 hda_nid_t nid = kcontrol->private_value & 0xffff; 622 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 623 long *valp = ucontrol->value.integer.value; 624 unsigned int val = snd_hda_codec_read(codec, nid, 0, 625 AC_VERB_GET_GPIO_DATA, 0x00); 626 627 *valp = (val & mask) != 0; 628 return 0; 629} 630static int alc_gpio_data_put(struct snd_kcontrol *kcontrol, 631 struct snd_ctl_elem_value *ucontrol) 632{ 633 signed int change; 634 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 635 hda_nid_t nid = kcontrol->private_value & 0xffff; 636 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 637 long val = *ucontrol->value.integer.value; 638 unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0, 639 AC_VERB_GET_GPIO_DATA, 640 0x00); 641 642 /* Set/unset the masked GPIO bit(s) as needed */ 643 change = (val == 0 ? 0 : mask) != (gpio_data & mask); 644 if (val == 0) 645 gpio_data &= ~mask; 646 else 647 gpio_data |= mask; 648 snd_hda_codec_write_cache(codec, nid, 0, 649 AC_VERB_SET_GPIO_DATA, gpio_data); 650 651 return change; 652} 653#define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \ 654 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 655 .info = alc_gpio_data_info, \ 656 .get = alc_gpio_data_get, \ 657 .put = alc_gpio_data_put, \ 658 .private_value = nid | (mask<<16) } 659#endif /* CONFIG_SND_DEBUG */ 660 661/* A switch control to allow the enabling of the digital IO pins on the 662 * ALC260. This is incredibly simplistic; the intention of this control is 663 * to provide something in the test model allowing digital outputs to be 664 * identified if present. If models are found which can utilise these 665 * outputs a more complete mixer control can be devised for those models if 666 * necessary. 667 */ 668#ifdef CONFIG_SND_DEBUG 669#define alc_spdif_ctrl_info snd_ctl_boolean_mono_info 670 671static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol, 672 struct snd_ctl_elem_value *ucontrol) 673{ 674 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 675 hda_nid_t nid = kcontrol->private_value & 0xffff; 676 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 677 long *valp = ucontrol->value.integer.value; 678 unsigned int val = snd_hda_codec_read(codec, nid, 0, 679 AC_VERB_GET_DIGI_CONVERT_1, 0x00); 680 681 *valp = (val & mask) != 0; 682 return 0; 683} 684static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol, 685 struct snd_ctl_elem_value *ucontrol) 686{ 687 signed int change; 688 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 689 hda_nid_t nid = kcontrol->private_value & 0xffff; 690 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 691 long val = *ucontrol->value.integer.value; 692 unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0, 693 AC_VERB_GET_DIGI_CONVERT_1, 694 0x00); 695 696 /* Set/unset the masked control bit(s) as needed */ 697 change = (val == 0 ? 0 : mask) != (ctrl_data & mask); 698 if (val==0) 699 ctrl_data &= ~mask; 700 else 701 ctrl_data |= mask; 702 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1, 703 ctrl_data); 704 705 return change; 706} 707#define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \ 708 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 709 .info = alc_spdif_ctrl_info, \ 710 .get = alc_spdif_ctrl_get, \ 711 .put = alc_spdif_ctrl_put, \ 712 .private_value = nid | (mask<<16) } 713#endif /* CONFIG_SND_DEBUG */ 714 715/* A switch control to allow the enabling EAPD digital outputs on the ALC26x. 716 * Again, this is only used in the ALC26x test models to help identify when 717 * the EAPD line must be asserted for features to work. 718 */ 719#ifdef CONFIG_SND_DEBUG 720#define alc_eapd_ctrl_info snd_ctl_boolean_mono_info 721 722static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol, 723 struct snd_ctl_elem_value *ucontrol) 724{ 725 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 726 hda_nid_t nid = kcontrol->private_value & 0xffff; 727 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 728 long *valp = ucontrol->value.integer.value; 729 unsigned int val = snd_hda_codec_read(codec, nid, 0, 730 AC_VERB_GET_EAPD_BTLENABLE, 0x00); 731 732 *valp = (val & mask) != 0; 733 return 0; 734} 735 736static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol, 737 struct snd_ctl_elem_value *ucontrol) 738{ 739 int change; 740 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 741 hda_nid_t nid = kcontrol->private_value & 0xffff; 742 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 743 long val = *ucontrol->value.integer.value; 744 unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0, 745 AC_VERB_GET_EAPD_BTLENABLE, 746 0x00); 747 748 /* Set/unset the masked control bit(s) as needed */ 749 change = (!val ? 0 : mask) != (ctrl_data & mask); 750 if (!val) 751 ctrl_data &= ~mask; 752 else 753 ctrl_data |= mask; 754 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE, 755 ctrl_data); 756 757 return change; 758} 759 760#define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \ 761 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 762 .info = alc_eapd_ctrl_info, \ 763 .get = alc_eapd_ctrl_get, \ 764 .put = alc_eapd_ctrl_put, \ 765 .private_value = nid | (mask<<16) } 766#endif /* CONFIG_SND_DEBUG */ 767 768/* 769 */ 770static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix) 771{ 772 if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers))) 773 return; 774 spec->mixers[spec->num_mixers++] = mix; 775} 776 777static void add_verb(struct alc_spec *spec, const struct hda_verb *verb) 778{ 779 if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs))) 780 return; 781 spec->init_verbs[spec->num_init_verbs++] = verb; 782} 783 784#ifdef CONFIG_PROC_FS 785/* 786 * hook for proc 787 */ 788static void print_realtek_coef(struct snd_info_buffer *buffer, 789 struct hda_codec *codec, hda_nid_t nid) 790{ 791 int coeff; 792 793 if (nid != 0x20) 794 return; 795 coeff = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0); 796 snd_iprintf(buffer, " Processing Coefficient: 0x%02x\n", coeff); 797 coeff = snd_hda_codec_read(codec, nid, 0, 798 AC_VERB_GET_COEF_INDEX, 0); 799 snd_iprintf(buffer, " Coefficient Index: 0x%02x\n", coeff); 800} 801#else 802#define print_realtek_coef NULL 803#endif 804 805/* 806 * set up from the preset table 807 */ 808static void setup_preset(struct alc_spec *spec, 809 const struct alc_config_preset *preset) 810{ 811 int i; 812 813 for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++) 814 add_mixer(spec, preset->mixers[i]); 815 spec->cap_mixer = preset->cap_mixer; 816 for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i]; 817 i++) 818 add_verb(spec, preset->init_verbs[i]); 819 820 spec->channel_mode = preset->channel_mode; 821 spec->num_channel_mode = preset->num_channel_mode; 822 spec->need_dac_fix = preset->need_dac_fix; 823 824 spec->multiout.max_channels = spec->channel_mode[0].channels; 825 826 spec->multiout.num_dacs = preset->num_dacs; 827 spec->multiout.dac_nids = preset->dac_nids; 828 spec->multiout.dig_out_nid = preset->dig_out_nid; 829 spec->multiout.slave_dig_outs = preset->slave_dig_outs; 830 spec->multiout.hp_nid = preset->hp_nid; 831 832 spec->num_mux_defs = preset->num_mux_defs; 833 if (!spec->num_mux_defs) 834 spec->num_mux_defs = 1; 835 spec->input_mux = preset->input_mux; 836 837 spec->num_adc_nids = preset->num_adc_nids; 838 spec->adc_nids = preset->adc_nids; 839 spec->capsrc_nids = preset->capsrc_nids; 840 spec->dig_in_nid = preset->dig_in_nid; 841 842 spec->unsol_event = preset->unsol_event; 843 spec->init_hook = preset->init_hook; 844#ifdef CONFIG_SND_HDA_POWER_SAVE 845 spec->loopback.amplist = preset->loopbacks; 846#endif 847} 848 849/* Enable GPIO mask and set output */ 850static struct hda_verb alc_gpio1_init_verbs[] = { 851 {0x01, AC_VERB_SET_GPIO_MASK, 0x01}, 852 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, 853 {0x01, AC_VERB_SET_GPIO_DATA, 0x01}, 854 { } 855}; 856 857static struct hda_verb alc_gpio2_init_verbs[] = { 858 {0x01, AC_VERB_SET_GPIO_MASK, 0x02}, 859 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02}, 860 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, 861 { } 862}; 863 864static struct hda_verb alc_gpio3_init_verbs[] = { 865 {0x01, AC_VERB_SET_GPIO_MASK, 0x03}, 866 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03}, 867 {0x01, AC_VERB_SET_GPIO_DATA, 0x03}, 868 { } 869}; 870 871/* 872 * Fix hardware PLL issue 873 * On some codecs, the analog PLL gating control must be off while 874 * the default value is 1. 875 */ 876static void alc_fix_pll(struct hda_codec *codec) 877{ 878 struct alc_spec *spec = codec->spec; 879 unsigned int val; 880 881 if (!spec->pll_nid) 882 return; 883 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX, 884 spec->pll_coef_idx); 885 val = snd_hda_codec_read(codec, spec->pll_nid, 0, 886 AC_VERB_GET_PROC_COEF, 0); 887 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX, 888 spec->pll_coef_idx); 889 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF, 890 val & ~(1 << spec->pll_coef_bit)); 891} 892 893static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid, 894 unsigned int coef_idx, unsigned int coef_bit) 895{ 896 struct alc_spec *spec = codec->spec; 897 spec->pll_nid = nid; 898 spec->pll_coef_idx = coef_idx; 899 spec->pll_coef_bit = coef_bit; 900 alc_fix_pll(codec); 901} 902 903static void alc_sku_automute(struct hda_codec *codec) 904{ 905 struct alc_spec *spec = codec->spec; 906 unsigned int present; 907 unsigned int hp_nid = spec->autocfg.hp_pins[0]; 908 unsigned int sp_nid = spec->autocfg.speaker_pins[0]; 909 910 /* need to execute and sync at first */ 911 snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0); 912 present = snd_hda_codec_read(codec, hp_nid, 0, 913 AC_VERB_GET_PIN_SENSE, 0); 914 spec->jack_present = (present & 0x80000000) != 0; 915 snd_hda_codec_write(codec, sp_nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 916 spec->jack_present ? 0 : PIN_OUT); 917} 918 919#if 0 /* it's broken in some acses -- temporarily disabled */ 920static void alc_mic_automute(struct hda_codec *codec) 921{ 922 struct alc_spec *spec = codec->spec; 923 unsigned int present; 924 unsigned int mic_nid = spec->autocfg.input_pins[AUTO_PIN_MIC]; 925 unsigned int fmic_nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC]; 926 unsigned int mix_nid = spec->capsrc_nids[0]; 927 unsigned int capsrc_idx_mic, capsrc_idx_fmic; 928 929 capsrc_idx_mic = mic_nid - 0x18; 930 capsrc_idx_fmic = fmic_nid - 0x18; 931 present = snd_hda_codec_read(codec, mic_nid, 0, 932 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 933 snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, 934 0x7000 | (capsrc_idx_mic << 8) | (present ? 0 : 0x80)); 935 snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, 936 0x7000 | (capsrc_idx_fmic << 8) | (present ? 0x80 : 0)); 937 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, capsrc_idx_fmic, 938 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 939} 940#else 941#define alc_mic_automute(codec) do {} while(0) /* NOP */ 942#endif /* disabled */ 943 944/* unsolicited event for HP jack sensing */ 945static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res) 946{ 947 if (codec->vendor_id == 0x10ec0880) 948 res >>= 28; 949 else 950 res >>= 26; 951 if (res == ALC880_HP_EVENT) 952 alc_sku_automute(codec); 953 954 if (res == ALC880_MIC_EVENT) 955 alc_mic_automute(codec); 956} 957 958static void alc_inithook(struct hda_codec *codec) 959{ 960 alc_sku_automute(codec); 961 alc_mic_automute(codec); 962} 963 964/* additional initialization for ALC888 variants */ 965static void alc888_coef_init(struct hda_codec *codec) 966{ 967 unsigned int tmp; 968 969 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0); 970 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0); 971 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7); 972 if ((tmp & 0xf0) == 2) 973 /* alc888S-VC */ 974 snd_hda_codec_read(codec, 0x20, 0, 975 AC_VERB_SET_PROC_COEF, 0x830); 976 else 977 /* alc888-VB */ 978 snd_hda_codec_read(codec, 0x20, 0, 979 AC_VERB_SET_PROC_COEF, 0x3030); 980} 981 982/* 32-bit subsystem ID for BIOS loading in HD Audio codec. 983 * 31 ~ 16 : Manufacture ID 984 * 15 ~ 8 : SKU ID 985 * 7 ~ 0 : Assembly ID 986 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36 987 */ 988static void alc_subsystem_id(struct hda_codec *codec, 989 unsigned int porta, unsigned int porte, 990 unsigned int portd) 991{ 992 unsigned int ass, tmp, i; 993 unsigned nid; 994 struct alc_spec *spec = codec->spec; 995 996 ass = codec->subsystem_id & 0xffff; 997 if ((ass != codec->bus->pci->subsystem_device) && (ass & 1)) 998 goto do_sku; 999 1000 /* 1001 * 31~30 : port conetcivity 1002 * 29~21 : reserve 1003 * 20 : PCBEEP input 1004 * 19~16 : Check sum (15:1) 1005 * 15~1 : Custom 1006 * 0 : override 1007 */ 1008 nid = 0x1d; 1009 if (codec->vendor_id == 0x10ec0260) 1010 nid = 0x17; 1011 ass = snd_hda_codec_read(codec, nid, 0, 1012 AC_VERB_GET_CONFIG_DEFAULT, 0); 1013 if (!(ass & 1) && !(ass & 0x100000)) 1014 return; 1015 if ((ass >> 30) != 1) /* no physical connection */ 1016 return; 1017 1018 /* check sum */ 1019 tmp = 0; 1020 for (i = 1; i < 16; i++) { 1021 if ((ass >> i) & 1) 1022 tmp++; 1023 } 1024 if (((ass >> 16) & 0xf) != tmp) 1025 return; 1026do_sku: 1027 /* 1028 * 0 : override 1029 * 1 : Swap Jack 1030 * 2 : 0 --> Desktop, 1 --> Laptop 1031 * 3~5 : External Amplifier control 1032 * 7~6 : Reserved 1033 */ 1034 tmp = (ass & 0x38) >> 3; /* external Amp control */ 1035 switch (tmp) { 1036 case 1: 1037 snd_hda_sequence_write(codec, alc_gpio1_init_verbs); 1038 break; 1039 case 3: 1040 snd_hda_sequence_write(codec, alc_gpio2_init_verbs); 1041 break; 1042 case 7: 1043 snd_hda_sequence_write(codec, alc_gpio3_init_verbs); 1044 break; 1045 case 5: /* set EAPD output high */ 1046 switch (codec->vendor_id) { 1047 case 0x10ec0260: 1048 snd_hda_codec_write(codec, 0x0f, 0, 1049 AC_VERB_SET_EAPD_BTLENABLE, 2); 1050 snd_hda_codec_write(codec, 0x10, 0, 1051 AC_VERB_SET_EAPD_BTLENABLE, 2); 1052 break; 1053 case 0x10ec0262: 1054 case 0x10ec0267: 1055 case 0x10ec0268: 1056 case 0x10ec0269: 1057 case 0x10ec0660: 1058 case 0x10ec0662: 1059 case 0x10ec0663: 1060 case 0x10ec0862: 1061 case 0x10ec0889: 1062 snd_hda_codec_write(codec, 0x14, 0, 1063 AC_VERB_SET_EAPD_BTLENABLE, 2); 1064 snd_hda_codec_write(codec, 0x15, 0, 1065 AC_VERB_SET_EAPD_BTLENABLE, 2); 1066 break; 1067 } 1068 switch (codec->vendor_id) { 1069 case 0x10ec0260: 1070 snd_hda_codec_write(codec, 0x1a, 0, 1071 AC_VERB_SET_COEF_INDEX, 7); 1072 tmp = snd_hda_codec_read(codec, 0x1a, 0, 1073 AC_VERB_GET_PROC_COEF, 0); 1074 snd_hda_codec_write(codec, 0x1a, 0, 1075 AC_VERB_SET_COEF_INDEX, 7); 1076 snd_hda_codec_write(codec, 0x1a, 0, 1077 AC_VERB_SET_PROC_COEF, 1078 tmp | 0x2010); 1079 break; 1080 case 0x10ec0262: 1081 case 0x10ec0880: 1082 case 0x10ec0882: 1083 case 0x10ec0883: 1084 case 0x10ec0885: 1085 case 0x10ec0889: 1086 snd_hda_codec_write(codec, 0x20, 0, 1087 AC_VERB_SET_COEF_INDEX, 7); 1088 tmp = snd_hda_codec_read(codec, 0x20, 0, 1089 AC_VERB_GET_PROC_COEF, 0); 1090 snd_hda_codec_write(codec, 0x20, 0, 1091 AC_VERB_SET_COEF_INDEX, 7); 1092 snd_hda_codec_write(codec, 0x20, 0, 1093 AC_VERB_SET_PROC_COEF, 1094 tmp | 0x2010); 1095 break; 1096 case 0x10ec0888: 1097 /*alc888_coef_init(codec);*/ /* called in alc_init() */ 1098 break; 1099 case 0x10ec0267: 1100 case 0x10ec0268: 1101 snd_hda_codec_write(codec, 0x20, 0, 1102 AC_VERB_SET_COEF_INDEX, 7); 1103 tmp = snd_hda_codec_read(codec, 0x20, 0, 1104 AC_VERB_GET_PROC_COEF, 0); 1105 snd_hda_codec_write(codec, 0x20, 0, 1106 AC_VERB_SET_COEF_INDEX, 7); 1107 snd_hda_codec_write(codec, 0x20, 0, 1108 AC_VERB_SET_PROC_COEF, 1109 tmp | 0x3000); 1110 break; 1111 } 1112 default: 1113 break; 1114 } 1115 1116 /* is laptop or Desktop and enable the function "Mute internal speaker 1117 * when the external headphone out jack is plugged" 1118 */ 1119 if (!(ass & 0x8000)) 1120 return; 1121 /* 1122 * 10~8 : Jack location 1123 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered 1124 * 14~13: Resvered 1125 * 15 : 1 --> enable the function "Mute internal speaker 1126 * when the external headphone out jack is plugged" 1127 */ 1128 if (!spec->autocfg.speaker_pins[0]) { 1129 if (spec->autocfg.line_out_pins[0]) 1130 spec->autocfg.speaker_pins[0] = 1131 spec->autocfg.line_out_pins[0]; 1132 else 1133 return; 1134 } 1135 1136 if (!spec->autocfg.hp_pins[0]) { 1137 tmp = (ass >> 11) & 0x3; /* HP to chassis */ 1138 if (tmp == 0) 1139 spec->autocfg.hp_pins[0] = porta; 1140 else if (tmp == 1) 1141 spec->autocfg.hp_pins[0] = porte; 1142 else if (tmp == 2) 1143 spec->autocfg.hp_pins[0] = portd; 1144 else 1145 return; 1146 } 1147 if (spec->autocfg.hp_pins[0]) 1148 snd_hda_codec_write(codec, spec->autocfg.hp_pins[0], 0, 1149 AC_VERB_SET_UNSOLICITED_ENABLE, 1150 AC_USRSP_EN | ALC880_HP_EVENT); 1151 1152#if 0 /* it's broken in some acses -- temporarily disabled */ 1153 if (spec->autocfg.input_pins[AUTO_PIN_MIC] && 1154 spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC]) 1155 snd_hda_codec_write(codec, 1156 spec->autocfg.input_pins[AUTO_PIN_MIC], 0, 1157 AC_VERB_SET_UNSOLICITED_ENABLE, 1158 AC_USRSP_EN | ALC880_MIC_EVENT); 1159#endif /* disabled */ 1160 1161 spec->unsol_event = alc_sku_unsol_event; 1162} 1163 1164/* 1165 * Fix-up pin default configurations 1166 */ 1167 1168struct alc_pincfg { 1169 hda_nid_t nid; 1170 u32 val; 1171}; 1172 1173static void alc_fix_pincfg(struct hda_codec *codec, 1174 const struct snd_pci_quirk *quirk, 1175 const struct alc_pincfg **pinfix) 1176{ 1177 const struct alc_pincfg *cfg; 1178 1179 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk); 1180 if (!quirk) 1181 return; 1182 1183 cfg = pinfix[quirk->value]; 1184 for (; cfg->nid; cfg++) { 1185 int i; 1186 u32 val = cfg->val; 1187 for (i = 0; i < 4; i++) { 1188 snd_hda_codec_write(codec, cfg->nid, 0, 1189 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i, 1190 val & 0xff); 1191 val >>= 8; 1192 } 1193 } 1194} 1195 1196/* 1197 * ALC888 1198 */ 1199 1200/* 1201 * 2ch mode 1202 */ 1203static struct hda_verb alc888_4ST_ch2_intel_init[] = { 1204/* Mic-in jack as mic in */ 1205 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 1206 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 1207/* Line-in jack as Line in */ 1208 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 1209 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 1210/* Line-Out as Front */ 1211 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00}, 1212 { } /* end */ 1213}; 1214 1215/* 1216 * 4ch mode 1217 */ 1218static struct hda_verb alc888_4ST_ch4_intel_init[] = { 1219/* Mic-in jack as mic in */ 1220 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 1221 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 1222/* Line-in jack as Surround */ 1223 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1224 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1225/* Line-Out as Front */ 1226 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00}, 1227 { } /* end */ 1228}; 1229 1230/* 1231 * 6ch mode 1232 */ 1233static struct hda_verb alc888_4ST_ch6_intel_init[] = { 1234/* Mic-in jack as CLFE */ 1235 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1236 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1237/* Line-in jack as Surround */ 1238 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1239 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1240/* Line-Out as CLFE (workaround because Mic-in is not loud enough) */ 1241 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 1242 { } /* end */ 1243}; 1244 1245/* 1246 * 8ch mode 1247 */ 1248static struct hda_verb alc888_4ST_ch8_intel_init[] = { 1249/* Mic-in jack as CLFE */ 1250 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1251 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1252/* Line-in jack as Surround */ 1253 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1254 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1255/* Line-Out as Side */ 1256 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 1257 { } /* end */ 1258}; 1259 1260static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = { 1261 { 2, alc888_4ST_ch2_intel_init }, 1262 { 4, alc888_4ST_ch4_intel_init }, 1263 { 6, alc888_4ST_ch6_intel_init }, 1264 { 8, alc888_4ST_ch8_intel_init }, 1265}; 1266 1267/* 1268 * ALC888 Fujitsu Siemens Amillo xa3530 1269 */ 1270 1271static struct hda_verb alc888_fujitsu_xa3530_verbs[] = { 1272/* Front Mic: set to PIN_IN (empty by default) */ 1273 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1274/* Connect Internal HP to Front */ 1275 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1276 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1277 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 1278/* Connect Bass HP to Front */ 1279 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1280 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1281 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 1282/* Connect Line-Out side jack (SPDIF) to Side */ 1283 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1284 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1285 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 1286/* Connect Mic jack to CLFE */ 1287 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1288 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1289 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, 1290/* Connect Line-in jack to Surround */ 1291 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1292 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1293 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, 1294/* Connect HP out jack to Front */ 1295 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1296 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1297 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 1298/* Enable unsolicited event for HP jack and Line-out jack */ 1299 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 1300 {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 1301 {} 1302}; 1303 1304static void alc888_fujitsu_xa3530_automute(struct hda_codec *codec) 1305{ 1306 unsigned int present; 1307 unsigned int bits; 1308 /* Line out presence */ 1309 present = snd_hda_codec_read(codec, 0x17, 0, 1310 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 1311 /* HP out presence */ 1312 present = present || snd_hda_codec_read(codec, 0x1b, 0, 1313 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 1314 bits = present ? HDA_AMP_MUTE : 0; 1315 /* Toggle internal speakers muting */ 1316 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 1317 HDA_AMP_MUTE, bits); 1318 /* Toggle internal bass muting */ 1319 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 1320 HDA_AMP_MUTE, bits); 1321} 1322 1323static void alc888_fujitsu_xa3530_unsol_event(struct hda_codec *codec, 1324 unsigned int res) 1325{ 1326 if (res >> 26 == ALC880_HP_EVENT) 1327 alc888_fujitsu_xa3530_automute(codec); 1328} 1329 1330 1331/* 1332 * ALC888 Acer Aspire 4930G model 1333 */ 1334 1335static struct hda_verb alc888_acer_aspire_4930g_verbs[] = { 1336/* Front Mic: set to PIN_IN (empty by default) */ 1337 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1338/* Unselect Front Mic by default in input mixer 3 */ 1339 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)}, 1340/* Enable unsolicited event for HP jack */ 1341 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 1342/* Connect Internal HP to front */ 1343 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1344 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1345 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 1346/* Connect HP out to front */ 1347 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1348 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1349 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 1350 { } 1351}; 1352 1353static struct hda_input_mux alc888_2_capture_sources[2] = { 1354 /* Front mic only available on one ADC */ 1355 { 1356 .num_items = 4, 1357 .items = { 1358 { "Mic", 0x0 }, 1359 { "Line", 0x2 }, 1360 { "CD", 0x4 }, 1361 { "Front Mic", 0xb }, 1362 }, 1363 }, 1364 { 1365 .num_items = 3, 1366 .items = { 1367 { "Mic", 0x0 }, 1368 { "Line", 0x2 }, 1369 { "CD", 0x4 }, 1370 }, 1371 } 1372}; 1373 1374static struct snd_kcontrol_new alc888_base_mixer[] = { 1375 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1376 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 1377 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1378 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 1379 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, 1380 HDA_OUTPUT), 1381 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 1382 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 1383 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 1384 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 1385 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 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("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 1389 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 1390 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1391 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 1392 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1393 { } /* end */ 1394}; 1395 1396static void alc888_acer_aspire_4930g_automute(struct hda_codec *codec) 1397{ 1398 unsigned int present; 1399 unsigned int bits; 1400 present = snd_hda_codec_read(codec, 0x15, 0, 1401 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 1402 bits = present ? HDA_AMP_MUTE : 0; 1403 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 1404 HDA_AMP_MUTE, bits); 1405} 1406 1407static void alc888_acer_aspire_4930g_unsol_event(struct hda_codec *codec, 1408 unsigned int res) 1409{ 1410 if (res >> 26 == ALC880_HP_EVENT) 1411 alc888_acer_aspire_4930g_automute(codec); 1412} 1413 1414/* 1415 * ALC880 3-stack model 1416 * 1417 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e) 1418 * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18, 1419 * F-Mic = 0x1b, HP = 0x19 1420 */ 1421 1422static hda_nid_t alc880_dac_nids[4] = { 1423 /* front, rear, clfe, rear_surr */ 1424 0x02, 0x05, 0x04, 0x03 1425}; 1426 1427static hda_nid_t alc880_adc_nids[3] = { 1428 /* ADC0-2 */ 1429 0x07, 0x08, 0x09, 1430}; 1431 1432/* The datasheet says the node 0x07 is connected from inputs, 1433 * but it shows zero connection in the real implementation on some devices. 1434 * Note: this is a 915GAV bug, fixed on 915GLV 1435 */ 1436static hda_nid_t alc880_adc_nids_alt[2] = { 1437 /* ADC1-2 */ 1438 0x08, 0x09, 1439}; 1440 1441#define ALC880_DIGOUT_NID 0x06 1442#define ALC880_DIGIN_NID 0x0a 1443 1444static struct hda_input_mux alc880_capture_source = { 1445 .num_items = 4, 1446 .items = { 1447 { "Mic", 0x0 }, 1448 { "Front Mic", 0x3 }, 1449 { "Line", 0x2 }, 1450 { "CD", 0x4 }, 1451 }, 1452}; 1453 1454/* channel source setting (2/6 channel selection for 3-stack) */ 1455/* 2ch mode */ 1456static struct hda_verb alc880_threestack_ch2_init[] = { 1457 /* set line-in to input, mute it */ 1458 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 1459 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 1460 /* set mic-in to input vref 80%, mute it */ 1461 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 1462 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 1463 { } /* end */ 1464}; 1465 1466/* 6ch mode */ 1467static struct hda_verb alc880_threestack_ch6_init[] = { 1468 /* set line-in to output, unmute it */ 1469 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1470 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1471 /* set mic-in to output, unmute it */ 1472 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1473 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1474 { } /* end */ 1475}; 1476 1477static struct hda_channel_mode alc880_threestack_modes[2] = { 1478 { 2, alc880_threestack_ch2_init }, 1479 { 6, alc880_threestack_ch6_init }, 1480}; 1481 1482static struct snd_kcontrol_new alc880_three_stack_mixer[] = { 1483 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1484 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 1485 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 1486 HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT), 1487 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 1488 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 1489 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 1490 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 1491 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1492 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1493 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 1494 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 1495 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1496 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1497 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT), 1498 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT), 1499 HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT), 1500 { 1501 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1502 .name = "Channel Mode", 1503 .info = alc_ch_mode_info, 1504 .get = alc_ch_mode_get, 1505 .put = alc_ch_mode_put, 1506 }, 1507 { } /* end */ 1508}; 1509 1510/* capture mixer elements */ 1511static int alc_cap_vol_info(struct snd_kcontrol *kcontrol, 1512 struct snd_ctl_elem_info *uinfo) 1513{ 1514 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1515 struct alc_spec *spec = codec->spec; 1516 int err; 1517 1518 mutex_lock(&codec->control_mutex); 1519 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, 1520 HDA_INPUT); 1521 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo); 1522 mutex_unlock(&codec->control_mutex); 1523 return err; 1524} 1525 1526static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag, 1527 unsigned int size, unsigned int __user *tlv) 1528{ 1529 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1530 struct alc_spec *spec = codec->spec; 1531 int err; 1532 1533 mutex_lock(&codec->control_mutex); 1534 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, 1535 HDA_INPUT); 1536 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv); 1537 mutex_unlock(&codec->control_mutex); 1538 return err; 1539} 1540 1541typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol, 1542 struct snd_ctl_elem_value *ucontrol); 1543 1544static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol, 1545 struct snd_ctl_elem_value *ucontrol, 1546 getput_call_t func) 1547{ 1548 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1549 struct alc_spec *spec = codec->spec; 1550 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 1551 int err; 1552 1553 mutex_lock(&codec->control_mutex); 1554 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx], 1555 3, 0, HDA_INPUT); 1556 err = func(kcontrol, ucontrol); 1557 mutex_unlock(&codec->control_mutex); 1558 return err; 1559} 1560 1561static int alc_cap_vol_get(struct snd_kcontrol *kcontrol, 1562 struct snd_ctl_elem_value *ucontrol) 1563{ 1564 return alc_cap_getput_caller(kcontrol, ucontrol, 1565 snd_hda_mixer_amp_volume_get); 1566} 1567 1568static int alc_cap_vol_put(struct snd_kcontrol *kcontrol, 1569 struct snd_ctl_elem_value *ucontrol) 1570{ 1571 return alc_cap_getput_caller(kcontrol, ucontrol, 1572 snd_hda_mixer_amp_volume_put); 1573} 1574 1575/* capture mixer elements */ 1576#define alc_cap_sw_info snd_ctl_boolean_stereo_info 1577 1578static int alc_cap_sw_get(struct snd_kcontrol *kcontrol, 1579 struct snd_ctl_elem_value *ucontrol) 1580{ 1581 return alc_cap_getput_caller(kcontrol, ucontrol, 1582 snd_hda_mixer_amp_switch_get); 1583} 1584 1585static int alc_cap_sw_put(struct snd_kcontrol *kcontrol, 1586 struct snd_ctl_elem_value *ucontrol) 1587{ 1588 return alc_cap_getput_caller(kcontrol, ucontrol, 1589 snd_hda_mixer_amp_switch_put); 1590} 1591 1592#define DEFINE_CAPMIX(num) \ 1593static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \ 1594 { \ 1595 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 1596 .name = "Capture Switch", \ 1597 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \ 1598 .count = num, \ 1599 .info = alc_cap_sw_info, \ 1600 .get = alc_cap_sw_get, \ 1601 .put = alc_cap_sw_put, \ 1602 }, \ 1603 { \ 1604 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 1605 .name = "Capture Volume", \ 1606 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \ 1607 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \ 1608 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \ 1609 .count = num, \ 1610 .info = alc_cap_vol_info, \ 1611 .get = alc_cap_vol_get, \ 1612 .put = alc_cap_vol_put, \ 1613 .tlv = { .c = alc_cap_vol_tlv }, \ 1614 }, \ 1615 { \ 1616 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 1617 /* .name = "Capture Source", */ \ 1618 .name = "Input Source", \ 1619 .count = num, \ 1620 .info = alc_mux_enum_info, \ 1621 .get = alc_mux_enum_get, \ 1622 .put = alc_mux_enum_put, \ 1623 }, \ 1624 { } /* end */ \ 1625} 1626 1627/* up to three ADCs */ 1628DEFINE_CAPMIX(1); 1629DEFINE_CAPMIX(2); 1630DEFINE_CAPMIX(3); 1631 1632 1633/* 1634 * ALC880 5-stack model 1635 * 1636 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d), 1637 * Side = 0x02 (0xd) 1638 * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16 1639 * Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19 1640 */ 1641 1642/* additional mixers to alc880_three_stack_mixer */ 1643static struct snd_kcontrol_new alc880_five_stack_mixer[] = { 1644 HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1645 HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT), 1646 { } /* end */ 1647}; 1648 1649/* channel source setting (6/8 channel selection for 5-stack) */ 1650/* 6ch mode */ 1651static struct hda_verb alc880_fivestack_ch6_init[] = { 1652 /* set line-in to input, mute it */ 1653 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 1654 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 1655 { } /* end */ 1656}; 1657 1658/* 8ch mode */ 1659static struct hda_verb alc880_fivestack_ch8_init[] = { 1660 /* set line-in to output, unmute it */ 1661 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1662 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1663 { } /* end */ 1664}; 1665 1666static struct hda_channel_mode alc880_fivestack_modes[2] = { 1667 { 6, alc880_fivestack_ch6_init }, 1668 { 8, alc880_fivestack_ch8_init }, 1669}; 1670 1671 1672/* 1673 * ALC880 6-stack model 1674 * 1675 * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e), 1676 * Side = 0x05 (0x0f) 1677 * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17, 1678 * Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b 1679 */ 1680 1681static hda_nid_t alc880_6st_dac_nids[4] = { 1682 /* front, rear, clfe, rear_surr */ 1683 0x02, 0x03, 0x04, 0x05 1684}; 1685 1686static struct hda_input_mux alc880_6stack_capture_source = { 1687 .num_items = 4, 1688 .items = { 1689 { "Mic", 0x0 }, 1690 { "Front Mic", 0x1 }, 1691 { "Line", 0x2 }, 1692 { "CD", 0x4 }, 1693 }, 1694}; 1695 1696/* fixed 8-channels */ 1697static struct hda_channel_mode alc880_sixstack_modes[1] = { 1698 { 8, NULL }, 1699}; 1700 1701static struct snd_kcontrol_new alc880_six_stack_mixer[] = { 1702 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1703 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 1704 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1705 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 1706 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 1707 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 1708 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 1709 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 1710 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 1711 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 1712 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1713 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1714 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 1715 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 1716 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1717 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1718 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 1719 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 1720 { 1721 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1722 .name = "Channel Mode", 1723 .info = alc_ch_mode_info, 1724 .get = alc_ch_mode_get, 1725 .put = alc_ch_mode_put, 1726 }, 1727 { } /* end */ 1728}; 1729 1730 1731/* 1732 * ALC880 W810 model 1733 * 1734 * W810 has rear IO for: 1735 * Front (DAC 02) 1736 * Surround (DAC 03) 1737 * Center/LFE (DAC 04) 1738 * Digital out (06) 1739 * 1740 * The system also has a pair of internal speakers, and a headphone jack. 1741 * These are both connected to Line2 on the codec, hence to DAC 02. 1742 * 1743 * There is a variable resistor to control the speaker or headphone 1744 * volume. This is a hardware-only device without a software API. 1745 * 1746 * Plugging headphones in will disable the internal speakers. This is 1747 * implemented in hardware, not via the driver using jack sense. In 1748 * a similar fashion, plugging into the rear socket marked "front" will 1749 * disable both the speakers and headphones. 1750 * 1751 * For input, there's a microphone jack, and an "audio in" jack. 1752 * These may not do anything useful with this driver yet, because I 1753 * haven't setup any initialization verbs for these yet... 1754 */ 1755 1756static hda_nid_t alc880_w810_dac_nids[3] = { 1757 /* front, rear/surround, clfe */ 1758 0x02, 0x03, 0x04 1759}; 1760 1761/* fixed 6 channels */ 1762static struct hda_channel_mode alc880_w810_modes[1] = { 1763 { 6, NULL } 1764}; 1765 1766/* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */ 1767static struct snd_kcontrol_new alc880_w810_base_mixer[] = { 1768 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1769 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 1770 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1771 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 1772 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 1773 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 1774 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 1775 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 1776 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 1777 { } /* end */ 1778}; 1779 1780 1781/* 1782 * Z710V model 1783 * 1784 * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d) 1785 * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?), 1786 * Line = 0x1a 1787 */ 1788 1789static hda_nid_t alc880_z71v_dac_nids[1] = { 1790 0x02 1791}; 1792#define ALC880_Z71V_HP_DAC 0x03 1793 1794/* fixed 2 channels */ 1795static struct hda_channel_mode alc880_2_jack_modes[1] = { 1796 { 2, NULL } 1797}; 1798 1799static struct snd_kcontrol_new alc880_z71v_mixer[] = { 1800 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1801 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 1802 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1803 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT), 1804 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1805 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1806 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1807 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1808 { } /* end */ 1809}; 1810 1811 1812/* 1813 * ALC880 F1734 model 1814 * 1815 * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d) 1816 * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18 1817 */ 1818 1819static hda_nid_t alc880_f1734_dac_nids[1] = { 1820 0x03 1821}; 1822#define ALC880_F1734_HP_DAC 0x02 1823 1824static struct snd_kcontrol_new alc880_f1734_mixer[] = { 1825 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1826 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 1827 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1828 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 1829 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1830 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1831 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 1832 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 1833 { } /* end */ 1834}; 1835 1836static struct hda_input_mux alc880_f1734_capture_source = { 1837 .num_items = 2, 1838 .items = { 1839 { "Mic", 0x1 }, 1840 { "CD", 0x4 }, 1841 }, 1842}; 1843 1844 1845/* 1846 * ALC880 ASUS model 1847 * 1848 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e) 1849 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16, 1850 * Mic = 0x18, Line = 0x1a 1851 */ 1852 1853#define alc880_asus_dac_nids alc880_w810_dac_nids /* identical with w810 */ 1854#define alc880_asus_modes alc880_threestack_modes /* 2/6 channel mode */ 1855 1856static struct snd_kcontrol_new alc880_asus_mixer[] = { 1857 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1858 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 1859 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1860 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 1861 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 1862 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 1863 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 1864 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 1865 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1866 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1867 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 1868 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 1869 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1870 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1871 { 1872 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1873 .name = "Channel Mode", 1874 .info = alc_ch_mode_info, 1875 .get = alc_ch_mode_get, 1876 .put = alc_ch_mode_put, 1877 }, 1878 { } /* end */ 1879}; 1880 1881/* 1882 * ALC880 ASUS W1V model 1883 * 1884 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e) 1885 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16, 1886 * Mic = 0x18, Line = 0x1a, Line2 = 0x1b 1887 */ 1888 1889/* additional mixers to alc880_asus_mixer */ 1890static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = { 1891 HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT), 1892 HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT), 1893 { } /* end */ 1894}; 1895 1896/* TCL S700 */ 1897static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = { 1898 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1899 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 1900 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 1901 HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT), 1902 HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT), 1903 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT), 1904 HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT), 1905 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 1906 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 1907 { } /* end */ 1908}; 1909 1910/* Uniwill */ 1911static struct snd_kcontrol_new alc880_uniwill_mixer[] = { 1912 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1913 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 1914 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1915 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 1916 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 1917 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 1918 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 1919 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 1920 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1921 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1922 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 1923 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 1924 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1925 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1926 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 1927 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 1928 { 1929 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1930 .name = "Channel Mode", 1931 .info = alc_ch_mode_info, 1932 .get = alc_ch_mode_get, 1933 .put = alc_ch_mode_put, 1934 }, 1935 { } /* end */ 1936}; 1937 1938static struct snd_kcontrol_new alc880_fujitsu_mixer[] = { 1939 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1940 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 1941 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1942 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 1943 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1944 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1945 HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1946 HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1947 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 1948 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 1949 { } /* end */ 1950}; 1951 1952static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = { 1953 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1954 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 1955 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1956 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 1957 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1958 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1959 { } /* end */ 1960}; 1961 1962/* 1963 * virtual master controls 1964 */ 1965 1966/* 1967 * slave controls for virtual master 1968 */ 1969static const char *alc_slave_vols[] = { 1970 "Front Playback Volume", 1971 "Surround Playback Volume", 1972 "Center Playback Volume", 1973 "LFE Playback Volume", 1974 "Side Playback Volume", 1975 "Headphone Playback Volume", 1976 "Speaker Playback Volume", 1977 "Mono Playback Volume", 1978 "Line-Out Playback Volume", 1979 "PCM Playback Volume", 1980 NULL, 1981}; 1982 1983static const char *alc_slave_sws[] = { 1984 "Front Playback Switch", 1985 "Surround Playback Switch", 1986 "Center Playback Switch", 1987 "LFE Playback Switch", 1988 "Side Playback Switch", 1989 "Headphone Playback Switch", 1990 "Speaker Playback Switch", 1991 "Mono Playback Switch", 1992 "IEC958 Playback Switch", 1993 NULL, 1994}; 1995 1996/* 1997 * build control elements 1998 */ 1999 2000static void alc_free_kctls(struct hda_codec *codec); 2001 2002/* additional beep mixers; the actual parameters are overwritten at build */ 2003static struct snd_kcontrol_new alc_beep_mixer[] = { 2004 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT), 2005 HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_INPUT), 2006 { } /* end */ 2007}; 2008 2009static int alc_build_controls(struct hda_codec *codec) 2010{ 2011 struct alc_spec *spec = codec->spec; 2012 int err; 2013 int i; 2014 2015 for (i = 0; i < spec->num_mixers; i++) { 2016 err = snd_hda_add_new_ctls(codec, spec->mixers[i]); 2017 if (err < 0) 2018 return err; 2019 } 2020 if (spec->cap_mixer) { 2021 err = snd_hda_add_new_ctls(codec, spec->cap_mixer); 2022 if (err < 0) 2023 return err; 2024 } 2025 if (spec->multiout.dig_out_nid) { 2026 err = snd_hda_create_spdif_out_ctls(codec, 2027 spec->multiout.dig_out_nid); 2028 if (err < 0) 2029 return err; 2030 if (!spec->no_analog) { 2031 err = snd_hda_create_spdif_share_sw(codec, 2032 &spec->multiout); 2033 if (err < 0) 2034 return err; 2035 spec->multiout.share_spdif = 1; 2036 } 2037 } 2038 if (spec->dig_in_nid) { 2039 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid); 2040 if (err < 0) 2041 return err; 2042 } 2043 2044 /* create beep controls if needed */ 2045 if (spec->beep_amp) { 2046 struct snd_kcontrol_new *knew; 2047 for (knew = alc_beep_mixer; knew->name; knew++) { 2048 struct snd_kcontrol *kctl; 2049 kctl = snd_ctl_new1(knew, codec); 2050 if (!kctl) 2051 return -ENOMEM; 2052 kctl->private_value = spec->beep_amp; 2053 err = snd_hda_ctl_add(codec, kctl); 2054 if (err < 0) 2055 return err; 2056 } 2057 } 2058 2059 /* if we have no master control, let's create it */ 2060 if (!spec->no_analog && 2061 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) { 2062 unsigned int vmaster_tlv[4]; 2063 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid, 2064 HDA_OUTPUT, vmaster_tlv); 2065 err = snd_hda_add_vmaster(codec, "Master Playback Volume", 2066 vmaster_tlv, alc_slave_vols); 2067 if (err < 0) 2068 return err; 2069 } 2070 if (!spec->no_analog && 2071 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) { 2072 err = snd_hda_add_vmaster(codec, "Master Playback Switch", 2073 NULL, alc_slave_sws); 2074 if (err < 0) 2075 return err; 2076 } 2077 2078 alc_free_kctls(codec); /* no longer needed */ 2079 return 0; 2080} 2081 2082 2083/* 2084 * initialize the codec volumes, etc 2085 */ 2086 2087/* 2088 * generic initialization of ADC, input mixers and output mixers 2089 */ 2090static struct hda_verb alc880_volume_init_verbs[] = { 2091 /* 2092 * Unmute ADC0-2 and set the default input to mic-in 2093 */ 2094 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 2095 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2096 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 2097 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2098 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 2099 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2100 2101 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 2102 * mixer widget 2103 * Note: PASD motherboards uses the Line In 2 as the input for front 2104 * panel mic (mic 2) 2105 */ 2106 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 2107 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2108 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2109 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 2110 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 2111 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 2112 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 2113 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 2114 2115 /* 2116 * Set up output mixers (0x0c - 0x0f) 2117 */ 2118 /* set vol=0 to output mixers */ 2119 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2120 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2121 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2122 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2123 /* set up input amps for analog loopback */ 2124 /* Amp Indices: DAC = 0, mixer = 1 */ 2125 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2126 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2127 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2128 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2129 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2130 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2131 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2132 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2133 2134 { } 2135}; 2136 2137/* 2138 * 3-stack pin configuration: 2139 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b 2140 */ 2141static struct hda_verb alc880_pin_3stack_init_verbs[] = { 2142 /* 2143 * preset connection lists of input pins 2144 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround 2145 */ 2146 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 2147 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 2148 {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */ 2149 2150 /* 2151 * Set pin mode and muting 2152 */ 2153 /* set front pin widgets 0x14 for output */ 2154 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2155 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2156 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 2157 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2158 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2159 /* Mic2 (as headphone out) for HP output */ 2160 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2161 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2162 /* Line In pin widget for input */ 2163 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2164 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2165 /* Line2 (as front mic) pin widget for input and vref at 80% */ 2166 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2167 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2168 /* CD pin widget for input */ 2169 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2170 2171 { } 2172}; 2173 2174/* 2175 * 5-stack pin configuration: 2176 * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19, 2177 * line-in/side = 0x1a, f-mic = 0x1b 2178 */ 2179static struct hda_verb alc880_pin_5stack_init_verbs[] = { 2180 /* 2181 * preset connection lists of input pins 2182 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround 2183 */ 2184 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 2185 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */ 2186 2187 /* 2188 * Set pin mode and muting 2189 */ 2190 /* set pin widgets 0x14-0x17 for output */ 2191 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2192 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2193 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2194 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2195 /* unmute pins for output (no gain on this amp) */ 2196 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2197 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2198 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2199 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2200 2201 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 2202 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2203 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2204 /* Mic2 (as headphone out) for HP output */ 2205 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2206 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2207 /* Line In pin widget for input */ 2208 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2209 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2210 /* Line2 (as front mic) pin widget for input and vref at 80% */ 2211 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2212 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2213 /* CD pin widget for input */ 2214 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2215 2216 { } 2217}; 2218 2219/* 2220 * W810 pin configuration: 2221 * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b 2222 */ 2223static struct hda_verb alc880_pin_w810_init_verbs[] = { 2224 /* hphone/speaker input selector: front DAC */ 2225 {0x13, AC_VERB_SET_CONNECT_SEL, 0x0}, 2226 2227 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2228 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2229 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2230 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2231 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2232 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2233 2234 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2235 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2236 2237 { } 2238}; 2239 2240/* 2241 * Z71V pin configuration: 2242 * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?) 2243 */ 2244static struct hda_verb alc880_pin_z71v_init_verbs[] = { 2245 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2246 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2247 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2248 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2249 2250 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2251 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2252 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2253 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2254 2255 { } 2256}; 2257 2258/* 2259 * 6-stack pin configuration: 2260 * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18, 2261 * f-mic = 0x19, line = 0x1a, HP = 0x1b 2262 */ 2263static struct hda_verb alc880_pin_6stack_init_verbs[] = { 2264 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 2265 2266 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2267 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2268 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2269 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2270 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2271 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2272 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2273 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2274 2275 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2276 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2277 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2278 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2279 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2280 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2281 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2282 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2283 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2284 2285 { } 2286}; 2287 2288/* 2289 * Uniwill pin configuration: 2290 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19, 2291 * line = 0x1a 2292 */ 2293static struct hda_verb alc880_uniwill_init_verbs[] = { 2294 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 2295 2296 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2297 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2298 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2299 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2300 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2301 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2302 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2303 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2304 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 2305 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 2306 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 2307 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 2308 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 2309 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 2310 2311 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2312 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2313 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2314 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2315 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2316 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2317 /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */ 2318 /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */ 2319 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2320 2321 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 2322 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 2323 2324 { } 2325}; 2326 2327/* 2328* Uniwill P53 2329* HP = 0x14, InternalSpeaker = 0x15, mic = 0x19, 2330 */ 2331static struct hda_verb alc880_uniwill_p53_init_verbs[] = { 2332 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 2333 2334 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2335 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2336 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2337 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2338 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2339 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2340 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 2341 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 2342 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 2343 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 2344 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 2345 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 2346 2347 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2348 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2349 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2350 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2351 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2352 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2353 2354 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 2355 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT}, 2356 2357 { } 2358}; 2359 2360static struct hda_verb alc880_beep_init_verbs[] = { 2361 { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) }, 2362 { } 2363}; 2364 2365/* toggle speaker-output according to the hp-jack state */ 2366static void alc880_uniwill_hp_automute(struct hda_codec *codec) 2367{ 2368 unsigned int present; 2369 unsigned char bits; 2370 2371 present = snd_hda_codec_read(codec, 0x14, 0, 2372 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 2373 bits = present ? HDA_AMP_MUTE : 0; 2374 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 2375 HDA_AMP_MUTE, bits); 2376 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 2377 HDA_AMP_MUTE, bits); 2378} 2379 2380/* auto-toggle front mic */ 2381static void alc880_uniwill_mic_automute(struct hda_codec *codec) 2382{ 2383 unsigned int present; 2384 unsigned char bits; 2385 2386 present = snd_hda_codec_read(codec, 0x18, 0, 2387 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 2388 bits = present ? HDA_AMP_MUTE : 0; 2389 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits); 2390} 2391 2392static void alc880_uniwill_automute(struct hda_codec *codec) 2393{ 2394 alc880_uniwill_hp_automute(codec); 2395 alc880_uniwill_mic_automute(codec); 2396} 2397 2398static void alc880_uniwill_unsol_event(struct hda_codec *codec, 2399 unsigned int res) 2400{ 2401 /* Looks like the unsol event is incompatible with the standard 2402 * definition. 4bit tag is placed at 28 bit! 2403 */ 2404 switch (res >> 28) { 2405 case ALC880_HP_EVENT: 2406 alc880_uniwill_hp_automute(codec); 2407 break; 2408 case ALC880_MIC_EVENT: 2409 alc880_uniwill_mic_automute(codec); 2410 break; 2411 } 2412} 2413 2414static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec) 2415{ 2416 unsigned int present; 2417 unsigned char bits; 2418 2419 present = snd_hda_codec_read(codec, 0x14, 0, 2420 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 2421 bits = present ? HDA_AMP_MUTE : 0; 2422 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, HDA_AMP_MUTE, bits); 2423} 2424 2425static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec) 2426{ 2427 unsigned int present; 2428 2429 present = snd_hda_codec_read(codec, 0x21, 0, 2430 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0); 2431 present &= HDA_AMP_VOLMASK; 2432 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, 2433 HDA_AMP_VOLMASK, present); 2434 snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0, 2435 HDA_AMP_VOLMASK, present); 2436} 2437 2438static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec, 2439 unsigned int res) 2440{ 2441 /* Looks like the unsol event is incompatible with the standard 2442 * definition. 4bit tag is placed at 28 bit! 2443 */ 2444 if ((res >> 28) == ALC880_HP_EVENT) 2445 alc880_uniwill_p53_hp_automute(codec); 2446 if ((res >> 28) == ALC880_DCVOL_EVENT) 2447 alc880_uniwill_p53_dcvol_automute(codec); 2448} 2449 2450/* 2451 * F1734 pin configuration: 2452 * HP = 0x14, speaker-out = 0x15, mic = 0x18 2453 */ 2454static struct hda_verb alc880_pin_f1734_init_verbs[] = { 2455 {0x07, AC_VERB_SET_CONNECT_SEL, 0x01}, 2456 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, 2457 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, 2458 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, 2459 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, 2460 2461 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2462 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2463 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2464 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2465 2466 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2467 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2468 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50}, 2469 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2470 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2471 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2472 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2473 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2474 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2475 2476 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT}, 2477 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT}, 2478 2479 { } 2480}; 2481 2482/* 2483 * ASUS pin configuration: 2484 * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a 2485 */ 2486static struct hda_verb alc880_pin_asus_init_verbs[] = { 2487 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, 2488 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, 2489 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, 2490 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, 2491 2492 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2493 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2494 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2495 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2496 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2497 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2498 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2499 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2500 2501 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2502 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2503 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2504 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2505 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2506 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2507 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2508 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2509 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2510 2511 { } 2512}; 2513 2514/* Enable GPIO mask and set output */ 2515#define alc880_gpio1_init_verbs alc_gpio1_init_verbs 2516#define alc880_gpio2_init_verbs alc_gpio2_init_verbs 2517 2518/* Clevo m520g init */ 2519static struct hda_verb alc880_pin_clevo_init_verbs[] = { 2520 /* headphone output */ 2521 {0x11, AC_VERB_SET_CONNECT_SEL, 0x01}, 2522 /* line-out */ 2523 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2524 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2525 /* Line-in */ 2526 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2527 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2528 /* CD */ 2529 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2530 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2531 /* Mic1 (rear panel) */ 2532 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2533 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2534 /* Mic2 (front panel) */ 2535 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2536 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2537 /* headphone */ 2538 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2539 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2540 /* change to EAPD mode */ 2541 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 2542 {0x20, AC_VERB_SET_PROC_COEF, 0x3060}, 2543 2544 { } 2545}; 2546 2547static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = { 2548 /* change to EAPD mode */ 2549 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 2550 {0x20, AC_VERB_SET_PROC_COEF, 0x3060}, 2551 2552 /* Headphone output */ 2553 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2554 /* Front output*/ 2555 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2556 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 2557 2558 /* Line In pin widget for input */ 2559 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2560 /* CD pin widget for input */ 2561 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2562 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 2563 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2564 2565 /* change to EAPD mode */ 2566 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 2567 {0x20, AC_VERB_SET_PROC_COEF, 0x3070}, 2568 2569 { } 2570}; 2571 2572/* 2573 * LG m1 express dual 2574 * 2575 * Pin assignment: 2576 * Rear Line-In/Out (blue): 0x14 2577 * Build-in Mic-In: 0x15 2578 * Speaker-out: 0x17 2579 * HP-Out (green): 0x1b 2580 * Mic-In/Out (red): 0x19 2581 * SPDIF-Out: 0x1e 2582 */ 2583 2584/* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */ 2585static hda_nid_t alc880_lg_dac_nids[3] = { 2586 0x05, 0x02, 0x03 2587}; 2588 2589/* seems analog CD is not working */ 2590static struct hda_input_mux alc880_lg_capture_source = { 2591 .num_items = 3, 2592 .items = { 2593 { "Mic", 0x1 }, 2594 { "Line", 0x5 }, 2595 { "Internal Mic", 0x6 }, 2596 }, 2597}; 2598 2599/* 2,4,6 channel modes */ 2600static struct hda_verb alc880_lg_ch2_init[] = { 2601 /* set line-in and mic-in to input */ 2602 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 2603 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 2604 { } 2605}; 2606 2607static struct hda_verb alc880_lg_ch4_init[] = { 2608 /* set line-in to out and mic-in to input */ 2609 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, 2610 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 2611 { } 2612}; 2613 2614static struct hda_verb alc880_lg_ch6_init[] = { 2615 /* set line-in and mic-in to output */ 2616 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, 2617 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, 2618 { } 2619}; 2620 2621static struct hda_channel_mode alc880_lg_ch_modes[3] = { 2622 { 2, alc880_lg_ch2_init }, 2623 { 4, alc880_lg_ch4_init }, 2624 { 6, alc880_lg_ch6_init }, 2625}; 2626 2627static struct snd_kcontrol_new alc880_lg_mixer[] = { 2628 HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 2629 HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT), 2630 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2631 HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT), 2632 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT), 2633 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT), 2634 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT), 2635 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT), 2636 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 2637 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 2638 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT), 2639 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT), 2640 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT), 2641 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT), 2642 { 2643 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2644 .name = "Channel Mode", 2645 .info = alc_ch_mode_info, 2646 .get = alc_ch_mode_get, 2647 .put = alc_ch_mode_put, 2648 }, 2649 { } /* end */ 2650}; 2651 2652static struct hda_verb alc880_lg_init_verbs[] = { 2653 /* set capture source to mic-in */ 2654 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2655 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2656 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2657 /* mute all amp mixer inputs */ 2658 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)}, 2659 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 2660 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 2661 /* line-in to input */ 2662 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2663 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2664 /* built-in mic */ 2665 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2666 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2667 /* speaker-out */ 2668 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2669 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2670 /* mic-in to input */ 2671 {0x11, AC_VERB_SET_CONNECT_SEL, 0x01}, 2672 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2673 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2674 /* HP-out */ 2675 {0x13, AC_VERB_SET_CONNECT_SEL, 0x03}, 2676 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2677 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2678 /* jack sense */ 2679 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1}, 2680 { } 2681}; 2682 2683/* toggle speaker-output according to the hp-jack state */ 2684static void alc880_lg_automute(struct hda_codec *codec) 2685{ 2686 unsigned int present; 2687 unsigned char bits; 2688 2689 present = snd_hda_codec_read(codec, 0x1b, 0, 2690 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 2691 bits = present ? HDA_AMP_MUTE : 0; 2692 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0, 2693 HDA_AMP_MUTE, bits); 2694} 2695 2696static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res) 2697{ 2698 /* Looks like the unsol event is incompatible with the standard 2699 * definition. 4bit tag is placed at 28 bit! 2700 */ 2701 if ((res >> 28) == 0x01) 2702 alc880_lg_automute(codec); 2703} 2704 2705/* 2706 * LG LW20 2707 * 2708 * Pin assignment: 2709 * Speaker-out: 0x14 2710 * Mic-In: 0x18 2711 * Built-in Mic-In: 0x19 2712 * Line-In: 0x1b 2713 * HP-Out: 0x1a 2714 * SPDIF-Out: 0x1e 2715 */ 2716 2717static struct hda_input_mux alc880_lg_lw_capture_source = { 2718 .num_items = 3, 2719 .items = { 2720 { "Mic", 0x0 }, 2721 { "Internal Mic", 0x1 }, 2722 { "Line In", 0x2 }, 2723 }, 2724}; 2725 2726#define alc880_lg_lw_modes alc880_threestack_modes 2727 2728static struct snd_kcontrol_new alc880_lg_lw_mixer[] = { 2729 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2730 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 2731 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 2732 HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT), 2733 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 2734 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 2735 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 2736 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 2737 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 2738 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 2739 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 2740 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 2741 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 2742 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 2743 { 2744 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2745 .name = "Channel Mode", 2746 .info = alc_ch_mode_info, 2747 .get = alc_ch_mode_get, 2748 .put = alc_ch_mode_put, 2749 }, 2750 { } /* end */ 2751}; 2752 2753static struct hda_verb alc880_lg_lw_init_verbs[] = { 2754 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 2755 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 2756 {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */ 2757 2758 /* set capture source to mic-in */ 2759 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2760 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2761 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2762 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 2763 /* speaker-out */ 2764 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2765 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2766 /* HP-out */ 2767 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2768 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2769 /* mic-in to input */ 2770 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2771 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2772 /* built-in mic */ 2773 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2774 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2775 /* jack sense */ 2776 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1}, 2777 { } 2778}; 2779 2780/* toggle speaker-output according to the hp-jack state */ 2781static void alc880_lg_lw_automute(struct hda_codec *codec) 2782{ 2783 unsigned int present; 2784 unsigned char bits; 2785 2786 present = snd_hda_codec_read(codec, 0x1b, 0, 2787 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 2788 bits = present ? HDA_AMP_MUTE : 0; 2789 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 2790 HDA_AMP_MUTE, bits); 2791} 2792 2793static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res) 2794{ 2795 /* Looks like the unsol event is incompatible with the standard 2796 * definition. 4bit tag is placed at 28 bit! 2797 */ 2798 if ((res >> 28) == 0x01) 2799 alc880_lg_lw_automute(codec); 2800} 2801 2802static struct snd_kcontrol_new alc880_medion_rim_mixer[] = { 2803 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2804 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT), 2805 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 2806 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 2807 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 2808 HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT), 2809 { } /* end */ 2810}; 2811 2812static struct hda_input_mux alc880_medion_rim_capture_source = { 2813 .num_items = 2, 2814 .items = { 2815 { "Mic", 0x0 }, 2816 { "Internal Mic", 0x1 }, 2817 }, 2818}; 2819 2820static struct hda_verb alc880_medion_rim_init_verbs[] = { 2821 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 2822 2823 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2824 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2825 2826 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 2827 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2828 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2829 /* Mic2 (as headphone out) for HP output */ 2830 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2831 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2832 /* Internal Speaker */ 2833 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2834 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2835 2836 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 2837 {0x20, AC_VERB_SET_PROC_COEF, 0x3060}, 2838 2839 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 2840 { } 2841}; 2842 2843/* toggle speaker-output according to the hp-jack state */ 2844static void alc880_medion_rim_automute(struct hda_codec *codec) 2845{ 2846 unsigned int present; 2847 unsigned char bits; 2848 2849 present = snd_hda_codec_read(codec, 0x14, 0, 2850 AC_VERB_GET_PIN_SENSE, 0) 2851 & AC_PINSENSE_PRESENCE; 2852 bits = present ? HDA_AMP_MUTE : 0; 2853 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 2854 HDA_AMP_MUTE, bits); 2855 if (present) 2856 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0); 2857 else 2858 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2); 2859} 2860 2861static void alc880_medion_rim_unsol_event(struct hda_codec *codec, 2862 unsigned int res) 2863{ 2864 /* Looks like the unsol event is incompatible with the standard 2865 * definition. 4bit tag is placed at 28 bit! 2866 */ 2867 if ((res >> 28) == ALC880_HP_EVENT) 2868 alc880_medion_rim_automute(codec); 2869} 2870 2871#ifdef CONFIG_SND_HDA_POWER_SAVE 2872static struct hda_amp_list alc880_loopbacks[] = { 2873 { 0x0b, HDA_INPUT, 0 }, 2874 { 0x0b, HDA_INPUT, 1 }, 2875 { 0x0b, HDA_INPUT, 2 }, 2876 { 0x0b, HDA_INPUT, 3 }, 2877 { 0x0b, HDA_INPUT, 4 }, 2878 { } /* end */ 2879}; 2880 2881static struct hda_amp_list alc880_lg_loopbacks[] = { 2882 { 0x0b, HDA_INPUT, 1 }, 2883 { 0x0b, HDA_INPUT, 6 }, 2884 { 0x0b, HDA_INPUT, 7 }, 2885 { } /* end */ 2886}; 2887#endif 2888 2889/* 2890 * Common callbacks 2891 */ 2892 2893static int alc_init(struct hda_codec *codec) 2894{ 2895 struct alc_spec *spec = codec->spec; 2896 unsigned int i; 2897 2898 alc_fix_pll(codec); 2899 if (codec->vendor_id == 0x10ec0888) 2900 alc888_coef_init(codec); 2901 2902 for (i = 0; i < spec->num_init_verbs; i++) 2903 snd_hda_sequence_write(codec, spec->init_verbs[i]); 2904 2905 if (spec->init_hook) 2906 spec->init_hook(codec); 2907 2908 return 0; 2909} 2910 2911static void alc_unsol_event(struct hda_codec *codec, unsigned int res) 2912{ 2913 struct alc_spec *spec = codec->spec; 2914 2915 if (spec->unsol_event) 2916 spec->unsol_event(codec, res); 2917} 2918 2919#ifdef CONFIG_SND_HDA_POWER_SAVE 2920static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid) 2921{ 2922 struct alc_spec *spec = codec->spec; 2923 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid); 2924} 2925#endif 2926 2927/* 2928 * Analog playback callbacks 2929 */ 2930static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo, 2931 struct hda_codec *codec, 2932 struct snd_pcm_substream *substream) 2933{ 2934 struct alc_spec *spec = codec->spec; 2935 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, 2936 hinfo); 2937} 2938 2939static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 2940 struct hda_codec *codec, 2941 unsigned int stream_tag, 2942 unsigned int format, 2943 struct snd_pcm_substream *substream) 2944{ 2945 struct alc_spec *spec = codec->spec; 2946 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, 2947 stream_tag, format, substream); 2948} 2949 2950static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 2951 struct hda_codec *codec, 2952 struct snd_pcm_substream *substream) 2953{ 2954 struct alc_spec *spec = codec->spec; 2955 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); 2956} 2957 2958/* 2959 * Digital out 2960 */ 2961static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, 2962 struct hda_codec *codec, 2963 struct snd_pcm_substream *substream) 2964{ 2965 struct alc_spec *spec = codec->spec; 2966 return snd_hda_multi_out_dig_open(codec, &spec->multiout); 2967} 2968 2969static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 2970 struct hda_codec *codec, 2971 unsigned int stream_tag, 2972 unsigned int format, 2973 struct snd_pcm_substream *substream) 2974{ 2975 struct alc_spec *spec = codec->spec; 2976 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, 2977 stream_tag, format, substream); 2978} 2979 2980static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, 2981 struct hda_codec *codec, 2982 struct snd_pcm_substream *substream) 2983{ 2984 struct alc_spec *spec = codec->spec; 2985 return snd_hda_multi_out_dig_close(codec, &spec->multiout); 2986} 2987 2988/* 2989 * Analog capture 2990 */ 2991static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 2992 struct hda_codec *codec, 2993 unsigned int stream_tag, 2994 unsigned int format, 2995 struct snd_pcm_substream *substream) 2996{ 2997 struct alc_spec *spec = codec->spec; 2998 2999 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1], 3000 stream_tag, 0, format); 3001 return 0; 3002} 3003 3004static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 3005 struct hda_codec *codec, 3006 struct snd_pcm_substream *substream) 3007{ 3008 struct alc_spec *spec = codec->spec; 3009 3010 snd_hda_codec_cleanup_stream(codec, 3011 spec->adc_nids[substream->number + 1]); 3012 return 0; 3013} 3014 3015 3016/* 3017 */ 3018static struct hda_pcm_stream alc880_pcm_analog_playback = { 3019 .substreams = 1, 3020 .channels_min = 2, 3021 .channels_max = 8, 3022 /* NID is set in alc_build_pcms */ 3023 .ops = { 3024 .open = alc880_playback_pcm_open, 3025 .prepare = alc880_playback_pcm_prepare, 3026 .cleanup = alc880_playback_pcm_cleanup 3027 }, 3028}; 3029 3030static struct hda_pcm_stream alc880_pcm_analog_capture = { 3031 .substreams = 1, 3032 .channels_min = 2, 3033 .channels_max = 2, 3034 /* NID is set in alc_build_pcms */ 3035}; 3036 3037static struct hda_pcm_stream alc880_pcm_analog_alt_playback = { 3038 .substreams = 1, 3039 .channels_min = 2, 3040 .channels_max = 2, 3041 /* NID is set in alc_build_pcms */ 3042}; 3043 3044static struct hda_pcm_stream alc880_pcm_analog_alt_capture = { 3045 .substreams = 2, /* can be overridden */ 3046 .channels_min = 2, 3047 .channels_max = 2, 3048 /* NID is set in alc_build_pcms */ 3049 .ops = { 3050 .prepare = alc880_alt_capture_pcm_prepare, 3051 .cleanup = alc880_alt_capture_pcm_cleanup 3052 }, 3053}; 3054 3055static struct hda_pcm_stream alc880_pcm_digital_playback = { 3056 .substreams = 1, 3057 .channels_min = 2, 3058 .channels_max = 2, 3059 /* NID is set in alc_build_pcms */ 3060 .ops = { 3061 .open = alc880_dig_playback_pcm_open, 3062 .close = alc880_dig_playback_pcm_close, 3063 .prepare = alc880_dig_playback_pcm_prepare 3064 }, 3065}; 3066 3067static struct hda_pcm_stream alc880_pcm_digital_capture = { 3068 .substreams = 1, 3069 .channels_min = 2, 3070 .channels_max = 2, 3071 /* NID is set in alc_build_pcms */ 3072}; 3073 3074/* Used by alc_build_pcms to flag that a PCM has no playback stream */ 3075static struct hda_pcm_stream alc_pcm_null_stream = { 3076 .substreams = 0, 3077 .channels_min = 0, 3078 .channels_max = 0, 3079}; 3080 3081static int alc_build_pcms(struct hda_codec *codec) 3082{ 3083 struct alc_spec *spec = codec->spec; 3084 struct hda_pcm *info = spec->pcm_rec; 3085 int i; 3086 3087 codec->num_pcms = 1; 3088 codec->pcm_info = info; 3089 3090 if (spec->no_analog) 3091 goto skip_analog; 3092 3093 info->name = spec->stream_name_analog; 3094 if (spec->stream_analog_playback) { 3095 if (snd_BUG_ON(!spec->multiout.dac_nids)) 3096 return -EINVAL; 3097 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback); 3098 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0]; 3099 } 3100 if (spec->stream_analog_capture) { 3101 if (snd_BUG_ON(!spec->adc_nids)) 3102 return -EINVAL; 3103 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture); 3104 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; 3105 } 3106 3107 if (spec->channel_mode) { 3108 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0; 3109 for (i = 0; i < spec->num_channel_mode; i++) { 3110 if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) { 3111 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels; 3112 } 3113 } 3114 } 3115 3116 skip_analog: 3117 /* SPDIF for stream index #1 */ 3118 if (spec->multiout.dig_out_nid || spec->dig_in_nid) { 3119 codec->num_pcms = 2; 3120 codec->slave_dig_outs = spec->multiout.slave_dig_outs; 3121 info = spec->pcm_rec + 1; 3122 info->name = spec->stream_name_digital; 3123 if (spec->dig_out_type) 3124 info->pcm_type = spec->dig_out_type; 3125 else 3126 info->pcm_type = HDA_PCM_TYPE_SPDIF; 3127 if (spec->multiout.dig_out_nid && 3128 spec->stream_digital_playback) { 3129 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback); 3130 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid; 3131 } 3132 if (spec->dig_in_nid && 3133 spec->stream_digital_capture) { 3134 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture); 3135 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid; 3136 } 3137 /* FIXME: do we need this for all Realtek codec models? */ 3138 codec->spdif_status_reset = 1; 3139 } 3140 3141 if (spec->no_analog) 3142 return 0; 3143 3144 /* If the use of more than one ADC is requested for the current 3145 * model, configure a second analog capture-only PCM. 3146 */ 3147 /* Additional Analaog capture for index #2 */ 3148 if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) || 3149 (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) { 3150 codec->num_pcms = 3; 3151 info = spec->pcm_rec + 2; 3152 info->name = spec->stream_name_analog; 3153 if (spec->alt_dac_nid) { 3154 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 3155 *spec->stream_analog_alt_playback; 3156 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 3157 spec->alt_dac_nid; 3158 } else { 3159 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 3160 alc_pcm_null_stream; 3161 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0; 3162 } 3163 if (spec->num_adc_nids > 1) { 3164 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 3165 *spec->stream_analog_alt_capture; 3166 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 3167 spec->adc_nids[1]; 3168 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 3169 spec->num_adc_nids - 1; 3170 } else { 3171 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 3172 alc_pcm_null_stream; 3173 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0; 3174 } 3175 } 3176 3177 return 0; 3178} 3179 3180static void alc_free_kctls(struct hda_codec *codec) 3181{ 3182 struct alc_spec *spec = codec->spec; 3183 3184 if (spec->kctls.list) { 3185 struct snd_kcontrol_new *kctl = spec->kctls.list; 3186 int i; 3187 for (i = 0; i < spec->kctls.used; i++) 3188 kfree(kctl[i].name); 3189 } 3190 snd_array_free(&spec->kctls); 3191} 3192 3193static void alc_free(struct hda_codec *codec) 3194{ 3195 struct alc_spec *spec = codec->spec; 3196 3197 if (!spec) 3198 return; 3199 3200 alc_free_kctls(codec); 3201 kfree(spec); 3202 snd_hda_detach_beep_device(codec); 3203 codec->spec = NULL; /* to be sure */ 3204} 3205 3206#ifdef SND_HDA_NEEDS_RESUME 3207static void store_pin_configs(struct hda_codec *codec) 3208{ 3209 struct alc_spec *spec = codec->spec; 3210 hda_nid_t nid, end_nid; 3211 3212 end_nid = codec->start_nid + codec->num_nodes; 3213 for (nid = codec->start_nid; nid < end_nid; nid++) { 3214 unsigned int wid_caps = get_wcaps(codec, nid); 3215 unsigned int wid_type = 3216 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 3217 if (wid_type != AC_WID_PIN) 3218 continue; 3219 if (spec->num_pins >= ARRAY_SIZE(spec->pin_nids)) 3220 break; 3221 spec->pin_nids[spec->num_pins] = nid; 3222 spec->pin_cfgs[spec->num_pins] = 3223 snd_hda_codec_read(codec, nid, 0, 3224 AC_VERB_GET_CONFIG_DEFAULT, 0); 3225 spec->num_pins++; 3226 } 3227} 3228 3229static void resume_pin_configs(struct hda_codec *codec) 3230{ 3231 struct alc_spec *spec = codec->spec; 3232 int i; 3233 3234 for (i = 0; i < spec->num_pins; i++) { 3235 hda_nid_t pin_nid = spec->pin_nids[i]; 3236 unsigned int pin_config = spec->pin_cfgs[i]; 3237 snd_hda_codec_write(codec, pin_nid, 0, 3238 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0, 3239 pin_config & 0x000000ff); 3240 snd_hda_codec_write(codec, pin_nid, 0, 3241 AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 3242 (pin_config & 0x0000ff00) >> 8); 3243 snd_hda_codec_write(codec, pin_nid, 0, 3244 AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 3245 (pin_config & 0x00ff0000) >> 16); 3246 snd_hda_codec_write(codec, pin_nid, 0, 3247 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 3248 pin_config >> 24); 3249 } 3250} 3251 3252static int alc_resume(struct hda_codec *codec) 3253{ 3254 resume_pin_configs(codec); 3255 codec->patch_ops.init(codec); 3256 snd_hda_codec_resume_amp(codec); 3257 snd_hda_codec_resume_cache(codec); 3258 return 0; 3259} 3260#else 3261#define store_pin_configs(codec) 3262#endif 3263 3264/* 3265 */ 3266static struct hda_codec_ops alc_patch_ops = { 3267 .build_controls = alc_build_controls, 3268 .build_pcms = alc_build_pcms, 3269 .init = alc_init, 3270 .free = alc_free, 3271 .unsol_event = alc_unsol_event, 3272#ifdef SND_HDA_NEEDS_RESUME 3273 .resume = alc_resume, 3274#endif 3275#ifdef CONFIG_SND_HDA_POWER_SAVE 3276 .check_power_status = alc_check_power_status, 3277#endif 3278}; 3279 3280 3281/* 3282 * Test configuration for debugging 3283 * 3284 * Almost all inputs/outputs are enabled. I/O pins can be configured via 3285 * enum controls. 3286 */ 3287#ifdef CONFIG_SND_DEBUG 3288static hda_nid_t alc880_test_dac_nids[4] = { 3289 0x02, 0x03, 0x04, 0x05 3290}; 3291 3292static struct hda_input_mux alc880_test_capture_source = { 3293 .num_items = 7, 3294 .items = { 3295 { "In-1", 0x0 }, 3296 { "In-2", 0x1 }, 3297 { "In-3", 0x2 }, 3298 { "In-4", 0x3 }, 3299 { "CD", 0x4 }, 3300 { "Front", 0x5 }, 3301 { "Surround", 0x6 }, 3302 }, 3303}; 3304 3305static struct hda_channel_mode alc880_test_modes[4] = { 3306 { 2, NULL }, 3307 { 4, NULL }, 3308 { 6, NULL }, 3309 { 8, NULL }, 3310}; 3311 3312static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol, 3313 struct snd_ctl_elem_info *uinfo) 3314{ 3315 static char *texts[] = { 3316 "N/A", "Line Out", "HP Out", 3317 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%" 3318 }; 3319 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 3320 uinfo->count = 1; 3321 uinfo->value.enumerated.items = 8; 3322 if (uinfo->value.enumerated.item >= 8) 3323 uinfo->value.enumerated.item = 7; 3324 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 3325 return 0; 3326} 3327 3328static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol, 3329 struct snd_ctl_elem_value *ucontrol) 3330{ 3331 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3332 hda_nid_t nid = (hda_nid_t)kcontrol->private_value; 3333 unsigned int pin_ctl, item = 0; 3334 3335 pin_ctl = snd_hda_codec_read(codec, nid, 0, 3336 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 3337 if (pin_ctl & AC_PINCTL_OUT_EN) { 3338 if (pin_ctl & AC_PINCTL_HP_EN) 3339 item = 2; 3340 else 3341 item = 1; 3342 } else if (pin_ctl & AC_PINCTL_IN_EN) { 3343 switch (pin_ctl & AC_PINCTL_VREFEN) { 3344 case AC_PINCTL_VREF_HIZ: item = 3; break; 3345 case AC_PINCTL_VREF_50: item = 4; break; 3346 case AC_PINCTL_VREF_GRD: item = 5; break; 3347 case AC_PINCTL_VREF_80: item = 6; break; 3348 case AC_PINCTL_VREF_100: item = 7; break; 3349 } 3350 } 3351 ucontrol->value.enumerated.item[0] = item; 3352 return 0; 3353} 3354 3355static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol, 3356 struct snd_ctl_elem_value *ucontrol) 3357{ 3358 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3359 hda_nid_t nid = (hda_nid_t)kcontrol->private_value; 3360 static unsigned int ctls[] = { 3361 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN, 3362 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ, 3363 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50, 3364 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD, 3365 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80, 3366 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100, 3367 }; 3368 unsigned int old_ctl, new_ctl; 3369 3370 old_ctl = snd_hda_codec_read(codec, nid, 0, 3371 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 3372 new_ctl = ctls[ucontrol->value.enumerated.item[0]]; 3373 if (old_ctl != new_ctl) { 3374 int val; 3375 snd_hda_codec_write_cache(codec, nid, 0, 3376 AC_VERB_SET_PIN_WIDGET_CONTROL, 3377 new_ctl); 3378 val = ucontrol->value.enumerated.item[0] >= 3 ? 3379 HDA_AMP_MUTE : 0; 3380 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 3381 HDA_AMP_MUTE, val); 3382 return 1; 3383 } 3384 return 0; 3385} 3386 3387static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol, 3388 struct snd_ctl_elem_info *uinfo) 3389{ 3390 static char *texts[] = { 3391 "Front", "Surround", "CLFE", "Side" 3392 }; 3393 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 3394 uinfo->count = 1; 3395 uinfo->value.enumerated.items = 4; 3396 if (uinfo->value.enumerated.item >= 4) 3397 uinfo->value.enumerated.item = 3; 3398 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 3399 return 0; 3400} 3401 3402static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol, 3403 struct snd_ctl_elem_value *ucontrol) 3404{ 3405 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3406 hda_nid_t nid = (hda_nid_t)kcontrol->private_value; 3407 unsigned int sel; 3408 3409 sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0); 3410 ucontrol->value.enumerated.item[0] = sel & 3; 3411 return 0; 3412} 3413 3414static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol, 3415 struct snd_ctl_elem_value *ucontrol) 3416{ 3417 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3418 hda_nid_t nid = (hda_nid_t)kcontrol->private_value; 3419 unsigned int sel; 3420 3421 sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3; 3422 if (ucontrol->value.enumerated.item[0] != sel) { 3423 sel = ucontrol->value.enumerated.item[0] & 3; 3424 snd_hda_codec_write_cache(codec, nid, 0, 3425 AC_VERB_SET_CONNECT_SEL, sel); 3426 return 1; 3427 } 3428 return 0; 3429} 3430 3431#define PIN_CTL_TEST(xname,nid) { \ 3432 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 3433 .name = xname, \ 3434 .info = alc_test_pin_ctl_info, \ 3435 .get = alc_test_pin_ctl_get, \ 3436 .put = alc_test_pin_ctl_put, \ 3437 .private_value = nid \ 3438 } 3439 3440#define PIN_SRC_TEST(xname,nid) { \ 3441 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 3442 .name = xname, \ 3443 .info = alc_test_pin_src_info, \ 3444 .get = alc_test_pin_src_get, \ 3445 .put = alc_test_pin_src_put, \ 3446 .private_value = nid \ 3447 } 3448 3449static struct snd_kcontrol_new alc880_test_mixer[] = { 3450 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 3451 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 3452 HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT), 3453 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 3454 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 3455 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 3456 HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT), 3457 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 3458 PIN_CTL_TEST("Front Pin Mode", 0x14), 3459 PIN_CTL_TEST("Surround Pin Mode", 0x15), 3460 PIN_CTL_TEST("CLFE Pin Mode", 0x16), 3461 PIN_CTL_TEST("Side Pin Mode", 0x17), 3462 PIN_CTL_TEST("In-1 Pin Mode", 0x18), 3463 PIN_CTL_TEST("In-2 Pin Mode", 0x19), 3464 PIN_CTL_TEST("In-3 Pin Mode", 0x1a), 3465 PIN_CTL_TEST("In-4 Pin Mode", 0x1b), 3466 PIN_SRC_TEST("In-1 Pin Source", 0x18), 3467 PIN_SRC_TEST("In-2 Pin Source", 0x19), 3468 PIN_SRC_TEST("In-3 Pin Source", 0x1a), 3469 PIN_SRC_TEST("In-4 Pin Source", 0x1b), 3470 HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT), 3471 HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT), 3472 HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT), 3473 HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT), 3474 HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT), 3475 HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT), 3476 HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT), 3477 HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT), 3478 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT), 3479 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT), 3480 { 3481 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3482 .name = "Channel Mode", 3483 .info = alc_ch_mode_info, 3484 .get = alc_ch_mode_get, 3485 .put = alc_ch_mode_put, 3486 }, 3487 { } /* end */ 3488}; 3489 3490static struct hda_verb alc880_test_init_verbs[] = { 3491 /* Unmute inputs of 0x0c - 0x0f */ 3492 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3493 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3494 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3495 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3496 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3497 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3498 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3499 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3500 /* Vol output for 0x0c-0x0f */ 3501 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 3502 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 3503 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 3504 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 3505 /* Set output pins 0x14-0x17 */ 3506 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3507 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3508 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3509 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3510 /* Unmute output pins 0x14-0x17 */ 3511 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3512 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3513 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3514 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3515 /* Set input pins 0x18-0x1c */ 3516 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3517 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3518 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3519 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3520 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3521 /* Mute input pins 0x18-0x1b */ 3522 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3523 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3524 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3525 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3526 /* ADC set up */ 3527 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3528 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 3529 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3530 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 3531 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3532 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 3533 /* Analog input/passthru */ 3534 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3535 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 3536 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 3537 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 3538 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 3539 { } 3540}; 3541#endif 3542 3543/* 3544 */ 3545 3546static const char *alc880_models[ALC880_MODEL_LAST] = { 3547 [ALC880_3ST] = "3stack", 3548 [ALC880_TCL_S700] = "tcl", 3549 [ALC880_3ST_DIG] = "3stack-digout", 3550 [ALC880_CLEVO] = "clevo", 3551 [ALC880_5ST] = "5stack", 3552 [ALC880_5ST_DIG] = "5stack-digout", 3553 [ALC880_W810] = "w810", 3554 [ALC880_Z71V] = "z71v", 3555 [ALC880_6ST] = "6stack", 3556 [ALC880_6ST_DIG] = "6stack-digout", 3557 [ALC880_ASUS] = "asus", 3558 [ALC880_ASUS_W1V] = "asus-w1v", 3559 [ALC880_ASUS_DIG] = "asus-dig", 3560 [ALC880_ASUS_DIG2] = "asus-dig2", 3561 [ALC880_UNIWILL_DIG] = "uniwill", 3562 [ALC880_UNIWILL_P53] = "uniwill-p53", 3563 [ALC880_FUJITSU] = "fujitsu", 3564 [ALC880_F1734] = "F1734", 3565 [ALC880_LG] = "lg", 3566 [ALC880_LG_LW] = "lg-lw", 3567 [ALC880_MEDION_RIM] = "medion", 3568#ifdef CONFIG_SND_DEBUG 3569 [ALC880_TEST] = "test", 3570#endif 3571 [ALC880_AUTO] = "auto", 3572}; 3573 3574static struct snd_pci_quirk alc880_cfg_tbl[] = { 3575 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810), 3576 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG), 3577 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST), 3578 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG), 3579 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG), 3580 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG), 3581 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG), 3582 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG), 3583 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST), 3584 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG), 3585 SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST), 3586 SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V), 3587 SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG), 3588 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG), 3589 SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG), 3590 SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG), 3591 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG), 3592 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V), 3593 /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */ 3594 SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG), 3595 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG), 3596 SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG), 3597 SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG), 3598 SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST), 3599 SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST), 3600 SND_PCI_QUIRK(0x1043, 0, "ASUS", ALC880_ASUS), /* default ASUS */ 3601 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST), 3602 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST), 3603 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST), 3604 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST), 3605 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST), 3606 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG), 3607 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG), 3608 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG), 3609 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG), 3610 SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO), 3611 SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO), 3612 SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2), 3613 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG), 3614 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG), 3615 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734), 3616 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL), 3617 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53), 3618 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810), 3619 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM), 3620 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG), 3621 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG), 3622 SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734), 3623 SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU), 3624 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL), 3625 SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU), 3626 SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW), 3627 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG), 3628 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG), 3629 SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW), 3630 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700), 3631 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */ 3632 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG), 3633 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG), 3634 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG), 3635 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG), 3636 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG), 3637 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG), 3638 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG), 3639 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG), 3640 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG), 3641 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG), 3642 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG), 3643 SND_PCI_QUIRK(0x8086, 0, "Intel mobo", ALC880_3ST), /* default Intel */ 3644 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG), 3645 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG), 3646 {} 3647}; 3648 3649/* 3650 * ALC880 codec presets 3651 */ 3652static struct alc_config_preset alc880_presets[] = { 3653 [ALC880_3ST] = { 3654 .mixers = { alc880_three_stack_mixer }, 3655 .init_verbs = { alc880_volume_init_verbs, 3656 alc880_pin_3stack_init_verbs }, 3657 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3658 .dac_nids = alc880_dac_nids, 3659 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 3660 .channel_mode = alc880_threestack_modes, 3661 .need_dac_fix = 1, 3662 .input_mux = &alc880_capture_source, 3663 }, 3664 [ALC880_3ST_DIG] = { 3665 .mixers = { alc880_three_stack_mixer }, 3666 .init_verbs = { alc880_volume_init_verbs, 3667 alc880_pin_3stack_init_verbs }, 3668 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3669 .dac_nids = alc880_dac_nids, 3670 .dig_out_nid = ALC880_DIGOUT_NID, 3671 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 3672 .channel_mode = alc880_threestack_modes, 3673 .need_dac_fix = 1, 3674 .input_mux = &alc880_capture_source, 3675 }, 3676 [ALC880_TCL_S700] = { 3677 .mixers = { alc880_tcl_s700_mixer }, 3678 .init_verbs = { alc880_volume_init_verbs, 3679 alc880_pin_tcl_S700_init_verbs, 3680 alc880_gpio2_init_verbs }, 3681 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3682 .dac_nids = alc880_dac_nids, 3683 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */ 3684 .num_adc_nids = 1, /* single ADC */ 3685 .hp_nid = 0x03, 3686 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 3687 .channel_mode = alc880_2_jack_modes, 3688 .input_mux = &alc880_capture_source, 3689 }, 3690 [ALC880_5ST] = { 3691 .mixers = { alc880_three_stack_mixer, 3692 alc880_five_stack_mixer}, 3693 .init_verbs = { alc880_volume_init_verbs, 3694 alc880_pin_5stack_init_verbs }, 3695 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3696 .dac_nids = alc880_dac_nids, 3697 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes), 3698 .channel_mode = alc880_fivestack_modes, 3699 .input_mux = &alc880_capture_source, 3700 }, 3701 [ALC880_5ST_DIG] = { 3702 .mixers = { alc880_three_stack_mixer, 3703 alc880_five_stack_mixer }, 3704 .init_verbs = { alc880_volume_init_verbs, 3705 alc880_pin_5stack_init_verbs }, 3706 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3707 .dac_nids = alc880_dac_nids, 3708 .dig_out_nid = ALC880_DIGOUT_NID, 3709 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes), 3710 .channel_mode = alc880_fivestack_modes, 3711 .input_mux = &alc880_capture_source, 3712 }, 3713 [ALC880_6ST] = { 3714 .mixers = { alc880_six_stack_mixer }, 3715 .init_verbs = { alc880_volume_init_verbs, 3716 alc880_pin_6stack_init_verbs }, 3717 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids), 3718 .dac_nids = alc880_6st_dac_nids, 3719 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes), 3720 .channel_mode = alc880_sixstack_modes, 3721 .input_mux = &alc880_6stack_capture_source, 3722 }, 3723 [ALC880_6ST_DIG] = { 3724 .mixers = { alc880_six_stack_mixer }, 3725 .init_verbs = { alc880_volume_init_verbs, 3726 alc880_pin_6stack_init_verbs }, 3727 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids), 3728 .dac_nids = alc880_6st_dac_nids, 3729 .dig_out_nid = ALC880_DIGOUT_NID, 3730 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes), 3731 .channel_mode = alc880_sixstack_modes, 3732 .input_mux = &alc880_6stack_capture_source, 3733 }, 3734 [ALC880_W810] = { 3735 .mixers = { alc880_w810_base_mixer }, 3736 .init_verbs = { alc880_volume_init_verbs, 3737 alc880_pin_w810_init_verbs, 3738 alc880_gpio2_init_verbs }, 3739 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids), 3740 .dac_nids = alc880_w810_dac_nids, 3741 .dig_out_nid = ALC880_DIGOUT_NID, 3742 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes), 3743 .channel_mode = alc880_w810_modes, 3744 .input_mux = &alc880_capture_source, 3745 }, 3746 [ALC880_Z71V] = { 3747 .mixers = { alc880_z71v_mixer }, 3748 .init_verbs = { alc880_volume_init_verbs, 3749 alc880_pin_z71v_init_verbs }, 3750 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids), 3751 .dac_nids = alc880_z71v_dac_nids, 3752 .dig_out_nid = ALC880_DIGOUT_NID, 3753 .hp_nid = 0x03, 3754 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 3755 .channel_mode = alc880_2_jack_modes, 3756 .input_mux = &alc880_capture_source, 3757 }, 3758 [ALC880_F1734] = { 3759 .mixers = { alc880_f1734_mixer }, 3760 .init_verbs = { alc880_volume_init_verbs, 3761 alc880_pin_f1734_init_verbs }, 3762 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids), 3763 .dac_nids = alc880_f1734_dac_nids, 3764 .hp_nid = 0x02, 3765 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 3766 .channel_mode = alc880_2_jack_modes, 3767 .input_mux = &alc880_f1734_capture_source, 3768 .unsol_event = alc880_uniwill_p53_unsol_event, 3769 .init_hook = alc880_uniwill_p53_hp_automute, 3770 }, 3771 [ALC880_ASUS] = { 3772 .mixers = { alc880_asus_mixer }, 3773 .init_verbs = { alc880_volume_init_verbs, 3774 alc880_pin_asus_init_verbs, 3775 alc880_gpio1_init_verbs }, 3776 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3777 .dac_nids = alc880_asus_dac_nids, 3778 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 3779 .channel_mode = alc880_asus_modes, 3780 .need_dac_fix = 1, 3781 .input_mux = &alc880_capture_source, 3782 }, 3783 [ALC880_ASUS_DIG] = { 3784 .mixers = { alc880_asus_mixer }, 3785 .init_verbs = { alc880_volume_init_verbs, 3786 alc880_pin_asus_init_verbs, 3787 alc880_gpio1_init_verbs }, 3788 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3789 .dac_nids = alc880_asus_dac_nids, 3790 .dig_out_nid = ALC880_DIGOUT_NID, 3791 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 3792 .channel_mode = alc880_asus_modes, 3793 .need_dac_fix = 1, 3794 .input_mux = &alc880_capture_source, 3795 }, 3796 [ALC880_ASUS_DIG2] = { 3797 .mixers = { alc880_asus_mixer }, 3798 .init_verbs = { alc880_volume_init_verbs, 3799 alc880_pin_asus_init_verbs, 3800 alc880_gpio2_init_verbs }, /* use GPIO2 */ 3801 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3802 .dac_nids = alc880_asus_dac_nids, 3803 .dig_out_nid = ALC880_DIGOUT_NID, 3804 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 3805 .channel_mode = alc880_asus_modes, 3806 .need_dac_fix = 1, 3807 .input_mux = &alc880_capture_source, 3808 }, 3809 [ALC880_ASUS_W1V] = { 3810 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer }, 3811 .init_verbs = { alc880_volume_init_verbs, 3812 alc880_pin_asus_init_verbs, 3813 alc880_gpio1_init_verbs }, 3814 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3815 .dac_nids = alc880_asus_dac_nids, 3816 .dig_out_nid = ALC880_DIGOUT_NID, 3817 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 3818 .channel_mode = alc880_asus_modes, 3819 .need_dac_fix = 1, 3820 .input_mux = &alc880_capture_source, 3821 }, 3822 [ALC880_UNIWILL_DIG] = { 3823 .mixers = { alc880_asus_mixer }, 3824 .init_verbs = { alc880_volume_init_verbs, 3825 alc880_pin_asus_init_verbs }, 3826 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3827 .dac_nids = alc880_asus_dac_nids, 3828 .dig_out_nid = ALC880_DIGOUT_NID, 3829 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 3830 .channel_mode = alc880_asus_modes, 3831 .need_dac_fix = 1, 3832 .input_mux = &alc880_capture_source, 3833 }, 3834 [ALC880_UNIWILL] = { 3835 .mixers = { alc880_uniwill_mixer }, 3836 .init_verbs = { alc880_volume_init_verbs, 3837 alc880_uniwill_init_verbs }, 3838 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3839 .dac_nids = alc880_asus_dac_nids, 3840 .dig_out_nid = ALC880_DIGOUT_NID, 3841 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 3842 .channel_mode = alc880_threestack_modes, 3843 .need_dac_fix = 1, 3844 .input_mux = &alc880_capture_source, 3845 .unsol_event = alc880_uniwill_unsol_event, 3846 .init_hook = alc880_uniwill_automute, 3847 }, 3848 [ALC880_UNIWILL_P53] = { 3849 .mixers = { alc880_uniwill_p53_mixer }, 3850 .init_verbs = { alc880_volume_init_verbs, 3851 alc880_uniwill_p53_init_verbs }, 3852 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3853 .dac_nids = alc880_asus_dac_nids, 3854 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes), 3855 .channel_mode = alc880_threestack_modes, 3856 .input_mux = &alc880_capture_source, 3857 .unsol_event = alc880_uniwill_p53_unsol_event, 3858 .init_hook = alc880_uniwill_p53_hp_automute, 3859 }, 3860 [ALC880_FUJITSU] = { 3861 .mixers = { alc880_fujitsu_mixer }, 3862 .init_verbs = { alc880_volume_init_verbs, 3863 alc880_uniwill_p53_init_verbs, 3864 alc880_beep_init_verbs }, 3865 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3866 .dac_nids = alc880_dac_nids, 3867 .dig_out_nid = ALC880_DIGOUT_NID, 3868 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 3869 .channel_mode = alc880_2_jack_modes, 3870 .input_mux = &alc880_capture_source, 3871 .unsol_event = alc880_uniwill_p53_unsol_event, 3872 .init_hook = alc880_uniwill_p53_hp_automute, 3873 }, 3874 [ALC880_CLEVO] = { 3875 .mixers = { alc880_three_stack_mixer }, 3876 .init_verbs = { alc880_volume_init_verbs, 3877 alc880_pin_clevo_init_verbs }, 3878 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3879 .dac_nids = alc880_dac_nids, 3880 .hp_nid = 0x03, 3881 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 3882 .channel_mode = alc880_threestack_modes, 3883 .need_dac_fix = 1, 3884 .input_mux = &alc880_capture_source, 3885 }, 3886 [ALC880_LG] = { 3887 .mixers = { alc880_lg_mixer }, 3888 .init_verbs = { alc880_volume_init_verbs, 3889 alc880_lg_init_verbs }, 3890 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids), 3891 .dac_nids = alc880_lg_dac_nids, 3892 .dig_out_nid = ALC880_DIGOUT_NID, 3893 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes), 3894 .channel_mode = alc880_lg_ch_modes, 3895 .need_dac_fix = 1, 3896 .input_mux = &alc880_lg_capture_source, 3897 .unsol_event = alc880_lg_unsol_event, 3898 .init_hook = alc880_lg_automute, 3899#ifdef CONFIG_SND_HDA_POWER_SAVE 3900 .loopbacks = alc880_lg_loopbacks, 3901#endif 3902 }, 3903 [ALC880_LG_LW] = { 3904 .mixers = { alc880_lg_lw_mixer }, 3905 .init_verbs = { alc880_volume_init_verbs, 3906 alc880_lg_lw_init_verbs }, 3907 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3908 .dac_nids = alc880_dac_nids, 3909 .dig_out_nid = ALC880_DIGOUT_NID, 3910 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes), 3911 .channel_mode = alc880_lg_lw_modes, 3912 .input_mux = &alc880_lg_lw_capture_source, 3913 .unsol_event = alc880_lg_lw_unsol_event, 3914 .init_hook = alc880_lg_lw_automute, 3915 }, 3916 [ALC880_MEDION_RIM] = { 3917 .mixers = { alc880_medion_rim_mixer }, 3918 .init_verbs = { alc880_volume_init_verbs, 3919 alc880_medion_rim_init_verbs, 3920 alc_gpio2_init_verbs }, 3921 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3922 .dac_nids = alc880_dac_nids, 3923 .dig_out_nid = ALC880_DIGOUT_NID, 3924 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 3925 .channel_mode = alc880_2_jack_modes, 3926 .input_mux = &alc880_medion_rim_capture_source, 3927 .unsol_event = alc880_medion_rim_unsol_event, 3928 .init_hook = alc880_medion_rim_automute, 3929 }, 3930#ifdef CONFIG_SND_DEBUG 3931 [ALC880_TEST] = { 3932 .mixers = { alc880_test_mixer }, 3933 .init_verbs = { alc880_test_init_verbs }, 3934 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids), 3935 .dac_nids = alc880_test_dac_nids, 3936 .dig_out_nid = ALC880_DIGOUT_NID, 3937 .num_channel_mode = ARRAY_SIZE(alc880_test_modes), 3938 .channel_mode = alc880_test_modes, 3939 .input_mux = &alc880_test_capture_source, 3940 }, 3941#endif 3942}; 3943 3944/* 3945 * Automatic parse of I/O pins from the BIOS configuration 3946 */ 3947 3948enum { 3949 ALC_CTL_WIDGET_VOL, 3950 ALC_CTL_WIDGET_MUTE, 3951 ALC_CTL_BIND_MUTE, 3952}; 3953static struct snd_kcontrol_new alc880_control_templates[] = { 3954 HDA_CODEC_VOLUME(NULL, 0, 0, 0), 3955 HDA_CODEC_MUTE(NULL, 0, 0, 0), 3956 HDA_BIND_MUTE(NULL, 0, 0, 0), 3957}; 3958 3959/* add dynamic controls */ 3960static int add_control(struct alc_spec *spec, int type, const char *name, 3961 unsigned long val) 3962{ 3963 struct snd_kcontrol_new *knew; 3964 3965 snd_array_init(&spec->kctls, sizeof(*knew), 32); 3966 knew = snd_array_new(&spec->kctls); 3967 if (!knew) 3968 return -ENOMEM; 3969 *knew = alc880_control_templates[type]; 3970 knew->name = kstrdup(name, GFP_KERNEL); 3971 if (!knew->name) 3972 return -ENOMEM; 3973 knew->private_value = val; 3974 return 0; 3975} 3976 3977#define alc880_is_fixed_pin(nid) ((nid) >= 0x14 && (nid) <= 0x17) 3978#define alc880_fixed_pin_idx(nid) ((nid) - 0x14) 3979#define alc880_is_multi_pin(nid) ((nid) >= 0x18) 3980#define alc880_multi_pin_idx(nid) ((nid) - 0x18) 3981#define alc880_is_input_pin(nid) ((nid) >= 0x18) 3982#define alc880_input_pin_idx(nid) ((nid) - 0x18) 3983#define alc880_idx_to_dac(nid) ((nid) + 0x02) 3984#define alc880_dac_to_idx(nid) ((nid) - 0x02) 3985#define alc880_idx_to_mixer(nid) ((nid) + 0x0c) 3986#define alc880_idx_to_selector(nid) ((nid) + 0x10) 3987#define ALC880_PIN_CD_NID 0x1c 3988 3989/* fill in the dac_nids table from the parsed pin configuration */ 3990static int alc880_auto_fill_dac_nids(struct alc_spec *spec, 3991 const struct auto_pin_cfg *cfg) 3992{ 3993 hda_nid_t nid; 3994 int assigned[4]; 3995 int i, j; 3996 3997 memset(assigned, 0, sizeof(assigned)); 3998 spec->multiout.dac_nids = spec->private_dac_nids; 3999 4000 /* check the pins hardwired to audio widget */ 4001 for (i = 0; i < cfg->line_outs; i++) { 4002 nid = cfg->line_out_pins[i]; 4003 if (alc880_is_fixed_pin(nid)) { 4004 int idx = alc880_fixed_pin_idx(nid); 4005 spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx); 4006 assigned[idx] = 1; 4007 } 4008 } 4009 /* left pins can be connect to any audio widget */ 4010 for (i = 0; i < cfg->line_outs; i++) { 4011 nid = cfg->line_out_pins[i]; 4012 if (alc880_is_fixed_pin(nid)) 4013 continue; 4014 /* search for an empty channel */ 4015 for (j = 0; j < cfg->line_outs; j++) { 4016 if (!assigned[j]) { 4017 spec->multiout.dac_nids[i] = 4018 alc880_idx_to_dac(j); 4019 assigned[j] = 1; 4020 break; 4021 } 4022 } 4023 } 4024 spec->multiout.num_dacs = cfg->line_outs; 4025 return 0; 4026} 4027 4028/* add playback controls from the parsed DAC table */ 4029static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec, 4030 const struct auto_pin_cfg *cfg) 4031{ 4032 char name[32]; 4033 static const char *chname[4] = { 4034 "Front", "Surround", NULL /*CLFE*/, "Side" 4035 }; 4036 hda_nid_t nid; 4037 int i, err; 4038 4039 for (i = 0; i < cfg->line_outs; i++) { 4040 if (!spec->multiout.dac_nids[i]) 4041 continue; 4042 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i])); 4043 if (i == 2) { 4044 /* Center/LFE */ 4045 err = add_control(spec, ALC_CTL_WIDGET_VOL, 4046 "Center Playback Volume", 4047 HDA_COMPOSE_AMP_VAL(nid, 1, 0, 4048 HDA_OUTPUT)); 4049 if (err < 0) 4050 return err; 4051 err = add_control(spec, ALC_CTL_WIDGET_VOL, 4052 "LFE Playback Volume", 4053 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 4054 HDA_OUTPUT)); 4055 if (err < 0) 4056 return err; 4057 err = add_control(spec, ALC_CTL_BIND_MUTE, 4058 "Center Playback Switch", 4059 HDA_COMPOSE_AMP_VAL(nid, 1, 2, 4060 HDA_INPUT)); 4061 if (err < 0) 4062 return err; 4063 err = add_control(spec, ALC_CTL_BIND_MUTE, 4064 "LFE Playback Switch", 4065 HDA_COMPOSE_AMP_VAL(nid, 2, 2, 4066 HDA_INPUT)); 4067 if (err < 0) 4068 return err; 4069 } else { 4070 sprintf(name, "%s Playback Volume", chname[i]); 4071 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 4072 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 4073 HDA_OUTPUT)); 4074 if (err < 0) 4075 return err; 4076 sprintf(name, "%s Playback Switch", chname[i]); 4077 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 4078 HDA_COMPOSE_AMP_VAL(nid, 3, 2, 4079 HDA_INPUT)); 4080 if (err < 0) 4081 return err; 4082 } 4083 } 4084 return 0; 4085} 4086 4087/* add playback controls for speaker and HP outputs */ 4088static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin, 4089 const char *pfx) 4090{ 4091 hda_nid_t nid; 4092 int err; 4093 char name[32]; 4094 4095 if (!pin) 4096 return 0; 4097 4098 if (alc880_is_fixed_pin(pin)) { 4099 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin)); 4100 /* specify the DAC as the extra output */ 4101 if (!spec->multiout.hp_nid) 4102 spec->multiout.hp_nid = nid; 4103 else 4104 spec->multiout.extra_out_nid[0] = nid; 4105 /* control HP volume/switch on the output mixer amp */ 4106 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin)); 4107 sprintf(name, "%s Playback Volume", pfx); 4108 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 4109 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 4110 if (err < 0) 4111 return err; 4112 sprintf(name, "%s Playback Switch", pfx); 4113 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 4114 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT)); 4115 if (err < 0) 4116 return err; 4117 } else if (alc880_is_multi_pin(pin)) { 4118 /* set manual connection */ 4119 /* we have only a switch on HP-out PIN */ 4120 sprintf(name, "%s Playback Switch", pfx); 4121 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 4122 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 4123 if (err < 0) 4124 return err; 4125 } 4126 return 0; 4127} 4128 4129/* create input playback/capture controls for the given pin */ 4130static int new_analog_input(struct alc_spec *spec, hda_nid_t pin, 4131 const char *ctlname, 4132 int idx, hda_nid_t mix_nid) 4133{ 4134 char name[32]; 4135 int err; 4136 4137 sprintf(name, "%s Playback Volume", ctlname); 4138 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 4139 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); 4140 if (err < 0) 4141 return err; 4142 sprintf(name, "%s Playback Switch", ctlname); 4143 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 4144 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); 4145 if (err < 0) 4146 return err; 4147 return 0; 4148} 4149 4150/* create playback/capture controls for input pins */ 4151static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec, 4152 const struct auto_pin_cfg *cfg) 4153{ 4154 struct hda_input_mux *imux = &spec->private_imux[0]; 4155 int i, err, idx; 4156 4157 for (i = 0; i < AUTO_PIN_LAST; i++) { 4158 if (alc880_is_input_pin(cfg->input_pins[i])) { 4159 idx = alc880_input_pin_idx(cfg->input_pins[i]); 4160 err = new_analog_input(spec, cfg->input_pins[i], 4161 auto_pin_cfg_labels[i], 4162 idx, 0x0b); 4163 if (err < 0) 4164 return err; 4165 imux->items[imux->num_items].label = 4166 auto_pin_cfg_labels[i]; 4167 imux->items[imux->num_items].index = 4168 alc880_input_pin_idx(cfg->input_pins[i]); 4169 imux->num_items++; 4170 } 4171 } 4172 return 0; 4173} 4174 4175static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid, 4176 unsigned int pin_type) 4177{ 4178 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4179 pin_type); 4180 /* unmute pin */ 4181 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, 4182 AMP_OUT_UNMUTE); 4183} 4184 4185static void alc880_auto_set_output_and_unmute(struct hda_codec *codec, 4186 hda_nid_t nid, int pin_type, 4187 int dac_idx) 4188{ 4189 alc_set_pin_output(codec, nid, pin_type); 4190 /* need the manual connection? */ 4191 if (alc880_is_multi_pin(nid)) { 4192 struct alc_spec *spec = codec->spec; 4193 int idx = alc880_multi_pin_idx(nid); 4194 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0, 4195 AC_VERB_SET_CONNECT_SEL, 4196 alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx])); 4197 } 4198} 4199 4200static int get_pin_type(int line_out_type) 4201{ 4202 if (line_out_type == AUTO_PIN_HP_OUT) 4203 return PIN_HP; 4204 else 4205 return PIN_OUT; 4206} 4207 4208static void alc880_auto_init_multi_out(struct hda_codec *codec) 4209{ 4210 struct alc_spec *spec = codec->spec; 4211 int i; 4212 4213 alc_subsystem_id(codec, 0x15, 0x1b, 0x14); 4214 for (i = 0; i < spec->autocfg.line_outs; i++) { 4215 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 4216 int pin_type = get_pin_type(spec->autocfg.line_out_type); 4217 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i); 4218 } 4219} 4220 4221static void alc880_auto_init_extra_out(struct hda_codec *codec) 4222{ 4223 struct alc_spec *spec = codec->spec; 4224 hda_nid_t pin; 4225 4226 pin = spec->autocfg.speaker_pins[0]; 4227 if (pin) /* connect to front */ 4228 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 4229 pin = spec->autocfg.hp_pins[0]; 4230 if (pin) /* connect to front */ 4231 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 4232} 4233 4234static void alc880_auto_init_analog_input(struct hda_codec *codec) 4235{ 4236 struct alc_spec *spec = codec->spec; 4237 int i; 4238 4239 for (i = 0; i < AUTO_PIN_LAST; i++) { 4240 hda_nid_t nid = spec->autocfg.input_pins[i]; 4241 if (alc880_is_input_pin(nid)) { 4242 snd_hda_codec_write(codec, nid, 0, 4243 AC_VERB_SET_PIN_WIDGET_CONTROL, 4244 i <= AUTO_PIN_FRONT_MIC ? 4245 PIN_VREF80 : PIN_IN); 4246 if (nid != ALC880_PIN_CD_NID) 4247 snd_hda_codec_write(codec, nid, 0, 4248 AC_VERB_SET_AMP_GAIN_MUTE, 4249 AMP_OUT_MUTE); 4250 } 4251 } 4252} 4253 4254/* parse the BIOS configuration and set up the alc_spec */ 4255/* return 1 if successful, 0 if the proper config is not found, 4256 * or a negative error code 4257 */ 4258static int alc880_parse_auto_config(struct hda_codec *codec) 4259{ 4260 struct alc_spec *spec = codec->spec; 4261 int err; 4262 static hda_nid_t alc880_ignore[] = { 0x1d, 0 }; 4263 4264 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 4265 alc880_ignore); 4266 if (err < 0) 4267 return err; 4268 if (!spec->autocfg.line_outs) 4269 return 0; /* can't find valid BIOS pin config */ 4270 4271 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg); 4272 if (err < 0) 4273 return err; 4274 err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg); 4275 if (err < 0) 4276 return err; 4277 err = alc880_auto_create_extra_out(spec, 4278 spec->autocfg.speaker_pins[0], 4279 "Speaker"); 4280 if (err < 0) 4281 return err; 4282 err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0], 4283 "Headphone"); 4284 if (err < 0) 4285 return err; 4286 err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg); 4287 if (err < 0) 4288 return err; 4289 4290 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 4291 4292 if (spec->autocfg.dig_out_pin) 4293 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID; 4294 if (spec->autocfg.dig_in_pin) 4295 spec->dig_in_nid = ALC880_DIGIN_NID; 4296 4297 if (spec->kctls.list) 4298 add_mixer(spec, spec->kctls.list); 4299 4300 add_verb(spec, alc880_volume_init_verbs); 4301 4302 spec->num_mux_defs = 1; 4303 spec->input_mux = &spec->private_imux[0]; 4304 4305 store_pin_configs(codec); 4306 return 1; 4307} 4308 4309/* additional initialization for auto-configuration model */ 4310static void alc880_auto_init(struct hda_codec *codec) 4311{ 4312 struct alc_spec *spec = codec->spec; 4313 alc880_auto_init_multi_out(codec); 4314 alc880_auto_init_extra_out(codec); 4315 alc880_auto_init_analog_input(codec); 4316 if (spec->unsol_event) 4317 alc_inithook(codec); 4318} 4319 4320static void set_capture_mixer(struct alc_spec *spec) 4321{ 4322 static struct snd_kcontrol_new *caps[3] = { 4323 alc_capture_mixer1, 4324 alc_capture_mixer2, 4325 alc_capture_mixer3, 4326 }; 4327 if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) 4328 spec->cap_mixer = caps[spec->num_adc_nids - 1]; 4329} 4330 4331#define set_beep_amp(spec, nid, idx, dir) \ 4332 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir)) 4333 4334/* 4335 * OK, here we have finally the patch for ALC880 4336 */ 4337 4338static int patch_alc880(struct hda_codec *codec) 4339{ 4340 struct alc_spec *spec; 4341 int board_config; 4342 int err; 4343 4344 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 4345 if (spec == NULL) 4346 return -ENOMEM; 4347 4348 codec->spec = spec; 4349 4350 board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST, 4351 alc880_models, 4352 alc880_cfg_tbl); 4353 if (board_config < 0) { 4354 printk(KERN_INFO "hda_codec: Unknown model for ALC880, " 4355 "trying auto-probe from BIOS...\n"); 4356 board_config = ALC880_AUTO; 4357 } 4358 4359 if (board_config == ALC880_AUTO) { 4360 /* automatic parse from the BIOS config */ 4361 err = alc880_parse_auto_config(codec); 4362 if (err < 0) { 4363 alc_free(codec); 4364 return err; 4365 } else if (!err) { 4366 printk(KERN_INFO 4367 "hda_codec: Cannot set up configuration " 4368 "from BIOS. Using 3-stack mode...\n"); 4369 board_config = ALC880_3ST; 4370 } 4371 } 4372 4373 err = snd_hda_attach_beep_device(codec, 0x1); 4374 if (err < 0) { 4375 alc_free(codec); 4376 return err; 4377 } 4378 4379 if (board_config != ALC880_AUTO) 4380 setup_preset(spec, &alc880_presets[board_config]); 4381 4382 spec->stream_name_analog = "ALC880 Analog"; 4383 spec->stream_analog_playback = &alc880_pcm_analog_playback; 4384 spec->stream_analog_capture = &alc880_pcm_analog_capture; 4385 spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture; 4386 4387 spec->stream_name_digital = "ALC880 Digital"; 4388 spec->stream_digital_playback = &alc880_pcm_digital_playback; 4389 spec->stream_digital_capture = &alc880_pcm_digital_capture; 4390 4391 if (!spec->adc_nids && spec->input_mux) { 4392 /* check whether NID 0x07 is valid */ 4393 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]); 4394 /* get type */ 4395 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 4396 if (wcap != AC_WID_AUD_IN) { 4397 spec->adc_nids = alc880_adc_nids_alt; 4398 spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt); 4399 } else { 4400 spec->adc_nids = alc880_adc_nids; 4401 spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids); 4402 } 4403 } 4404 set_capture_mixer(spec); 4405 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 4406 4407 spec->vmaster_nid = 0x0c; 4408 4409 codec->patch_ops = alc_patch_ops; 4410 if (board_config == ALC880_AUTO) 4411 spec->init_hook = alc880_auto_init; 4412#ifdef CONFIG_SND_HDA_POWER_SAVE 4413 if (!spec->loopback.amplist) 4414 spec->loopback.amplist = alc880_loopbacks; 4415#endif 4416 codec->proc_widget_hook = print_realtek_coef; 4417 4418 return 0; 4419} 4420 4421 4422/* 4423 * ALC260 support 4424 */ 4425 4426static hda_nid_t alc260_dac_nids[1] = { 4427 /* front */ 4428 0x02, 4429}; 4430 4431static hda_nid_t alc260_adc_nids[1] = { 4432 /* ADC0 */ 4433 0x04, 4434}; 4435 4436static hda_nid_t alc260_adc_nids_alt[1] = { 4437 /* ADC1 */ 4438 0x05, 4439}; 4440 4441/* NIDs used when simultaneous access to both ADCs makes sense. Note that 4442 * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC. 4443 */ 4444static hda_nid_t alc260_dual_adc_nids[2] = { 4445 /* ADC0, ADC1 */ 4446 0x04, 0x05 4447}; 4448 4449#define ALC260_DIGOUT_NID 0x03 4450#define ALC260_DIGIN_NID 0x06 4451 4452static struct hda_input_mux alc260_capture_source = { 4453 .num_items = 4, 4454 .items = { 4455 { "Mic", 0x0 }, 4456 { "Front Mic", 0x1 }, 4457 { "Line", 0x2 }, 4458 { "CD", 0x4 }, 4459 }, 4460}; 4461 4462/* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack, 4463 * headphone jack and the internal CD lines since these are the only pins at 4464 * which audio can appear. For flexibility, also allow the option of 4465 * recording the mixer output on the second ADC (ADC0 doesn't have a 4466 * connection to the mixer output). 4467 */ 4468static struct hda_input_mux alc260_fujitsu_capture_sources[2] = { 4469 { 4470 .num_items = 3, 4471 .items = { 4472 { "Mic/Line", 0x0 }, 4473 { "CD", 0x4 }, 4474 { "Headphone", 0x2 }, 4475 }, 4476 }, 4477 { 4478 .num_items = 4, 4479 .items = { 4480 { "Mic/Line", 0x0 }, 4481 { "CD", 0x4 }, 4482 { "Headphone", 0x2 }, 4483 { "Mixer", 0x5 }, 4484 }, 4485 }, 4486 4487}; 4488 4489/* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to 4490 * the Fujitsu S702x, but jacks are marked differently. 4491 */ 4492static struct hda_input_mux alc260_acer_capture_sources[2] = { 4493 { 4494 .num_items = 4, 4495 .items = { 4496 { "Mic", 0x0 }, 4497 { "Line", 0x2 }, 4498 { "CD", 0x4 }, 4499 { "Headphone", 0x5 }, 4500 }, 4501 }, 4502 { 4503 .num_items = 5, 4504 .items = { 4505 { "Mic", 0x0 }, 4506 { "Line", 0x2 }, 4507 { "CD", 0x4 }, 4508 { "Headphone", 0x6 }, 4509 { "Mixer", 0x5 }, 4510 }, 4511 }, 4512}; 4513/* 4514 * This is just place-holder, so there's something for alc_build_pcms to look 4515 * at when it calculates the maximum number of channels. ALC260 has no mixer 4516 * element which allows changing the channel mode, so the verb list is 4517 * never used. 4518 */ 4519static struct hda_channel_mode alc260_modes[1] = { 4520 { 2, NULL }, 4521}; 4522 4523 4524/* Mixer combinations 4525 * 4526 * basic: base_output + input + pc_beep + capture 4527 * HP: base_output + input + capture_alt 4528 * HP_3013: hp_3013 + input + capture 4529 * fujitsu: fujitsu + capture 4530 * acer: acer + capture 4531 */ 4532 4533static struct snd_kcontrol_new alc260_base_output_mixer[] = { 4534 HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4535 HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT), 4536 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT), 4537 HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT), 4538 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT), 4539 HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT), 4540 { } /* end */ 4541}; 4542 4543static struct snd_kcontrol_new alc260_input_mixer[] = { 4544 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 4545 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 4546 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT), 4547 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT), 4548 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT), 4549 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT), 4550 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT), 4551 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT), 4552 { } /* end */ 4553}; 4554 4555/* update HP, line and mono out pins according to the master switch */ 4556static void alc260_hp_master_update(struct hda_codec *codec, 4557 hda_nid_t hp, hda_nid_t line, 4558 hda_nid_t mono) 4559{ 4560 struct alc_spec *spec = codec->spec; 4561 unsigned int val = spec->master_sw ? PIN_HP : 0; 4562 /* change HP and line-out pins */ 4563 snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4564 val); 4565 snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4566 val); 4567 /* mono (speaker) depending on the HP jack sense */ 4568 val = (val && !spec->jack_present) ? PIN_OUT : 0; 4569 snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4570 val); 4571} 4572 4573static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol, 4574 struct snd_ctl_elem_value *ucontrol) 4575{ 4576 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 4577 struct alc_spec *spec = codec->spec; 4578 *ucontrol->value.integer.value = spec->master_sw; 4579 return 0; 4580} 4581 4582static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol, 4583 struct snd_ctl_elem_value *ucontrol) 4584{ 4585 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 4586 struct alc_spec *spec = codec->spec; 4587 int val = !!*ucontrol->value.integer.value; 4588 hda_nid_t hp, line, mono; 4589 4590 if (val == spec->master_sw) 4591 return 0; 4592 spec->master_sw = val; 4593 hp = (kcontrol->private_value >> 16) & 0xff; 4594 line = (kcontrol->private_value >> 8) & 0xff; 4595 mono = kcontrol->private_value & 0xff; 4596 alc260_hp_master_update(codec, hp, line, mono); 4597 return 1; 4598} 4599 4600static struct snd_kcontrol_new alc260_hp_output_mixer[] = { 4601 { 4602 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4603 .name = "Master Playback Switch", 4604 .info = snd_ctl_boolean_mono_info, 4605 .get = alc260_hp_master_sw_get, 4606 .put = alc260_hp_master_sw_put, 4607 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11 4608 }, 4609 HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4610 HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT), 4611 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT), 4612 HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT), 4613 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, 4614 HDA_OUTPUT), 4615 HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT), 4616 { } /* end */ 4617}; 4618 4619static struct hda_verb alc260_hp_unsol_verbs[] = { 4620 {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 4621 {}, 4622}; 4623 4624static void alc260_hp_automute(struct hda_codec *codec) 4625{ 4626 struct alc_spec *spec = codec->spec; 4627 unsigned int present; 4628 4629 present = snd_hda_codec_read(codec, 0x10, 0, 4630 AC_VERB_GET_PIN_SENSE, 0); 4631 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0; 4632 alc260_hp_master_update(codec, 0x0f, 0x10, 0x11); 4633} 4634 4635static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res) 4636{ 4637 if ((res >> 26) == ALC880_HP_EVENT) 4638 alc260_hp_automute(codec); 4639} 4640 4641static struct snd_kcontrol_new alc260_hp_3013_mixer[] = { 4642 { 4643 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4644 .name = "Master Playback Switch", 4645 .info = snd_ctl_boolean_mono_info, 4646 .get = alc260_hp_master_sw_get, 4647 .put = alc260_hp_master_sw_put, 4648 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11 4649 }, 4650 HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT), 4651 HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT), 4652 HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT), 4653 HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT), 4654 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4655 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 4656 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT), 4657 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT), 4658 { } /* end */ 4659}; 4660 4661static struct hda_bind_ctls alc260_dc7600_bind_master_vol = { 4662 .ops = &snd_hda_bind_vol, 4663 .values = { 4664 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT), 4665 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT), 4666 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT), 4667 0 4668 }, 4669}; 4670 4671static struct hda_bind_ctls alc260_dc7600_bind_switch = { 4672 .ops = &snd_hda_bind_sw, 4673 .values = { 4674 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT), 4675 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT), 4676 0 4677 }, 4678}; 4679 4680static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = { 4681 HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol), 4682 HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch), 4683 HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT), 4684 HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT), 4685 { } /* end */ 4686}; 4687 4688static struct hda_verb alc260_hp_3013_unsol_verbs[] = { 4689 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 4690 {}, 4691}; 4692 4693static void alc260_hp_3013_automute(struct hda_codec *codec) 4694{ 4695 struct alc_spec *spec = codec->spec; 4696 unsigned int present; 4697 4698 present = snd_hda_codec_read(codec, 0x15, 0, 4699 AC_VERB_GET_PIN_SENSE, 0); 4700 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0; 4701 alc260_hp_master_update(codec, 0x15, 0x10, 0x11); 4702} 4703 4704static void alc260_hp_3013_unsol_event(struct hda_codec *codec, 4705 unsigned int res) 4706{ 4707 if ((res >> 26) == ALC880_HP_EVENT) 4708 alc260_hp_3013_automute(codec); 4709} 4710 4711static void alc260_hp_3012_automute(struct hda_codec *codec) 4712{ 4713 unsigned int present, bits; 4714 4715 present = snd_hda_codec_read(codec, 0x10, 0, 4716 AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE; 4717 4718 bits = present ? 0 : PIN_OUT; 4719 snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4720 bits); 4721 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4722 bits); 4723 snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4724 bits); 4725} 4726 4727static void alc260_hp_3012_unsol_event(struct hda_codec *codec, 4728 unsigned int res) 4729{ 4730 if ((res >> 26) == ALC880_HP_EVENT) 4731 alc260_hp_3012_automute(codec); 4732} 4733 4734/* Fujitsu S702x series laptops. ALC260 pin usage: Mic/Line jack = 0x12, 4735 * HP jack = 0x14, CD audio = 0x16, internal speaker = 0x10. 4736 */ 4737static struct snd_kcontrol_new alc260_fujitsu_mixer[] = { 4738 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4739 HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT), 4740 ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT), 4741 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 4742 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 4743 HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT), 4744 HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT), 4745 ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN), 4746 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT), 4747 HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT), 4748 { } /* end */ 4749}; 4750 4751/* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks. Note that current 4752 * versions of the ALC260 don't act on requests to enable mic bias from NID 4753 * 0x0f (used to drive the headphone jack in these laptops). The ALC260 4754 * datasheet doesn't mention this restriction. At this stage it's not clear 4755 * whether this behaviour is intentional or is a hardware bug in chip 4756 * revisions available in early 2006. Therefore for now allow the 4757 * "Headphone Jack Mode" control to span all choices, but if it turns out 4758 * that the lack of mic bias for this NID is intentional we could change the 4759 * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS. 4760 * 4761 * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006 4762 * don't appear to make the mic bias available from the "line" jack, even 4763 * though the NID used for this jack (0x14) can supply it. The theory is 4764 * that perhaps Acer have included blocking capacitors between the ALC260 4765 * and the output jack. If this turns out to be the case for all such 4766 * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT 4767 * to ALC_PIN_DIR_INOUT_NOMICBIAS. 4768 * 4769 * The C20x Tablet series have a mono internal speaker which is controlled 4770 * via the chip's Mono sum widget and pin complex, so include the necessary 4771 * controls for such models. On models without a "mono speaker" the control 4772 * won't do anything. 4773 */ 4774static struct snd_kcontrol_new alc260_acer_mixer[] = { 4775 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4776 HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT), 4777 ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT), 4778 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, 4779 HDA_OUTPUT), 4780 HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, 4781 HDA_INPUT), 4782 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 4783 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 4784 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT), 4785 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT), 4786 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN), 4787 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT), 4788 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT), 4789 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT), 4790 { } /* end */ 4791}; 4792 4793/* Packard bell V7900 ALC260 pin usage: HP = 0x0f, Mic jack = 0x12, 4794 * Line In jack = 0x14, CD audio = 0x16, pc beep = 0x17. 4795 */ 4796static struct snd_kcontrol_new alc260_will_mixer[] = { 4797 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4798 HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT), 4799 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT), 4800 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT), 4801 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN), 4802 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT), 4803 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT), 4804 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT), 4805 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 4806 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 4807 { } /* end */ 4808}; 4809 4810/* Replacer 672V ALC260 pin usage: Mic jack = 0x12, 4811 * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f. 4812 */ 4813static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = { 4814 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4815 HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT), 4816 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT), 4817 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT), 4818 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN), 4819 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT), 4820 HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT), 4821 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT), 4822 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT), 4823 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT), 4824 { } /* end */ 4825}; 4826 4827/* 4828 * initialization verbs 4829 */ 4830static struct hda_verb alc260_init_verbs[] = { 4831 /* Line In pin widget for input */ 4832 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 4833 /* CD pin widget for input */ 4834 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 4835 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 4836 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 4837 /* Mic2 (front panel) pin widget for input and vref at 80% */ 4838 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 4839 /* LINE-2 is used for line-out in rear */ 4840 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4841 /* select line-out */ 4842 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00}, 4843 /* LINE-OUT pin */ 4844 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4845 /* enable HP */ 4846 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 4847 /* enable Mono */ 4848 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4849 /* mute capture amp left and right */ 4850 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4851 /* set connection select to line in (default select for this ADC) */ 4852 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02}, 4853 /* mute capture amp left and right */ 4854 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4855 /* set connection select to line in (default select for this ADC) */ 4856 {0x05, AC_VERB_SET_CONNECT_SEL, 0x02}, 4857 /* set vol=0 Line-Out mixer amp left and right */ 4858 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4859 /* unmute pin widget amp left and right (no gain on this amp) */ 4860 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4861 /* set vol=0 HP mixer amp left and right */ 4862 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4863 /* unmute pin widget amp left and right (no gain on this amp) */ 4864 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4865 /* set vol=0 Mono mixer amp left and right */ 4866 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4867 /* unmute pin widget amp left and right (no gain on this amp) */ 4868 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4869 /* unmute LINE-2 out pin */ 4870 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4871 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & 4872 * Line In 2 = 0x03 4873 */ 4874 /* mute analog inputs */ 4875 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4876 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4877 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 4878 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 4879 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 4880 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */ 4881 /* mute Front out path */ 4882 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4883 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4884 /* mute Headphone out path */ 4885 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4886 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4887 /* mute Mono out path */ 4888 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4889 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4890 { } 4891}; 4892 4893#if 0 /* should be identical with alc260_init_verbs? */ 4894static struct hda_verb alc260_hp_init_verbs[] = { 4895 /* Headphone and output */ 4896 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 4897 /* mono output */ 4898 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 4899 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 4900 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 4901 /* Mic2 (front panel) pin widget for input and vref at 80% */ 4902 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 4903 /* Line In pin widget for input */ 4904 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 4905 /* Line-2 pin widget for output */ 4906 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 4907 /* CD pin widget for input */ 4908 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 4909 /* unmute amp left and right */ 4910 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000}, 4911 /* set connection select to line in (default select for this ADC) */ 4912 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02}, 4913 /* unmute Line-Out mixer amp left and right (volume = 0) */ 4914 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 4915 /* mute pin widget amp left and right (no gain on this amp) */ 4916 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 4917 /* unmute HP mixer amp left and right (volume = 0) */ 4918 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 4919 /* mute pin widget amp left and right (no gain on this amp) */ 4920 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 4921 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & 4922 * Line In 2 = 0x03 4923 */ 4924 /* mute analog inputs */ 4925 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4926 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4927 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 4928 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 4929 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 4930 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */ 4931 /* Unmute Front out path */ 4932 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4933 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4934 /* Unmute Headphone out path */ 4935 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4936 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4937 /* Unmute Mono out path */ 4938 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4939 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4940 { } 4941}; 4942#endif 4943 4944static struct hda_verb alc260_hp_3013_init_verbs[] = { 4945 /* Line out and output */ 4946 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 4947 /* mono output */ 4948 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 4949 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 4950 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 4951 /* Mic2 (front panel) pin widget for input and vref at 80% */ 4952 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 4953 /* Line In pin widget for input */ 4954 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 4955 /* Headphone pin widget for output */ 4956 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 4957 /* CD pin widget for input */ 4958 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 4959 /* unmute amp left and right */ 4960 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000}, 4961 /* set connection select to line in (default select for this ADC) */ 4962 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02}, 4963 /* unmute Line-Out mixer amp left and right (volume = 0) */ 4964 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 4965 /* mute pin widget amp left and right (no gain on this amp) */ 4966 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 4967 /* unmute HP mixer amp left and right (volume = 0) */ 4968 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 4969 /* mute pin widget amp left and right (no gain on this amp) */ 4970 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 4971 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & 4972 * Line In 2 = 0x03 4973 */ 4974 /* mute analog inputs */ 4975 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4976 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4977 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 4978 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 4979 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 4980 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */ 4981 /* Unmute Front out path */ 4982 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4983 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4984 /* Unmute Headphone out path */ 4985 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4986 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4987 /* Unmute Mono out path */ 4988 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4989 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4990 { } 4991}; 4992 4993/* Initialisation sequence for ALC260 as configured in Fujitsu S702x 4994 * laptops. ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD 4995 * audio = 0x16, internal speaker = 0x10. 4996 */ 4997static struct hda_verb alc260_fujitsu_init_verbs[] = { 4998 /* Disable all GPIOs */ 4999 {0x01, AC_VERB_SET_GPIO_MASK, 0}, 5000 /* Internal speaker is connected to headphone pin */ 5001 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 5002 /* Headphone/Line-out jack connects to Line1 pin; make it an output */ 5003 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5004 /* Mic/Line-in jack is connected to mic1 pin, so make it an input */ 5005 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 5006 /* Ensure all other unused pins are disabled and muted. */ 5007 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 5008 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5009 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 5010 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5011 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 5012 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5013 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 5014 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5015 5016 /* Disable digital (SPDIF) pins */ 5017 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0}, 5018 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0}, 5019 5020 /* Ensure Line1 pin widget takes its input from the OUT1 sum bus 5021 * when acting as an output. 5022 */ 5023 {0x0d, AC_VERB_SET_CONNECT_SEL, 0}, 5024 5025 /* Start with output sum widgets muted and their output gains at min */ 5026 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5027 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5028 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5029 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5030 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5031 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5032 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5033 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5034 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5035 5036 /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */ 5037 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5038 /* Unmute Line1 pin widget output buffer since it starts as an output. 5039 * If the pin mode is changed by the user the pin mode control will 5040 * take care of enabling the pin's input/output buffers as needed. 5041 * Therefore there's no need to enable the input buffer at this 5042 * stage. 5043 */ 5044 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5045 /* Unmute input buffer of pin widget used for Line-in (no equiv 5046 * mixer ctrl) 5047 */ 5048 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5049 5050 /* Mute capture amp left and right */ 5051 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5052 /* Set ADC connection select to match default mixer setting - line 5053 * in (on mic1 pin) 5054 */ 5055 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00}, 5056 5057 /* Do the same for the second ADC: mute capture input amp and 5058 * set ADC connection to line in (on mic1 pin) 5059 */ 5060 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5061 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00}, 5062 5063 /* Mute all inputs to mixer widget (even unconnected ones) */ 5064 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */ 5065 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */ 5066 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */ 5067 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */ 5068 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */ 5069 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */ 5070 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */ 5071 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */ 5072 5073 { } 5074}; 5075 5076/* Initialisation sequence for ALC260 as configured in Acer TravelMate and 5077 * similar laptops (adapted from Fujitsu init verbs). 5078 */ 5079static struct hda_verb alc260_acer_init_verbs[] = { 5080 /* On TravelMate laptops, GPIO 0 enables the internal speaker and 5081 * the headphone jack. Turn this on and rely on the standard mute 5082 * methods whenever the user wants to turn these outputs off. 5083 */ 5084 {0x01, AC_VERB_SET_GPIO_MASK, 0x01}, 5085 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, 5086 {0x01, AC_VERB_SET_GPIO_DATA, 0x01}, 5087 /* Internal speaker/Headphone jack is connected to Line-out pin */ 5088 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 5089 /* Internal microphone/Mic jack is connected to Mic1 pin */ 5090 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50}, 5091 /* Line In jack is connected to Line1 pin */ 5092 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 5093 /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */ 5094 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 5095 /* Ensure all other unused pins are disabled and muted. */ 5096 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 5097 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5098 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 5099 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5100 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 5101 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5102 /* Disable digital (SPDIF) pins */ 5103 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0}, 5104 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0}, 5105 5106 /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum 5107 * bus when acting as outputs. 5108 */ 5109 {0x0b, AC_VERB_SET_CONNECT_SEL, 0}, 5110 {0x0d, AC_VERB_SET_CONNECT_SEL, 0}, 5111 5112 /* Start with output sum widgets muted and their output gains at min */ 5113 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5114 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5115 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5116 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5117 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5118 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5119 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5120 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5121 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5122 5123 /* Unmute Line-out pin widget amp left and right 5124 * (no equiv mixer ctrl) 5125 */ 5126 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5127 /* Unmute mono pin widget amp output (no equiv mixer ctrl) */ 5128 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5129 /* Unmute Mic1 and Line1 pin widget input buffers since they start as 5130 * inputs. If the pin mode is changed by the user the pin mode control 5131 * will take care of enabling the pin's input/output buffers as needed. 5132 * Therefore there's no need to enable the input buffer at this 5133 * stage. 5134 */ 5135 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5136 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5137 5138 /* Mute capture amp left and right */ 5139 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5140 /* Set ADC connection select to match default mixer setting - mic 5141 * (on mic1 pin) 5142 */ 5143 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00}, 5144 5145 /* Do similar with the second ADC: mute capture input amp and 5146 * set ADC connection to mic to match ALSA's default state. 5147 */ 5148 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5149 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00}, 5150 5151 /* Mute all inputs to mixer widget (even unconnected ones) */ 5152 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */ 5153 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */ 5154 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */ 5155 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */ 5156 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */ 5157 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */ 5158 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */ 5159 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */ 5160 5161 { } 5162}; 5163 5164static struct hda_verb alc260_will_verbs[] = { 5165 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 5166 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00}, 5167 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00}, 5168 {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02}, 5169 {0x1a, AC_VERB_SET_COEF_INDEX, 0x07}, 5170 {0x1a, AC_VERB_SET_PROC_COEF, 0x3040}, 5171 {} 5172}; 5173 5174static struct hda_verb alc260_replacer_672v_verbs[] = { 5175 {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02}, 5176 {0x1a, AC_VERB_SET_COEF_INDEX, 0x07}, 5177 {0x1a, AC_VERB_SET_PROC_COEF, 0x3050}, 5178 5179 {0x01, AC_VERB_SET_GPIO_MASK, 0x01}, 5180 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, 5181 {0x01, AC_VERB_SET_GPIO_DATA, 0x00}, 5182 5183 {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 5184 {} 5185}; 5186 5187/* toggle speaker-output according to the hp-jack state */ 5188static void alc260_replacer_672v_automute(struct hda_codec *codec) 5189{ 5190 unsigned int present; 5191 5192 /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */ 5193 present = snd_hda_codec_read(codec, 0x0f, 0, 5194 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 5195 if (present) { 5196 snd_hda_codec_write_cache(codec, 0x01, 0, 5197 AC_VERB_SET_GPIO_DATA, 1); 5198 snd_hda_codec_write_cache(codec, 0x0f, 0, 5199 AC_VERB_SET_PIN_WIDGET_CONTROL, 5200 PIN_HP); 5201 } else { 5202 snd_hda_codec_write_cache(codec, 0x01, 0, 5203 AC_VERB_SET_GPIO_DATA, 0); 5204 snd_hda_codec_write_cache(codec, 0x0f, 0, 5205 AC_VERB_SET_PIN_WIDGET_CONTROL, 5206 PIN_OUT); 5207 } 5208} 5209 5210static void alc260_replacer_672v_unsol_event(struct hda_codec *codec, 5211 unsigned int res) 5212{ 5213 if ((res >> 26) == ALC880_HP_EVENT) 5214 alc260_replacer_672v_automute(codec); 5215} 5216 5217static struct hda_verb alc260_hp_dc7600_verbs[] = { 5218 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01}, 5219 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 5220 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5221 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 5222 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5223 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5224 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 5225 {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 5226 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 5227 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 5228 {} 5229}; 5230 5231/* Test configuration for debugging, modelled after the ALC880 test 5232 * configuration. 5233 */ 5234#ifdef CONFIG_SND_DEBUG 5235static hda_nid_t alc260_test_dac_nids[1] = { 5236 0x02, 5237}; 5238static hda_nid_t alc260_test_adc_nids[2] = { 5239 0x04, 0x05, 5240}; 5241/* For testing the ALC260, each input MUX needs its own definition since 5242 * the signal assignments are different. This assumes that the first ADC 5243 * is NID 0x04. 5244 */ 5245static struct hda_input_mux alc260_test_capture_sources[2] = { 5246 { 5247 .num_items = 7, 5248 .items = { 5249 { "MIC1 pin", 0x0 }, 5250 { "MIC2 pin", 0x1 }, 5251 { "LINE1 pin", 0x2 }, 5252 { "LINE2 pin", 0x3 }, 5253 { "CD pin", 0x4 }, 5254 { "LINE-OUT pin", 0x5 }, 5255 { "HP-OUT pin", 0x6 }, 5256 }, 5257 }, 5258 { 5259 .num_items = 8, 5260 .items = { 5261 { "MIC1 pin", 0x0 }, 5262 { "MIC2 pin", 0x1 }, 5263 { "LINE1 pin", 0x2 }, 5264 { "LINE2 pin", 0x3 }, 5265 { "CD pin", 0x4 }, 5266 { "Mixer", 0x5 }, 5267 { "LINE-OUT pin", 0x6 }, 5268 { "HP-OUT pin", 0x7 }, 5269 }, 5270 }, 5271}; 5272static struct snd_kcontrol_new alc260_test_mixer[] = { 5273 /* Output driver widgets */ 5274 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT), 5275 HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT), 5276 HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT), 5277 HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT), 5278 HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT), 5279 HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT), 5280 5281 /* Modes for retasking pin widgets 5282 * Note: the ALC260 doesn't seem to act on requests to enable mic 5283 * bias from NIDs 0x0f and 0x10. The ALC260 datasheet doesn't 5284 * mention this restriction. At this stage it's not clear whether 5285 * this behaviour is intentional or is a hardware bug in chip 5286 * revisions available at least up until early 2006. Therefore for 5287 * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all 5288 * choices, but if it turns out that the lack of mic bias for these 5289 * NIDs is intentional we could change their modes from 5290 * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS. 5291 */ 5292 ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT), 5293 ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT), 5294 ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT), 5295 ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT), 5296 ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT), 5297 ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT), 5298 5299 /* Loopback mixer controls */ 5300 HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT), 5301 HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT), 5302 HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT), 5303 HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT), 5304 HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT), 5305 HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT), 5306 HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT), 5307 HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT), 5308 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 5309 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 5310 HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT), 5311 HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT), 5312 HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT), 5313 HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT), 5314 5315 /* Controls for GPIO pins, assuming they are configured as outputs */ 5316 ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01), 5317 ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02), 5318 ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04), 5319 ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08), 5320 5321 /* Switches to allow the digital IO pins to be enabled. The datasheet 5322 * is ambigious as to which NID is which; testing on laptops which 5323 * make this output available should provide clarification. 5324 */ 5325 ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01), 5326 ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01), 5327 5328 /* A switch allowing EAPD to be enabled. Some laptops seem to use 5329 * this output to turn on an external amplifier. 5330 */ 5331 ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02), 5332 ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02), 5333 5334 { } /* end */ 5335}; 5336static struct hda_verb alc260_test_init_verbs[] = { 5337 /* Enable all GPIOs as outputs with an initial value of 0 */ 5338 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f}, 5339 {0x01, AC_VERB_SET_GPIO_DATA, 0x00}, 5340 {0x01, AC_VERB_SET_GPIO_MASK, 0x0f}, 5341 5342 /* Enable retasking pins as output, initially without power amp */ 5343 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5344 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5345 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5346 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5347 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5348 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5349 5350 /* Disable digital (SPDIF) pins initially, but users can enable 5351 * them via a mixer switch. In the case of SPDIF-out, this initverb 5352 * payload also sets the generation to 0, output to be in "consumer" 5353 * PCM format, copyright asserted, no pre-emphasis and no validity 5354 * control. 5355 */ 5356 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0}, 5357 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0}, 5358 5359 /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the 5360 * OUT1 sum bus when acting as an output. 5361 */ 5362 {0x0b, AC_VERB_SET_CONNECT_SEL, 0}, 5363 {0x0c, AC_VERB_SET_CONNECT_SEL, 0}, 5364 {0x0d, AC_VERB_SET_CONNECT_SEL, 0}, 5365 {0x0e, AC_VERB_SET_CONNECT_SEL, 0}, 5366 5367 /* Start with output sum widgets muted and their output gains at min */ 5368 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5369 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5370 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5371 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5372 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5373 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5374 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5375 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5376 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5377 5378 /* Unmute retasking pin widget output buffers since the default 5379 * state appears to be output. As the pin mode is changed by the 5380 * user the pin mode control will take care of enabling the pin's 5381 * input/output buffers as needed. 5382 */ 5383 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5384 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5385 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5386 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5387 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5388 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5389 /* Also unmute the mono-out pin widget */ 5390 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5391 5392 /* Mute capture amp left and right */ 5393 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5394 /* Set ADC connection select to match default mixer setting (mic1 5395 * pin) 5396 */ 5397 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00}, 5398 5399 /* Do the same for the second ADC: mute capture input amp and 5400 * set ADC connection to mic1 pin 5401 */ 5402 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5403 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00}, 5404 5405 /* Mute all inputs to mixer widget (even unconnected ones) */ 5406 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */ 5407 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */ 5408 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */ 5409 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */ 5410 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */ 5411 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */ 5412 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */ 5413 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */ 5414 5415 { } 5416}; 5417#endif 5418 5419#define alc260_pcm_analog_playback alc880_pcm_analog_alt_playback 5420#define alc260_pcm_analog_capture alc880_pcm_analog_capture 5421 5422#define alc260_pcm_digital_playback alc880_pcm_digital_playback 5423#define alc260_pcm_digital_capture alc880_pcm_digital_capture 5424 5425/* 5426 * for BIOS auto-configuration 5427 */ 5428 5429static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid, 5430 const char *pfx, int *vol_bits) 5431{ 5432 hda_nid_t nid_vol; 5433 unsigned long vol_val, sw_val; 5434 char name[32]; 5435 int err; 5436 5437 if (nid >= 0x0f && nid < 0x11) { 5438 nid_vol = nid - 0x7; 5439 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT); 5440 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 5441 } else if (nid == 0x11) { 5442 nid_vol = nid - 0x7; 5443 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT); 5444 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT); 5445 } else if (nid >= 0x12 && nid <= 0x15) { 5446 nid_vol = 0x08; 5447 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT); 5448 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 5449 } else 5450 return 0; /* N/A */ 5451 5452 if (!(*vol_bits & (1 << nid_vol))) { 5453 /* first control for the volume widget */ 5454 snprintf(name, sizeof(name), "%s Playback Volume", pfx); 5455 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val); 5456 if (err < 0) 5457 return err; 5458 *vol_bits |= (1 << nid_vol); 5459 } 5460 snprintf(name, sizeof(name), "%s Playback Switch", pfx); 5461 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val); 5462 if (err < 0) 5463 return err; 5464 return 1; 5465} 5466 5467/* add playback controls from the parsed DAC table */ 5468static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec, 5469 const struct auto_pin_cfg *cfg) 5470{ 5471 hda_nid_t nid; 5472 int err; 5473 int vols = 0; 5474 5475 spec->multiout.num_dacs = 1; 5476 spec->multiout.dac_nids = spec->private_dac_nids; 5477 spec->multiout.dac_nids[0] = 0x02; 5478 5479 nid = cfg->line_out_pins[0]; 5480 if (nid) { 5481 err = alc260_add_playback_controls(spec, nid, "Front", &vols); 5482 if (err < 0) 5483 return err; 5484 } 5485 5486 nid = cfg->speaker_pins[0]; 5487 if (nid) { 5488 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols); 5489 if (err < 0) 5490 return err; 5491 } 5492 5493 nid = cfg->hp_pins[0]; 5494 if (nid) { 5495 err = alc260_add_playback_controls(spec, nid, "Headphone", 5496 &vols); 5497 if (err < 0) 5498 return err; 5499 } 5500 return 0; 5501} 5502 5503/* create playback/capture controls for input pins */ 5504static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec, 5505 const struct auto_pin_cfg *cfg) 5506{ 5507 struct hda_input_mux *imux = &spec->private_imux[0]; 5508 int i, err, idx; 5509 5510 for (i = 0; i < AUTO_PIN_LAST; i++) { 5511 if (cfg->input_pins[i] >= 0x12) { 5512 idx = cfg->input_pins[i] - 0x12; 5513 err = new_analog_input(spec, cfg->input_pins[i], 5514 auto_pin_cfg_labels[i], idx, 5515 0x07); 5516 if (err < 0) 5517 return err; 5518 imux->items[imux->num_items].label = 5519 auto_pin_cfg_labels[i]; 5520 imux->items[imux->num_items].index = idx; 5521 imux->num_items++; 5522 } 5523 if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){ 5524 idx = cfg->input_pins[i] - 0x09; 5525 err = new_analog_input(spec, cfg->input_pins[i], 5526 auto_pin_cfg_labels[i], idx, 5527 0x07); 5528 if (err < 0) 5529 return err; 5530 imux->items[imux->num_items].label = 5531 auto_pin_cfg_labels[i]; 5532 imux->items[imux->num_items].index = idx; 5533 imux->num_items++; 5534 } 5535 } 5536 return 0; 5537} 5538 5539static void alc260_auto_set_output_and_unmute(struct hda_codec *codec, 5540 hda_nid_t nid, int pin_type, 5541 int sel_idx) 5542{ 5543 alc_set_pin_output(codec, nid, pin_type); 5544 /* need the manual connection? */ 5545 if (nid >= 0x12) { 5546 int idx = nid - 0x12; 5547 snd_hda_codec_write(codec, idx + 0x0b, 0, 5548 AC_VERB_SET_CONNECT_SEL, sel_idx); 5549 } 5550} 5551 5552static void alc260_auto_init_multi_out(struct hda_codec *codec) 5553{ 5554 struct alc_spec *spec = codec->spec; 5555 hda_nid_t nid; 5556 5557 alc_subsystem_id(codec, 0x10, 0x15, 0x0f); 5558 nid = spec->autocfg.line_out_pins[0]; 5559 if (nid) { 5560 int pin_type = get_pin_type(spec->autocfg.line_out_type); 5561 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0); 5562 } 5563 5564 nid = spec->autocfg.speaker_pins[0]; 5565 if (nid) 5566 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0); 5567 5568 nid = spec->autocfg.hp_pins[0]; 5569 if (nid) 5570 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0); 5571} 5572 5573#define ALC260_PIN_CD_NID 0x16 5574static void alc260_auto_init_analog_input(struct hda_codec *codec) 5575{ 5576 struct alc_spec *spec = codec->spec; 5577 int i; 5578 5579 for (i = 0; i < AUTO_PIN_LAST; i++) { 5580 hda_nid_t nid = spec->autocfg.input_pins[i]; 5581 if (nid >= 0x12) { 5582 snd_hda_codec_write(codec, nid, 0, 5583 AC_VERB_SET_PIN_WIDGET_CONTROL, 5584 i <= AUTO_PIN_FRONT_MIC ? 5585 PIN_VREF80 : PIN_IN); 5586 if (nid != ALC260_PIN_CD_NID) 5587 snd_hda_codec_write(codec, nid, 0, 5588 AC_VERB_SET_AMP_GAIN_MUTE, 5589 AMP_OUT_MUTE); 5590 } 5591 } 5592} 5593 5594/* 5595 * generic initialization of ADC, input mixers and output mixers 5596 */ 5597static struct hda_verb alc260_volume_init_verbs[] = { 5598 /* 5599 * Unmute ADC0-1 and set the default input to mic-in 5600 */ 5601 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00}, 5602 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5603 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00}, 5604 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5605 5606 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 5607 * mixer widget 5608 * Note: PASD motherboards uses the Line In 2 as the input for 5609 * front panel mic (mic 2) 5610 */ 5611 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 5612 /* mute analog inputs */ 5613 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5614 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5615 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5616 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5617 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5618 5619 /* 5620 * Set up output mixers (0x08 - 0x0a) 5621 */ 5622 /* set vol=0 to output mixers */ 5623 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5624 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5625 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5626 /* set up input amps for analog loopback */ 5627 /* Amp Indices: DAC = 0, mixer = 1 */ 5628 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5629 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5630 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5631 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5632 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5633 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5634 5635 { } 5636}; 5637 5638static int alc260_parse_auto_config(struct hda_codec *codec) 5639{ 5640 struct alc_spec *spec = codec->spec; 5641 int err; 5642 static hda_nid_t alc260_ignore[] = { 0x17, 0 }; 5643 5644 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 5645 alc260_ignore); 5646 if (err < 0) 5647 return err; 5648 err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg); 5649 if (err < 0) 5650 return err; 5651 if (!spec->kctls.list) 5652 return 0; /* can't find valid BIOS pin config */ 5653 err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg); 5654 if (err < 0) 5655 return err; 5656 5657 spec->multiout.max_channels = 2; 5658 5659 if (spec->autocfg.dig_out_pin) 5660 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID; 5661 if (spec->kctls.list) 5662 add_mixer(spec, spec->kctls.list); 5663 5664 add_verb(spec, alc260_volume_init_verbs); 5665 5666 spec->num_mux_defs = 1; 5667 spec->input_mux = &spec->private_imux[0]; 5668 5669 store_pin_configs(codec); 5670 return 1; 5671} 5672 5673/* additional initialization for auto-configuration model */ 5674static void alc260_auto_init(struct hda_codec *codec) 5675{ 5676 struct alc_spec *spec = codec->spec; 5677 alc260_auto_init_multi_out(codec); 5678 alc260_auto_init_analog_input(codec); 5679 if (spec->unsol_event) 5680 alc_inithook(codec); 5681} 5682 5683#ifdef CONFIG_SND_HDA_POWER_SAVE 5684static struct hda_amp_list alc260_loopbacks[] = { 5685 { 0x07, HDA_INPUT, 0 }, 5686 { 0x07, HDA_INPUT, 1 }, 5687 { 0x07, HDA_INPUT, 2 }, 5688 { 0x07, HDA_INPUT, 3 }, 5689 { 0x07, HDA_INPUT, 4 }, 5690 { } /* end */ 5691}; 5692#endif 5693 5694/* 5695 * ALC260 configurations 5696 */ 5697static const char *alc260_models[ALC260_MODEL_LAST] = { 5698 [ALC260_BASIC] = "basic", 5699 [ALC260_HP] = "hp", 5700 [ALC260_HP_3013] = "hp-3013", 5701 [ALC260_HP_DC7600] = "hp-dc7600", 5702 [ALC260_FUJITSU_S702X] = "fujitsu", 5703 [ALC260_ACER] = "acer", 5704 [ALC260_WILL] = "will", 5705 [ALC260_REPLACER_672V] = "replacer", 5706#ifdef CONFIG_SND_DEBUG 5707 [ALC260_TEST] = "test", 5708#endif 5709 [ALC260_AUTO] = "auto", 5710}; 5711 5712static struct snd_pci_quirk alc260_cfg_tbl[] = { 5713 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER), 5714 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER), 5715 SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013), 5716 SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013), 5717 SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013), 5718 SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013), 5719 SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600), 5720 SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013), 5721 SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP), 5722 SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP), 5723 SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP), 5724 SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC), 5725 SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC), 5726 SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC), 5727 SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X), 5728 SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC), 5729 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V), 5730 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL), 5731 {} 5732}; 5733 5734static struct alc_config_preset alc260_presets[] = { 5735 [ALC260_BASIC] = { 5736 .mixers = { alc260_base_output_mixer, 5737 alc260_input_mixer }, 5738 .init_verbs = { alc260_init_verbs }, 5739 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5740 .dac_nids = alc260_dac_nids, 5741 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids), 5742 .adc_nids = alc260_adc_nids, 5743 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5744 .channel_mode = alc260_modes, 5745 .input_mux = &alc260_capture_source, 5746 }, 5747 [ALC260_HP] = { 5748 .mixers = { alc260_hp_output_mixer, 5749 alc260_input_mixer }, 5750 .init_verbs = { alc260_init_verbs, 5751 alc260_hp_unsol_verbs }, 5752 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5753 .dac_nids = alc260_dac_nids, 5754 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt), 5755 .adc_nids = alc260_adc_nids_alt, 5756 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5757 .channel_mode = alc260_modes, 5758 .input_mux = &alc260_capture_source, 5759 .unsol_event = alc260_hp_unsol_event, 5760 .init_hook = alc260_hp_automute, 5761 }, 5762 [ALC260_HP_DC7600] = { 5763 .mixers = { alc260_hp_dc7600_mixer, 5764 alc260_input_mixer }, 5765 .init_verbs = { alc260_init_verbs, 5766 alc260_hp_dc7600_verbs }, 5767 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5768 .dac_nids = alc260_dac_nids, 5769 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt), 5770 .adc_nids = alc260_adc_nids_alt, 5771 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5772 .channel_mode = alc260_modes, 5773 .input_mux = &alc260_capture_source, 5774 .unsol_event = alc260_hp_3012_unsol_event, 5775 .init_hook = alc260_hp_3012_automute, 5776 }, 5777 [ALC260_HP_3013] = { 5778 .mixers = { alc260_hp_3013_mixer, 5779 alc260_input_mixer }, 5780 .init_verbs = { alc260_hp_3013_init_verbs, 5781 alc260_hp_3013_unsol_verbs }, 5782 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5783 .dac_nids = alc260_dac_nids, 5784 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt), 5785 .adc_nids = alc260_adc_nids_alt, 5786 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5787 .channel_mode = alc260_modes, 5788 .input_mux = &alc260_capture_source, 5789 .unsol_event = alc260_hp_3013_unsol_event, 5790 .init_hook = alc260_hp_3013_automute, 5791 }, 5792 [ALC260_FUJITSU_S702X] = { 5793 .mixers = { alc260_fujitsu_mixer }, 5794 .init_verbs = { alc260_fujitsu_init_verbs }, 5795 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5796 .dac_nids = alc260_dac_nids, 5797 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids), 5798 .adc_nids = alc260_dual_adc_nids, 5799 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5800 .channel_mode = alc260_modes, 5801 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources), 5802 .input_mux = alc260_fujitsu_capture_sources, 5803 }, 5804 [ALC260_ACER] = { 5805 .mixers = { alc260_acer_mixer }, 5806 .init_verbs = { alc260_acer_init_verbs }, 5807 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5808 .dac_nids = alc260_dac_nids, 5809 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids), 5810 .adc_nids = alc260_dual_adc_nids, 5811 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5812 .channel_mode = alc260_modes, 5813 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources), 5814 .input_mux = alc260_acer_capture_sources, 5815 }, 5816 [ALC260_WILL] = { 5817 .mixers = { alc260_will_mixer }, 5818 .init_verbs = { alc260_init_verbs, alc260_will_verbs }, 5819 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5820 .dac_nids = alc260_dac_nids, 5821 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids), 5822 .adc_nids = alc260_adc_nids, 5823 .dig_out_nid = ALC260_DIGOUT_NID, 5824 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5825 .channel_mode = alc260_modes, 5826 .input_mux = &alc260_capture_source, 5827 }, 5828 [ALC260_REPLACER_672V] = { 5829 .mixers = { alc260_replacer_672v_mixer }, 5830 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs }, 5831 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5832 .dac_nids = alc260_dac_nids, 5833 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids), 5834 .adc_nids = alc260_adc_nids, 5835 .dig_out_nid = ALC260_DIGOUT_NID, 5836 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5837 .channel_mode = alc260_modes, 5838 .input_mux = &alc260_capture_source, 5839 .unsol_event = alc260_replacer_672v_unsol_event, 5840 .init_hook = alc260_replacer_672v_automute, 5841 }, 5842#ifdef CONFIG_SND_DEBUG 5843 [ALC260_TEST] = { 5844 .mixers = { alc260_test_mixer }, 5845 .init_verbs = { alc260_test_init_verbs }, 5846 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids), 5847 .dac_nids = alc260_test_dac_nids, 5848 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids), 5849 .adc_nids = alc260_test_adc_nids, 5850 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5851 .channel_mode = alc260_modes, 5852 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources), 5853 .input_mux = alc260_test_capture_sources, 5854 }, 5855#endif 5856}; 5857 5858static int patch_alc260(struct hda_codec *codec) 5859{ 5860 struct alc_spec *spec; 5861 int err, board_config; 5862 5863 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5864 if (spec == NULL) 5865 return -ENOMEM; 5866 5867 codec->spec = spec; 5868 5869 board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST, 5870 alc260_models, 5871 alc260_cfg_tbl); 5872 if (board_config < 0) { 5873 snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260, " 5874 "trying auto-probe from BIOS...\n"); 5875 board_config = ALC260_AUTO; 5876 } 5877 5878 if (board_config == ALC260_AUTO) { 5879 /* automatic parse from the BIOS config */ 5880 err = alc260_parse_auto_config(codec); 5881 if (err < 0) { 5882 alc_free(codec); 5883 return err; 5884 } else if (!err) { 5885 printk(KERN_INFO 5886 "hda_codec: Cannot set up configuration " 5887 "from BIOS. Using base mode...\n"); 5888 board_config = ALC260_BASIC; 5889 } 5890 } 5891 5892 err = snd_hda_attach_beep_device(codec, 0x1); 5893 if (err < 0) { 5894 alc_free(codec); 5895 return err; 5896 } 5897 5898 if (board_config != ALC260_AUTO) 5899 setup_preset(spec, &alc260_presets[board_config]); 5900 5901 spec->stream_name_analog = "ALC260 Analog"; 5902 spec->stream_analog_playback = &alc260_pcm_analog_playback; 5903 spec->stream_analog_capture = &alc260_pcm_analog_capture; 5904 5905 spec->stream_name_digital = "ALC260 Digital"; 5906 spec->stream_digital_playback = &alc260_pcm_digital_playback; 5907 spec->stream_digital_capture = &alc260_pcm_digital_capture; 5908 5909 if (!spec->adc_nids && spec->input_mux) { 5910 /* check whether NID 0x04 is valid */ 5911 unsigned int wcap = get_wcaps(codec, 0x04); 5912 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 5913 /* get type */ 5914 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) { 5915 spec->adc_nids = alc260_adc_nids_alt; 5916 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt); 5917 } else { 5918 spec->adc_nids = alc260_adc_nids; 5919 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids); 5920 } 5921 } 5922 set_capture_mixer(spec); 5923 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT); 5924 5925 spec->vmaster_nid = 0x08; 5926 5927 codec->patch_ops = alc_patch_ops; 5928 if (board_config == ALC260_AUTO) 5929 spec->init_hook = alc260_auto_init; 5930#ifdef CONFIG_SND_HDA_POWER_SAVE 5931 if (!spec->loopback.amplist) 5932 spec->loopback.amplist = alc260_loopbacks; 5933#endif 5934 codec->proc_widget_hook = print_realtek_coef; 5935 5936 return 0; 5937} 5938 5939 5940/* 5941 * ALC882 support 5942 * 5943 * ALC882 is almost identical with ALC880 but has cleaner and more flexible 5944 * configuration. Each pin widget can choose any input DACs and a mixer. 5945 * Each ADC is connected from a mixer of all inputs. This makes possible 5946 * 6-channel independent captures. 5947 * 5948 * In addition, an independent DAC for the multi-playback (not used in this 5949 * driver yet). 5950 */ 5951#define ALC882_DIGOUT_NID 0x06 5952#define ALC882_DIGIN_NID 0x0a 5953 5954static struct hda_channel_mode alc882_ch_modes[1] = { 5955 { 8, NULL } 5956}; 5957 5958static hda_nid_t alc882_dac_nids[4] = { 5959 /* front, rear, clfe, rear_surr */ 5960 0x02, 0x03, 0x04, 0x05 5961}; 5962 5963/* identical with ALC880 */ 5964#define alc882_adc_nids alc880_adc_nids 5965#define alc882_adc_nids_alt alc880_adc_nids_alt 5966 5967static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 }; 5968static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 }; 5969 5970/* input MUX */ 5971/* FIXME: should be a matrix-type input source selection */ 5972 5973static struct hda_input_mux alc882_capture_source = { 5974 .num_items = 4, 5975 .items = { 5976 { "Mic", 0x0 }, 5977 { "Front Mic", 0x1 }, 5978 { "Line", 0x2 }, 5979 { "CD", 0x4 }, 5980 }, 5981}; 5982/* 5983 * 2ch mode 5984 */ 5985static struct hda_verb alc882_3ST_ch2_init[] = { 5986 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 5987 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 5988 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 5989 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 5990 { } /* end */ 5991}; 5992 5993/* 5994 * 6ch mode 5995 */ 5996static struct hda_verb alc882_3ST_ch6_init[] = { 5997 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 5998 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 5999 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 }, 6000 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6001 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 6002 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 6003 { } /* end */ 6004}; 6005 6006static struct hda_channel_mode alc882_3ST_6ch_modes[2] = { 6007 { 2, alc882_3ST_ch2_init }, 6008 { 6, alc882_3ST_ch6_init }, 6009}; 6010 6011/* 6012 * 6ch mode 6013 */ 6014static struct hda_verb alc882_sixstack_ch6_init[] = { 6015 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 6016 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6017 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6018 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6019 { } /* end */ 6020}; 6021 6022/* 6023 * 8ch mode 6024 */ 6025static struct hda_verb alc882_sixstack_ch8_init[] = { 6026 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6027 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6028 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6029 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6030 { } /* end */ 6031}; 6032 6033static struct hda_channel_mode alc882_sixstack_modes[2] = { 6034 { 6, alc882_sixstack_ch6_init }, 6035 { 8, alc882_sixstack_ch8_init }, 6036}; 6037 6038/* 6039 * macbook pro ALC885 can switch LineIn to LineOut without loosing Mic 6040 */ 6041 6042/* 6043 * 2ch mode 6044 */ 6045static struct hda_verb alc885_mbp_ch2_init[] = { 6046 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 6047 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6048 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6049 { } /* end */ 6050}; 6051 6052/* 6053 * 6ch mode 6054 */ 6055static struct hda_verb alc885_mbp_ch6_init[] = { 6056 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6057 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6058 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 6059 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6060 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6061 { } /* end */ 6062}; 6063 6064static struct hda_channel_mode alc885_mbp_6ch_modes[2] = { 6065 { 2, alc885_mbp_ch2_init }, 6066 { 6, alc885_mbp_ch6_init }, 6067}; 6068 6069 6070/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17 6071 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b 6072 */ 6073static struct snd_kcontrol_new alc882_base_mixer[] = { 6074 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 6075 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 6076 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 6077 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 6078 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 6079 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 6080 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 6081 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 6082 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 6083 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 6084 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 6085 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 6086 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 6087 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 6088 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 6089 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 6090 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 6091 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 6092 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 6093 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 6094 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 6095 { } /* end */ 6096}; 6097 6098static struct snd_kcontrol_new alc885_mbp3_mixer[] = { 6099 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT), 6100 HDA_BIND_MUTE ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT), 6101 HDA_CODEC_MUTE ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT), 6102 HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT), 6103 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 6104 HDA_CODEC_MUTE ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 6105 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT), 6106 HDA_CODEC_MUTE ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT), 6107 HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT), 6108 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT), 6109 { } /* end */ 6110}; 6111static struct snd_kcontrol_new alc882_w2jc_mixer[] = { 6112 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 6113 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 6114 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 6115 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 6116 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 6117 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 6118 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 6119 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 6120 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 6121 { } /* end */ 6122}; 6123 6124static struct snd_kcontrol_new alc882_targa_mixer[] = { 6125 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 6126 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 6127 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 6128 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 6129 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 6130 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 6131 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 6132 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 6133 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 6134 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 6135 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 6136 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 6137 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 6138 { } /* end */ 6139}; 6140 6141/* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ??? 6142 * Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c 6143 */ 6144static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = { 6145 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 6146 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 6147 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 6148 HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT), 6149 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 6150 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 6151 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 6152 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 6153 HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT), 6154 HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT), 6155 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 6156 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 6157 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 6158 { } /* end */ 6159}; 6160 6161static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = { 6162 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 6163 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 6164 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 6165 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 6166 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 6167 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 6168 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 6169 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 6170 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 6171 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 6172 { } /* end */ 6173}; 6174 6175static struct snd_kcontrol_new alc882_chmode_mixer[] = { 6176 { 6177 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6178 .name = "Channel Mode", 6179 .info = alc_ch_mode_info, 6180 .get = alc_ch_mode_get, 6181 .put = alc_ch_mode_put, 6182 }, 6183 { } /* end */ 6184}; 6185 6186static struct hda_verb alc882_init_verbs[] = { 6187 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 6188 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6189 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6190 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6191 /* Rear mixer */ 6192 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6193 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6194 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6195 /* CLFE mixer */ 6196 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6197 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6198 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6199 /* Side mixer */ 6200 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6201 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6202 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6203 6204 /* Front Pin: output 0 (0x0c) */ 6205 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6206 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6207 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 6208 /* Rear Pin: output 1 (0x0d) */ 6209 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6210 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6211 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 6212 /* CLFE Pin: output 2 (0x0e) */ 6213 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6214 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6215 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02}, 6216 /* Side Pin: output 3 (0x0f) */ 6217 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6218 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6219 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 6220 /* Mic (rear) pin: input vref at 80% */ 6221 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 6222 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 6223 /* Front Mic pin: input vref at 80% */ 6224 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 6225 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 6226 /* Line In pin: input */ 6227 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 6228 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 6229 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 6230 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 6231 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6232 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 6233 /* CD pin widget for input */ 6234 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 6235 6236 /* FIXME: use matrix-type input source selection */ 6237 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 6238 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 6239 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6240 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6241 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6242 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6243 /* Input mixer2 */ 6244 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6245 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6246 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6247 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6248 /* Input mixer3 */ 6249 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6250 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6251 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6252 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6253 /* ADC1: mute amp left and right */ 6254 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6255 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 6256 /* ADC2: mute amp left and right */ 6257 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6258 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 6259 /* ADC3: mute amp left and right */ 6260 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6261 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 6262 6263 { } 6264}; 6265 6266static struct hda_verb alc882_eapd_verbs[] = { 6267 /* change to EAPD mode */ 6268 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 6269 {0x20, AC_VERB_SET_PROC_COEF, 0x3060}, 6270 { } 6271}; 6272 6273/* Mac Pro test */ 6274static struct snd_kcontrol_new alc882_macpro_mixer[] = { 6275 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 6276 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 6277 HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT), 6278 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT), 6279 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT), 6280 /* FIXME: this looks suspicious... 6281 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT), 6282 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT), 6283 */ 6284 { } /* end */ 6285}; 6286 6287static struct hda_verb alc882_macpro_init_verbs[] = { 6288 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 6289 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6290 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6291 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6292 /* Front Pin: output 0 (0x0c) */ 6293 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6294 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6295 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 6296 /* Front Mic pin: input vref at 80% */ 6297 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 6298 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 6299 /* Speaker: output */ 6300 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6301 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6302 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04}, 6303 /* Headphone output (output 0 - 0x0c) */ 6304 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 6305 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6306 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00}, 6307 6308 /* FIXME: use matrix-type input source selection */ 6309 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 6310 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 6311 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6312 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6313 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6314 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6315 /* Input mixer2 */ 6316 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6317 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6318 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6319 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6320 /* Input mixer3 */ 6321 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6322 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6323 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6324 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6325 /* ADC1: mute amp left and right */ 6326 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6327 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 6328 /* ADC2: mute amp left and right */ 6329 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6330 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 6331 /* ADC3: mute amp left and right */ 6332 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6333 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 6334 6335 { } 6336}; 6337 6338/* Macbook Pro rev3 */ 6339static struct hda_verb alc885_mbp3_init_verbs[] = { 6340 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 6341 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6342 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6343 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6344 /* Rear mixer */ 6345 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6346 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6347 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6348 /* Front Pin: output 0 (0x0c) */ 6349 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6350 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6351 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 6352 /* HP Pin: output 0 (0x0d) */ 6353 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4}, 6354 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 6355 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 6356 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 6357 /* Mic (rear) pin: input vref at 80% */ 6358 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 6359 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 6360 /* Front Mic pin: input vref at 80% */ 6361 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 6362 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 6363 /* Line In pin: use output 1 when in LineOut mode */ 6364 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 6365 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 6366 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, 6367 6368 /* FIXME: use matrix-type input source selection */ 6369 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 6370 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 6371 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6372 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6373 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6374 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6375 /* Input mixer2 */ 6376 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6377 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6378 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6379 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6380 /* Input mixer3 */ 6381 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6382 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6383 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6384 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6385 /* ADC1: mute amp left and right */ 6386 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6387 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 6388 /* ADC2: mute amp left and right */ 6389 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6390 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 6391 /* ADC3: mute amp left and right */ 6392 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6393 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 6394 6395 { } 6396}; 6397 6398/* iMac 24 mixer. */ 6399static struct snd_kcontrol_new alc885_imac24_mixer[] = { 6400 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT), 6401 HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT), 6402 { } /* end */ 6403}; 6404 6405/* iMac 24 init verbs. */ 6406static struct hda_verb alc885_imac24_init_verbs[] = { 6407 /* Internal speakers: output 0 (0x0c) */ 6408 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6409 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6410 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00}, 6411 /* Internal speakers: output 0 (0x0c) */ 6412 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6413 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6414 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00}, 6415 /* Headphone: output 0 (0x0c) */ 6416 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 6417 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6418 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 6419 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 6420 /* Front Mic: input vref at 80% */ 6421 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 6422 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 6423 { } 6424}; 6425 6426/* Toggle speaker-output according to the hp-jack state */ 6427static void alc885_imac24_automute(struct hda_codec *codec) 6428{ 6429 unsigned int present; 6430 6431 present = snd_hda_codec_read(codec, 0x14, 0, 6432 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 6433 snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0, 6434 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 6435 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0, 6436 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 6437} 6438 6439/* Processes unsolicited events. */ 6440static void alc885_imac24_unsol_event(struct hda_codec *codec, 6441 unsigned int res) 6442{ 6443 /* Headphone insertion or removal. */ 6444 if ((res >> 26) == ALC880_HP_EVENT) 6445 alc885_imac24_automute(codec); 6446} 6447 6448static void alc885_mbp3_automute(struct hda_codec *codec) 6449{ 6450 unsigned int present; 6451 6452 present = snd_hda_codec_read(codec, 0x15, 0, 6453 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 6454 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 6455 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 6456 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 6457 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE); 6458 6459} 6460static void alc885_mbp3_unsol_event(struct hda_codec *codec, 6461 unsigned int res) 6462{ 6463 /* Headphone insertion or removal. */ 6464 if ((res >> 26) == ALC880_HP_EVENT) 6465 alc885_mbp3_automute(codec); 6466} 6467 6468 6469static struct hda_verb alc882_targa_verbs[] = { 6470 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6471 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6472 6473 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 6474 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6475 6476 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 6477 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */ 6478 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 6479 6480 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 6481 {0x01, AC_VERB_SET_GPIO_MASK, 0x03}, 6482 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03}, 6483 {0x01, AC_VERB_SET_GPIO_DATA, 0x03}, 6484 { } /* end */ 6485}; 6486 6487/* toggle speaker-output according to the hp-jack state */ 6488static void alc882_targa_automute(struct hda_codec *codec) 6489{ 6490 unsigned int present; 6491 6492 present = snd_hda_codec_read(codec, 0x14, 0, 6493 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 6494 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 6495 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 6496 snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA, 6497 present ? 1 : 3); 6498} 6499 6500static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res) 6501{ 6502 /* Looks like the unsol event is incompatible with the standard 6503 * definition. 4bit tag is placed at 26 bit! 6504 */ 6505 if (((res >> 26) == ALC880_HP_EVENT)) { 6506 alc882_targa_automute(codec); 6507 } 6508} 6509 6510static struct hda_verb alc882_asus_a7j_verbs[] = { 6511 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6512 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6513 6514 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 6515 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6516 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6517 6518 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */ 6519 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 6520 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */ 6521 6522 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 6523 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */ 6524 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 6525 { } /* end */ 6526}; 6527 6528static struct hda_verb alc882_asus_a7m_verbs[] = { 6529 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6530 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6531 6532 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 6533 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6534 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6535 6536 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */ 6537 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 6538 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */ 6539 6540 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 6541 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */ 6542 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 6543 { } /* end */ 6544}; 6545 6546static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted) 6547{ 6548 unsigned int gpiostate, gpiomask, gpiodir; 6549 6550 gpiostate = snd_hda_codec_read(codec, codec->afg, 0, 6551 AC_VERB_GET_GPIO_DATA, 0); 6552 6553 if (!muted) 6554 gpiostate |= (1 << pin); 6555 else 6556 gpiostate &= ~(1 << pin); 6557 6558 gpiomask = snd_hda_codec_read(codec, codec->afg, 0, 6559 AC_VERB_GET_GPIO_MASK, 0); 6560 gpiomask |= (1 << pin); 6561 6562 gpiodir = snd_hda_codec_read(codec, codec->afg, 0, 6563 AC_VERB_GET_GPIO_DIRECTION, 0); 6564 gpiodir |= (1 << pin); 6565 6566 6567 snd_hda_codec_write(codec, codec->afg, 0, 6568 AC_VERB_SET_GPIO_MASK, gpiomask); 6569 snd_hda_codec_write(codec, codec->afg, 0, 6570 AC_VERB_SET_GPIO_DIRECTION, gpiodir); 6571 6572 msleep(1); 6573 6574 snd_hda_codec_write(codec, codec->afg, 0, 6575 AC_VERB_SET_GPIO_DATA, gpiostate); 6576} 6577 6578/* set up GPIO at initialization */ 6579static void alc885_macpro_init_hook(struct hda_codec *codec) 6580{ 6581 alc882_gpio_mute(codec, 0, 0); 6582 alc882_gpio_mute(codec, 1, 0); 6583} 6584 6585/* set up GPIO and update auto-muting at initialization */ 6586static void alc885_imac24_init_hook(struct hda_codec *codec) 6587{ 6588 alc885_macpro_init_hook(codec); 6589 alc885_imac24_automute(codec); 6590} 6591 6592/* 6593 * generic initialization of ADC, input mixers and output mixers 6594 */ 6595static struct hda_verb alc882_auto_init_verbs[] = { 6596 /* 6597 * Unmute ADC0-2 and set the default input to mic-in 6598 */ 6599 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 6600 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6601 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 6602 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6603 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 6604 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6605 6606 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 6607 * mixer widget 6608 * Note: PASD motherboards uses the Line In 2 as the input for 6609 * front panel mic (mic 2) 6610 */ 6611 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 6612 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6613 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6614 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6615 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6616 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6617 6618 /* 6619 * Set up output mixers (0x0c - 0x0f) 6620 */ 6621 /* set vol=0 to output mixers */ 6622 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6623 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6624 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6625 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6626 /* set up input amps for analog loopback */ 6627 /* Amp Indices: DAC = 0, mixer = 1 */ 6628 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6629 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6630 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6631 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6632 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6633 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6634 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6635 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6636 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6637 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6638 6639 /* FIXME: use matrix-type input source selection */ 6640 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 6641 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 6642 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 6643 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 6644 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 6645 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 6646 /* Input mixer2 */ 6647 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 6648 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 6649 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 6650 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 6651 /* Input mixer3 */ 6652 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 6653 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 6654 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 6655 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 6656 6657 { } 6658}; 6659 6660#ifdef CONFIG_SND_HDA_POWER_SAVE 6661#define alc882_loopbacks alc880_loopbacks 6662#endif 6663 6664/* pcm configuration: identiacal with ALC880 */ 6665#define alc882_pcm_analog_playback alc880_pcm_analog_playback 6666#define alc882_pcm_analog_capture alc880_pcm_analog_capture 6667#define alc882_pcm_digital_playback alc880_pcm_digital_playback 6668#define alc882_pcm_digital_capture alc880_pcm_digital_capture 6669 6670/* 6671 * configuration and preset 6672 */ 6673static const char *alc882_models[ALC882_MODEL_LAST] = { 6674 [ALC882_3ST_DIG] = "3stack-dig", 6675 [ALC882_6ST_DIG] = "6stack-dig", 6676 [ALC882_ARIMA] = "arima", 6677 [ALC882_W2JC] = "w2jc", 6678 [ALC882_TARGA] = "targa", 6679 [ALC882_ASUS_A7J] = "asus-a7j", 6680 [ALC882_ASUS_A7M] = "asus-a7m", 6681 [ALC885_MACPRO] = "macpro", 6682 [ALC885_MBP3] = "mbp3", 6683 [ALC885_IMAC24] = "imac24", 6684 [ALC882_AUTO] = "auto", 6685}; 6686 6687static struct snd_pci_quirk alc882_cfg_tbl[] = { 6688 SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG), 6689 SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J), 6690 SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J), 6691 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M), 6692 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC), 6693 SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG), 6694 SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG), 6695 SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG), 6696 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG), 6697 SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8 */ 6698 SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG), 6699 SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), 6700 {} 6701}; 6702 6703static struct alc_config_preset alc882_presets[] = { 6704 [ALC882_3ST_DIG] = { 6705 .mixers = { alc882_base_mixer }, 6706 .init_verbs = { alc882_init_verbs }, 6707 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6708 .dac_nids = alc882_dac_nids, 6709 .dig_out_nid = ALC882_DIGOUT_NID, 6710 .dig_in_nid = ALC882_DIGIN_NID, 6711 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes), 6712 .channel_mode = alc882_ch_modes, 6713 .need_dac_fix = 1, 6714 .input_mux = &alc882_capture_source, 6715 }, 6716 [ALC882_6ST_DIG] = { 6717 .mixers = { alc882_base_mixer, alc882_chmode_mixer }, 6718 .init_verbs = { alc882_init_verbs }, 6719 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6720 .dac_nids = alc882_dac_nids, 6721 .dig_out_nid = ALC882_DIGOUT_NID, 6722 .dig_in_nid = ALC882_DIGIN_NID, 6723 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes), 6724 .channel_mode = alc882_sixstack_modes, 6725 .input_mux = &alc882_capture_source, 6726 }, 6727 [ALC882_ARIMA] = { 6728 .mixers = { alc882_base_mixer, alc882_chmode_mixer }, 6729 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs }, 6730 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6731 .dac_nids = alc882_dac_nids, 6732 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes), 6733 .channel_mode = alc882_sixstack_modes, 6734 .input_mux = &alc882_capture_source, 6735 }, 6736 [ALC882_W2JC] = { 6737 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer }, 6738 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs, 6739 alc880_gpio1_init_verbs }, 6740 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6741 .dac_nids = alc882_dac_nids, 6742 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 6743 .channel_mode = alc880_threestack_modes, 6744 .need_dac_fix = 1, 6745 .input_mux = &alc882_capture_source, 6746 .dig_out_nid = ALC882_DIGOUT_NID, 6747 }, 6748 [ALC885_MBP3] = { 6749 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer }, 6750 .init_verbs = { alc885_mbp3_init_verbs, 6751 alc880_gpio1_init_verbs }, 6752 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6753 .dac_nids = alc882_dac_nids, 6754 .channel_mode = alc885_mbp_6ch_modes, 6755 .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes), 6756 .input_mux = &alc882_capture_source, 6757 .dig_out_nid = ALC882_DIGOUT_NID, 6758 .dig_in_nid = ALC882_DIGIN_NID, 6759 .unsol_event = alc885_mbp3_unsol_event, 6760 .init_hook = alc885_mbp3_automute, 6761 }, 6762 [ALC885_MACPRO] = { 6763 .mixers = { alc882_macpro_mixer }, 6764 .init_verbs = { alc882_macpro_init_verbs }, 6765 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6766 .dac_nids = alc882_dac_nids, 6767 .dig_out_nid = ALC882_DIGOUT_NID, 6768 .dig_in_nid = ALC882_DIGIN_NID, 6769 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes), 6770 .channel_mode = alc882_ch_modes, 6771 .input_mux = &alc882_capture_source, 6772 .init_hook = alc885_macpro_init_hook, 6773 }, 6774 [ALC885_IMAC24] = { 6775 .mixers = { alc885_imac24_mixer }, 6776 .init_verbs = { alc885_imac24_init_verbs }, 6777 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6778 .dac_nids = alc882_dac_nids, 6779 .dig_out_nid = ALC882_DIGOUT_NID, 6780 .dig_in_nid = ALC882_DIGIN_NID, 6781 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes), 6782 .channel_mode = alc882_ch_modes, 6783 .input_mux = &alc882_capture_source, 6784 .unsol_event = alc885_imac24_unsol_event, 6785 .init_hook = alc885_imac24_init_hook, 6786 }, 6787 [ALC882_TARGA] = { 6788 .mixers = { alc882_targa_mixer, alc882_chmode_mixer }, 6789 .init_verbs = { alc882_init_verbs, alc882_targa_verbs}, 6790 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6791 .dac_nids = alc882_dac_nids, 6792 .dig_out_nid = ALC882_DIGOUT_NID, 6793 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids), 6794 .adc_nids = alc882_adc_nids, 6795 .capsrc_nids = alc882_capsrc_nids, 6796 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes), 6797 .channel_mode = alc882_3ST_6ch_modes, 6798 .need_dac_fix = 1, 6799 .input_mux = &alc882_capture_source, 6800 .unsol_event = alc882_targa_unsol_event, 6801 .init_hook = alc882_targa_automute, 6802 }, 6803 [ALC882_ASUS_A7J] = { 6804 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer }, 6805 .init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs}, 6806 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6807 .dac_nids = alc882_dac_nids, 6808 .dig_out_nid = ALC882_DIGOUT_NID, 6809 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids), 6810 .adc_nids = alc882_adc_nids, 6811 .capsrc_nids = alc882_capsrc_nids, 6812 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes), 6813 .channel_mode = alc882_3ST_6ch_modes, 6814 .need_dac_fix = 1, 6815 .input_mux = &alc882_capture_source, 6816 }, 6817 [ALC882_ASUS_A7M] = { 6818 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer }, 6819 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs, 6820 alc880_gpio1_init_verbs, 6821 alc882_asus_a7m_verbs }, 6822 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6823 .dac_nids = alc882_dac_nids, 6824 .dig_out_nid = ALC882_DIGOUT_NID, 6825 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 6826 .channel_mode = alc880_threestack_modes, 6827 .need_dac_fix = 1, 6828 .input_mux = &alc882_capture_source, 6829 }, 6830}; 6831 6832 6833/* 6834 * Pin config fixes 6835 */ 6836enum { 6837 PINFIX_ABIT_AW9D_MAX 6838}; 6839 6840static struct alc_pincfg alc882_abit_aw9d_pinfix[] = { 6841 { 0x15, 0x01080104 }, /* side */ 6842 { 0x16, 0x01011012 }, /* rear */ 6843 { 0x17, 0x01016011 }, /* clfe */ 6844 { } 6845}; 6846 6847static const struct alc_pincfg *alc882_pin_fixes[] = { 6848 [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix, 6849}; 6850 6851static struct snd_pci_quirk alc882_pinfix_tbl[] = { 6852 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX), 6853 {} 6854}; 6855 6856/* 6857 * BIOS auto configuration 6858 */ 6859static void alc882_auto_set_output_and_unmute(struct hda_codec *codec, 6860 hda_nid_t nid, int pin_type, 6861 int dac_idx) 6862{ 6863 /* set as output */ 6864 struct alc_spec *spec = codec->spec; 6865 int idx; 6866 6867 alc_set_pin_output(codec, nid, pin_type); 6868 if (spec->multiout.dac_nids[dac_idx] == 0x25) 6869 idx = 4; 6870 else 6871 idx = spec->multiout.dac_nids[dac_idx] - 2; 6872 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx); 6873 6874} 6875 6876static void alc882_auto_init_multi_out(struct hda_codec *codec) 6877{ 6878 struct alc_spec *spec = codec->spec; 6879 int i; 6880 6881 alc_subsystem_id(codec, 0x15, 0x1b, 0x14); 6882 for (i = 0; i <= HDA_SIDE; i++) { 6883 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 6884 int pin_type = get_pin_type(spec->autocfg.line_out_type); 6885 if (nid) 6886 alc882_auto_set_output_and_unmute(codec, nid, pin_type, 6887 i); 6888 } 6889} 6890 6891static void alc882_auto_init_hp_out(struct hda_codec *codec) 6892{ 6893 struct alc_spec *spec = codec->spec; 6894 hda_nid_t pin; 6895 6896 pin = spec->autocfg.hp_pins[0]; 6897 if (pin) /* connect to front */ 6898 /* use dac 0 */ 6899 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 6900 pin = spec->autocfg.speaker_pins[0]; 6901 if (pin) 6902 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 6903} 6904 6905#define alc882_is_input_pin(nid) alc880_is_input_pin(nid) 6906#define ALC882_PIN_CD_NID ALC880_PIN_CD_NID 6907 6908static void alc882_auto_init_analog_input(struct hda_codec *codec) 6909{ 6910 struct alc_spec *spec = codec->spec; 6911 int i; 6912 6913 for (i = 0; i < AUTO_PIN_LAST; i++) { 6914 hda_nid_t nid = spec->autocfg.input_pins[i]; 6915 unsigned int vref; 6916 if (!nid) 6917 continue; 6918 vref = PIN_IN; 6919 if (1 /*i <= AUTO_PIN_FRONT_MIC*/) { 6920 unsigned int pincap; 6921 pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP); 6922 if ((pincap >> AC_PINCAP_VREF_SHIFT) & 6923 AC_PINCAP_VREF_80) 6924 vref = PIN_VREF80; 6925 } 6926 snd_hda_codec_write(codec, nid, 0, 6927 AC_VERB_SET_PIN_WIDGET_CONTROL, vref); 6928 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) 6929 snd_hda_codec_write(codec, nid, 0, 6930 AC_VERB_SET_AMP_GAIN_MUTE, 6931 AMP_OUT_MUTE); 6932 } 6933} 6934 6935static void alc882_auto_init_input_src(struct hda_codec *codec) 6936{ 6937 struct alc_spec *spec = codec->spec; 6938 int c; 6939 6940 for (c = 0; c < spec->num_adc_nids; c++) { 6941 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS]; 6942 hda_nid_t nid = spec->capsrc_nids[c]; 6943 unsigned int mux_idx; 6944 const struct hda_input_mux *imux; 6945 int conns, mute, idx, item; 6946 6947 conns = snd_hda_get_connections(codec, nid, conn_list, 6948 ARRAY_SIZE(conn_list)); 6949 if (conns < 0) 6950 continue; 6951 mux_idx = c >= spec->num_mux_defs ? 0 : c; 6952 imux = &spec->input_mux[mux_idx]; 6953 for (idx = 0; idx < conns; idx++) { 6954 /* if the current connection is the selected one, 6955 * unmute it as default - otherwise mute it 6956 */ 6957 mute = AMP_IN_MUTE(idx); 6958 for (item = 0; item < imux->num_items; item++) { 6959 if (imux->items[item].index == idx) { 6960 if (spec->cur_mux[c] == item) 6961 mute = AMP_IN_UNMUTE(idx); 6962 break; 6963 } 6964 } 6965 /* check if we have a selector or mixer 6966 * we could check for the widget type instead, but 6967 * just check for Amp-In presence (in case of mixer 6968 * without amp-in there is something wrong, this 6969 * function shouldn't be used or capsrc nid is wrong) 6970 */ 6971 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) 6972 snd_hda_codec_write(codec, nid, 0, 6973 AC_VERB_SET_AMP_GAIN_MUTE, 6974 mute); 6975 else if (mute != AMP_IN_MUTE(idx)) 6976 snd_hda_codec_write(codec, nid, 0, 6977 AC_VERB_SET_CONNECT_SEL, 6978 idx); 6979 } 6980 } 6981} 6982 6983/* add mic boosts if needed */ 6984static int alc_auto_add_mic_boost(struct hda_codec *codec) 6985{ 6986 struct alc_spec *spec = codec->spec; 6987 int err; 6988 hda_nid_t nid; 6989 6990 nid = spec->autocfg.input_pins[AUTO_PIN_MIC]; 6991 if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) { 6992 err = add_control(spec, ALC_CTL_WIDGET_VOL, 6993 "Mic Boost", 6994 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT)); 6995 if (err < 0) 6996 return err; 6997 } 6998 nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC]; 6999 if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) { 7000 err = add_control(spec, ALC_CTL_WIDGET_VOL, 7001 "Front Mic Boost", 7002 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT)); 7003 if (err < 0) 7004 return err; 7005 } 7006 return 0; 7007} 7008 7009/* almost identical with ALC880 parser... */ 7010static int alc882_parse_auto_config(struct hda_codec *codec) 7011{ 7012 struct alc_spec *spec = codec->spec; 7013 int err = alc880_parse_auto_config(codec); 7014 7015 if (err < 0) 7016 return err; 7017 else if (!err) 7018 return 0; /* no config found */ 7019 7020 err = alc_auto_add_mic_boost(codec); 7021 if (err < 0) 7022 return err; 7023 7024 /* hack - override the init verbs */ 7025 spec->init_verbs[0] = alc882_auto_init_verbs; 7026 7027 return 1; /* config found */ 7028} 7029 7030/* additional initialization for auto-configuration model */ 7031static void alc882_auto_init(struct hda_codec *codec) 7032{ 7033 struct alc_spec *spec = codec->spec; 7034 alc882_auto_init_multi_out(codec); 7035 alc882_auto_init_hp_out(codec); 7036 alc882_auto_init_analog_input(codec); 7037 alc882_auto_init_input_src(codec); 7038 if (spec->unsol_event) 7039 alc_inithook(codec); 7040} 7041 7042static int patch_alc883(struct hda_codec *codec); /* called in patch_alc882() */ 7043 7044static int patch_alc882(struct hda_codec *codec) 7045{ 7046 struct alc_spec *spec; 7047 int err, board_config; 7048 7049 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 7050 if (spec == NULL) 7051 return -ENOMEM; 7052 7053 codec->spec = spec; 7054 7055 board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST, 7056 alc882_models, 7057 alc882_cfg_tbl); 7058 7059 if (board_config < 0 || board_config >= ALC882_MODEL_LAST) { 7060 /* Pick up systems that don't supply PCI SSID */ 7061 switch (codec->subsystem_id) { 7062 case 0x106b0c00: /* Mac Pro */ 7063 board_config = ALC885_MACPRO; 7064 break; 7065 case 0x106b1000: /* iMac 24 */ 7066 case 0x106b2800: /* AppleTV */ 7067 case 0x106b3e00: /* iMac 24 Aluminium */ 7068 board_config = ALC885_IMAC24; 7069 break; 7070 case 0x106b00a1: /* Macbook (might be wrong - PCI SSID?) */ 7071 case 0x106b00a4: /* MacbookPro4,1 */ 7072 case 0x106b2c00: /* Macbook Pro rev3 */ 7073 case 0x106b3600: /* Macbook 3.1 */ 7074 case 0x106b3800: /* MacbookPro4,1 - latter revision */ 7075 board_config = ALC885_MBP3; 7076 break; 7077 default: 7078 /* ALC889A is handled better as ALC888-compatible */ 7079 if (codec->revision_id == 0x100101 || 7080 codec->revision_id == 0x100103) { 7081 alc_free(codec); 7082 return patch_alc883(codec); 7083 } 7084 printk(KERN_INFO "hda_codec: Unknown model for ALC882, " 7085 "trying auto-probe from BIOS...\n"); 7086 board_config = ALC882_AUTO; 7087 } 7088 } 7089 7090 alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes); 7091 7092 if (board_config == ALC882_AUTO) { 7093 /* automatic parse from the BIOS config */ 7094 err = alc882_parse_auto_config(codec); 7095 if (err < 0) { 7096 alc_free(codec); 7097 return err; 7098 } else if (!err) { 7099 printk(KERN_INFO 7100 "hda_codec: Cannot set up configuration " 7101 "from BIOS. Using base mode...\n"); 7102 board_config = ALC882_3ST_DIG; 7103 } 7104 } 7105 7106 err = snd_hda_attach_beep_device(codec, 0x1); 7107 if (err < 0) { 7108 alc_free(codec); 7109 return err; 7110 } 7111 7112 if (board_config != ALC882_AUTO) 7113 setup_preset(spec, &alc882_presets[board_config]); 7114 7115 if (codec->vendor_id == 0x10ec0885) { 7116 spec->stream_name_analog = "ALC885 Analog"; 7117 spec->stream_name_digital = "ALC885 Digital"; 7118 } else { 7119 spec->stream_name_analog = "ALC882 Analog"; 7120 spec->stream_name_digital = "ALC882 Digital"; 7121 } 7122 7123 spec->stream_analog_playback = &alc882_pcm_analog_playback; 7124 spec->stream_analog_capture = &alc882_pcm_analog_capture; 7125 /* FIXME: setup DAC5 */ 7126 /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/ 7127 spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture; 7128 7129 spec->stream_digital_playback = &alc882_pcm_digital_playback; 7130 spec->stream_digital_capture = &alc882_pcm_digital_capture; 7131 7132 spec->capture_style = CAPT_MIX; /* matrix-style capture */ 7133 if (!spec->adc_nids && spec->input_mux) { 7134 /* check whether NID 0x07 is valid */ 7135 unsigned int wcap = get_wcaps(codec, 0x07); 7136 /* get type */ 7137 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 7138 if (wcap != AC_WID_AUD_IN) { 7139 spec->adc_nids = alc882_adc_nids_alt; 7140 spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt); 7141 spec->capsrc_nids = alc882_capsrc_nids_alt; 7142 } else { 7143 spec->adc_nids = alc882_adc_nids; 7144 spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids); 7145 spec->capsrc_nids = alc882_capsrc_nids; 7146 } 7147 } 7148 set_capture_mixer(spec); 7149 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 7150 7151 spec->vmaster_nid = 0x0c; 7152 7153 codec->patch_ops = alc_patch_ops; 7154 if (board_config == ALC882_AUTO) 7155 spec->init_hook = alc882_auto_init; 7156#ifdef CONFIG_SND_HDA_POWER_SAVE 7157 if (!spec->loopback.amplist) 7158 spec->loopback.amplist = alc882_loopbacks; 7159#endif 7160 codec->proc_widget_hook = print_realtek_coef; 7161 7162 return 0; 7163} 7164 7165/* 7166 * ALC883 support 7167 * 7168 * ALC883 is almost identical with ALC880 but has cleaner and more flexible 7169 * configuration. Each pin widget can choose any input DACs and a mixer. 7170 * Each ADC is connected from a mixer of all inputs. This makes possible 7171 * 6-channel independent captures. 7172 * 7173 * In addition, an independent DAC for the multi-playback (not used in this 7174 * driver yet). 7175 */ 7176#define ALC883_DIGOUT_NID 0x06 7177#define ALC883_DIGIN_NID 0x0a 7178 7179#define ALC1200_DIGOUT_NID 0x10 7180 7181static hda_nid_t alc883_dac_nids[4] = { 7182 /* front, rear, clfe, rear_surr */ 7183 0x02, 0x03, 0x04, 0x05 7184}; 7185 7186static hda_nid_t alc883_adc_nids[2] = { 7187 /* ADC1-2 */ 7188 0x08, 0x09, 7189}; 7190 7191static hda_nid_t alc883_adc_nids_alt[1] = { 7192 /* ADC1 */ 7193 0x08, 7194}; 7195 7196static hda_nid_t alc883_adc_nids_rev[2] = { 7197 /* ADC2-1 */ 7198 0x09, 0x08 7199}; 7200 7201#define alc889_adc_nids alc880_adc_nids 7202 7203static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 }; 7204 7205static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 }; 7206 7207#define alc889_capsrc_nids alc882_capsrc_nids 7208 7209/* input MUX */ 7210/* FIXME: should be a matrix-type input source selection */ 7211 7212static struct hda_input_mux alc883_capture_source = { 7213 .num_items = 4, 7214 .items = { 7215 { "Mic", 0x0 }, 7216 { "Front Mic", 0x1 }, 7217 { "Line", 0x2 }, 7218 { "CD", 0x4 }, 7219 }, 7220}; 7221 7222static struct hda_input_mux alc883_3stack_6ch_intel = { 7223 .num_items = 4, 7224 .items = { 7225 { "Mic", 0x1 }, 7226 { "Front Mic", 0x0 }, 7227 { "Line", 0x2 }, 7228 { "CD", 0x4 }, 7229 }, 7230}; 7231 7232static struct hda_input_mux alc883_lenovo_101e_capture_source = { 7233 .num_items = 2, 7234 .items = { 7235 { "Mic", 0x1 }, 7236 { "Line", 0x2 }, 7237 }, 7238}; 7239 7240static struct hda_input_mux alc883_lenovo_nb0763_capture_source = { 7241 .num_items = 4, 7242 .items = { 7243 { "Mic", 0x0 }, 7244 { "iMic", 0x1 }, 7245 { "Line", 0x2 }, 7246 { "CD", 0x4 }, 7247 }, 7248}; 7249 7250static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = { 7251 .num_items = 2, 7252 .items = { 7253 { "Mic", 0x0 }, 7254 { "Int Mic", 0x1 }, 7255 }, 7256}; 7257 7258static struct hda_input_mux alc883_lenovo_sky_capture_source = { 7259 .num_items = 3, 7260 .items = { 7261 { "Mic", 0x0 }, 7262 { "Front Mic", 0x1 }, 7263 { "Line", 0x4 }, 7264 }, 7265}; 7266 7267static struct hda_input_mux alc883_asus_eee1601_capture_source = { 7268 .num_items = 2, 7269 .items = { 7270 { "Mic", 0x0 }, 7271 { "Line", 0x2 }, 7272 }, 7273}; 7274 7275/* 7276 * 2ch mode 7277 */ 7278static struct hda_channel_mode alc883_3ST_2ch_modes[1] = { 7279 { 2, NULL } 7280}; 7281 7282/* 7283 * 2ch mode 7284 */ 7285static struct hda_verb alc883_3ST_ch2_init[] = { 7286 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 7287 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7288 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 7289 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7290 { } /* end */ 7291}; 7292 7293/* 7294 * 4ch mode 7295 */ 7296static struct hda_verb alc883_3ST_ch4_init[] = { 7297 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 7298 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7299 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7300 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7301 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 7302 { } /* end */ 7303}; 7304 7305/* 7306 * 6ch mode 7307 */ 7308static struct hda_verb alc883_3ST_ch6_init[] = { 7309 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7310 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7311 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 }, 7312 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7313 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7314 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 7315 { } /* end */ 7316}; 7317 7318static struct hda_channel_mode alc883_3ST_6ch_modes[3] = { 7319 { 2, alc883_3ST_ch2_init }, 7320 { 4, alc883_3ST_ch4_init }, 7321 { 6, alc883_3ST_ch6_init }, 7322}; 7323 7324/* 7325 * 2ch mode 7326 */ 7327static struct hda_verb alc883_3ST_ch2_intel_init[] = { 7328 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 7329 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7330 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 7331 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7332 { } /* end */ 7333}; 7334 7335/* 7336 * 4ch mode 7337 */ 7338static struct hda_verb alc883_3ST_ch4_intel_init[] = { 7339 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 7340 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7341 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7342 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7343 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 7344 { } /* end */ 7345}; 7346 7347/* 7348 * 6ch mode 7349 */ 7350static struct hda_verb alc883_3ST_ch6_intel_init[] = { 7351 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7352 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7353 { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 }, 7354 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7355 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7356 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 7357 { } /* end */ 7358}; 7359 7360static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = { 7361 { 2, alc883_3ST_ch2_intel_init }, 7362 { 4, alc883_3ST_ch4_intel_init }, 7363 { 6, alc883_3ST_ch6_intel_init }, 7364}; 7365 7366/* 7367 * 6ch mode 7368 */ 7369static struct hda_verb alc883_sixstack_ch6_init[] = { 7370 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 7371 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7372 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7373 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7374 { } /* end */ 7375}; 7376 7377/* 7378 * 8ch mode 7379 */ 7380static struct hda_verb alc883_sixstack_ch8_init[] = { 7381 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7382 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7383 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7384 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7385 { } /* end */ 7386}; 7387 7388static struct hda_channel_mode alc883_sixstack_modes[2] = { 7389 { 6, alc883_sixstack_ch6_init }, 7390 { 8, alc883_sixstack_ch8_init }, 7391}; 7392 7393static struct hda_verb alc883_medion_eapd_verbs[] = { 7394 /* eanable EAPD on medion laptop */ 7395 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 7396 {0x20, AC_VERB_SET_PROC_COEF, 0x3070}, 7397 { } 7398}; 7399 7400/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17 7401 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b 7402 */ 7403 7404static struct snd_kcontrol_new alc883_base_mixer[] = { 7405 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7406 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7407 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7408 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 7409 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 7410 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 7411 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 7412 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 7413 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 7414 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 7415 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7416 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7417 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7418 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7419 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7420 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7421 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7422 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7423 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7424 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 7425 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7426 { } /* end */ 7427}; 7428 7429static struct snd_kcontrol_new alc883_mitac_mixer[] = { 7430 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7431 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7432 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 7433 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 7434 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 7435 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 7436 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 7437 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7438 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7439 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7440 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7441 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 7442 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7443 { } /* end */ 7444}; 7445 7446static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = { 7447 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7448 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 7449 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7450 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 7451 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7452 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7453 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7454 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7455 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 7456 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7457 { } /* end */ 7458}; 7459 7460static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = { 7461 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7462 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 7463 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7464 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 7465 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7466 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7467 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7468 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7469 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 7470 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7471 { } /* end */ 7472}; 7473 7474static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = { 7475 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7476 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7477 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7478 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7479 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7480 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7481 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7482 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7483 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7484 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7485 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7486 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 7487 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7488 { } /* end */ 7489}; 7490 7491static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = { 7492 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7493 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7494 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7495 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 7496 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 7497 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 7498 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 7499 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 7500 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7501 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7502 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7503 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7504 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7505 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7506 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7507 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7508 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7509 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 7510 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7511 { } /* end */ 7512}; 7513 7514static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = { 7515 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7516 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7517 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7518 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 7519 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, 7520 HDA_OUTPUT), 7521 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 7522 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 7523 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 7524 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 7525 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7526 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7527 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7528 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7529 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7530 HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT), 7531 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7532 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7533 HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT), 7534 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7535 { } /* end */ 7536}; 7537 7538static struct snd_kcontrol_new alc883_fivestack_mixer[] = { 7539 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7540 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7541 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7542 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 7543 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 7544 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 7545 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 7546 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 7547 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7548 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7549 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7550 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7551 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7552 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7553 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7554 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7555 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7556 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 7557 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7558 { } /* end */ 7559}; 7560 7561static struct snd_kcontrol_new alc883_tagra_mixer[] = { 7562 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7563 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 7564 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7565 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7566 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 7567 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 7568 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 7569 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 7570 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 7571 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7572 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7573 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7574 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7575 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7576 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7577 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7578 { } /* end */ 7579}; 7580 7581static struct snd_kcontrol_new alc883_tagra_2ch_mixer[] = { 7582 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7583 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 7584 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7585 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7586 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7587 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7588 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7589 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7590 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7591 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 7592 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7593 { } /* end */ 7594}; 7595 7596static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = { 7597 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7598 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7599 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7600 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 7601 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7602 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7603 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7604 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7605 { } /* end */ 7606}; 7607 7608static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = { 7609 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7610 HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT), 7611 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 7612 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7613 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7614 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7615 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7616 HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7617 HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7618 { } /* end */ 7619}; 7620 7621static struct snd_kcontrol_new alc883_medion_md2_mixer[] = { 7622 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7623 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 7624 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT), 7625 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7626 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7627 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7628 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7629 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7630 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7631 { } /* end */ 7632}; 7633 7634static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = { 7635 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7636 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7637 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 7638 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7639 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7640 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7641 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7642 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7643 { } /* end */ 7644}; 7645 7646static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = { 7647 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7648 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7649 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT), 7650 HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT), 7651 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 7652 0x0d, 1, 0x0, HDA_OUTPUT), 7653 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT), 7654 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT), 7655 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT), 7656 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 7657 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 7658 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7659 HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x1a, 0x0, HDA_OUTPUT), 7660 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7661 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7662 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7663 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7664 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7665 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7666 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7667 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7668 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 7669 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7670 { } /* end */ 7671}; 7672 7673static struct hda_bind_ctls alc883_bind_cap_vol = { 7674 .ops = &snd_hda_bind_vol, 7675 .values = { 7676 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT), 7677 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT), 7678 0 7679 }, 7680}; 7681 7682static struct hda_bind_ctls alc883_bind_cap_switch = { 7683 .ops = &snd_hda_bind_sw, 7684 .values = { 7685 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT), 7686 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT), 7687 0 7688 }, 7689}; 7690 7691static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = { 7692 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7693 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7694 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 7695 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7696 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7697 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7698 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7699 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7700 { } /* end */ 7701}; 7702 7703static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = { 7704 HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol), 7705 HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch), 7706 { 7707 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7708 /* .name = "Capture Source", */ 7709 .name = "Input Source", 7710 .count = 1, 7711 .info = alc_mux_enum_info, 7712 .get = alc_mux_enum_get, 7713 .put = alc_mux_enum_put, 7714 }, 7715 { } /* end */ 7716}; 7717 7718static struct snd_kcontrol_new alc883_chmode_mixer[] = { 7719 { 7720 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7721 .name = "Channel Mode", 7722 .info = alc_ch_mode_info, 7723 .get = alc_ch_mode_get, 7724 .put = alc_ch_mode_put, 7725 }, 7726 { } /* end */ 7727}; 7728 7729static struct hda_verb alc883_init_verbs[] = { 7730 /* ADC1: mute amp left and right */ 7731 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7732 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 7733 /* ADC2: mute amp left and right */ 7734 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7735 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 7736 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 7737 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7738 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7739 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7740 /* Rear mixer */ 7741 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7742 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7743 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7744 /* CLFE mixer */ 7745 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7746 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7747 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7748 /* Side mixer */ 7749 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7750 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7751 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7752 7753 /* mute analog input loopbacks */ 7754 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7755 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7756 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 7757 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 7758 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 7759 7760 /* Front Pin: output 0 (0x0c) */ 7761 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7762 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7763 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 7764 /* Rear Pin: output 1 (0x0d) */ 7765 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7766 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7767 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 7768 /* CLFE Pin: output 2 (0x0e) */ 7769 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7770 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7771 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02}, 7772 /* Side Pin: output 3 (0x0f) */ 7773 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7774 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7775 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 7776 /* Mic (rear) pin: input vref at 80% */ 7777 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 7778 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 7779 /* Front Mic pin: input vref at 80% */ 7780 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 7781 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 7782 /* Line In pin: input */ 7783 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 7784 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 7785 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 7786 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7787 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7788 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 7789 /* CD pin widget for input */ 7790 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 7791 7792 /* FIXME: use matrix-type input source selection */ 7793 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 7794 /* Input mixer2 */ 7795 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7796 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7797 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 7798 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 7799 /* Input mixer3 */ 7800 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7801 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7802 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 7803 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 7804 { } 7805}; 7806 7807/* toggle speaker-output according to the hp-jack state */ 7808static void alc883_mitac_hp_automute(struct hda_codec *codec) 7809{ 7810 unsigned int present; 7811 7812 present = snd_hda_codec_read(codec, 0x15, 0, 7813 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7814 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 7815 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7816 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0, 7817 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7818} 7819 7820/* auto-toggle front mic */ 7821/* 7822static void alc883_mitac_mic_automute(struct hda_codec *codec) 7823{ 7824 unsigned int present; 7825 unsigned char bits; 7826 7827 present = snd_hda_codec_read(codec, 0x18, 0, 7828 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7829 bits = present ? HDA_AMP_MUTE : 0; 7830 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits); 7831} 7832*/ 7833 7834static void alc883_mitac_automute(struct hda_codec *codec) 7835{ 7836 alc883_mitac_hp_automute(codec); 7837 /* alc883_mitac_mic_automute(codec); */ 7838} 7839 7840static void alc883_mitac_unsol_event(struct hda_codec *codec, 7841 unsigned int res) 7842{ 7843 switch (res >> 26) { 7844 case ALC880_HP_EVENT: 7845 alc883_mitac_hp_automute(codec); 7846 break; 7847 case ALC880_MIC_EVENT: 7848 /* alc883_mitac_mic_automute(codec); */ 7849 break; 7850 } 7851} 7852 7853static struct hda_verb alc883_mitac_verbs[] = { 7854 /* HP */ 7855 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 7856 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7857 /* Subwoofer */ 7858 {0x17, AC_VERB_SET_CONNECT_SEL, 0x02}, 7859 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7860 7861 /* enable unsolicited event */ 7862 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7863 /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */ 7864 7865 { } /* end */ 7866}; 7867 7868static struct hda_verb alc883_clevo_m720_verbs[] = { 7869 /* HP */ 7870 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 7871 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7872 /* Int speaker */ 7873 {0x14, AC_VERB_SET_CONNECT_SEL, 0x01}, 7874 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7875 7876 /* enable unsolicited event */ 7877 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7878 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, 7879 7880 { } /* end */ 7881}; 7882 7883static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = { 7884 /* HP */ 7885 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 7886 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7887 /* Subwoofer */ 7888 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 7889 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7890 7891 /* enable unsolicited event */ 7892 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7893 7894 { } /* end */ 7895}; 7896 7897static struct hda_verb alc883_tagra_verbs[] = { 7898 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7899 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7900 7901 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7902 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7903 7904 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 7905 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */ 7906 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 7907 7908 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7909 {0x01, AC_VERB_SET_GPIO_MASK, 0x03}, 7910 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03}, 7911 {0x01, AC_VERB_SET_GPIO_DATA, 0x03}, 7912 7913 { } /* end */ 7914}; 7915 7916static struct hda_verb alc883_lenovo_101e_verbs[] = { 7917 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 7918 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN}, 7919 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN}, 7920 { } /* end */ 7921}; 7922 7923static struct hda_verb alc883_lenovo_nb0763_verbs[] = { 7924 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 7925 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7926 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7927 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7928 { } /* end */ 7929}; 7930 7931static struct hda_verb alc888_lenovo_ms7195_verbs[] = { 7932 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7933 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7934 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 7935 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN}, 7936 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7937 { } /* end */ 7938}; 7939 7940static struct hda_verb alc883_haier_w66_verbs[] = { 7941 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7942 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7943 7944 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7945 7946 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 7947 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7948 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7949 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7950 { } /* end */ 7951}; 7952 7953static struct hda_verb alc888_lenovo_sky_verbs[] = { 7954 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7955 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7956 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7957 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7958 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7959 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7960 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00}, 7961 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7962 { } /* end */ 7963}; 7964 7965static struct hda_verb alc888_3st_hp_verbs[] = { 7966 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front: output 0 (0x0c) */ 7967 {0x16, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Rear : output 1 (0x0d) */ 7968 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* CLFE : output 2 (0x0e) */ 7969 { } 7970}; 7971 7972static struct hda_verb alc888_6st_dell_verbs[] = { 7973 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7974 { } 7975}; 7976 7977static struct hda_verb alc888_3st_hp_2ch_init[] = { 7978 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 7979 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7980 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 7981 { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7982 { } 7983}; 7984 7985static struct hda_verb alc888_3st_hp_6ch_init[] = { 7986 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7987 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7988 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7989 { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7990 { } 7991}; 7992 7993static struct hda_channel_mode alc888_3st_hp_modes[2] = { 7994 { 2, alc888_3st_hp_2ch_init }, 7995 { 6, alc888_3st_hp_6ch_init }, 7996}; 7997 7998/* toggle front-jack and RCA according to the hp-jack state */ 7999static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec) 8000{ 8001 unsigned int present; 8002 8003 present = snd_hda_codec_read(codec, 0x1b, 0, 8004 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 8005 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 8006 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 8007 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 8008 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 8009} 8010 8011/* toggle RCA according to the front-jack state */ 8012static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec) 8013{ 8014 unsigned int present; 8015 8016 present = snd_hda_codec_read(codec, 0x14, 0, 8017 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 8018 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 8019 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 8020} 8021 8022static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec, 8023 unsigned int res) 8024{ 8025 if ((res >> 26) == ALC880_HP_EVENT) 8026 alc888_lenovo_ms7195_front_automute(codec); 8027 if ((res >> 26) == ALC880_FRONT_EVENT) 8028 alc888_lenovo_ms7195_rca_automute(codec); 8029} 8030 8031static struct hda_verb alc883_medion_md2_verbs[] = { 8032 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8033 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8034 8035 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8036 8037 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 8038 { } /* end */ 8039}; 8040 8041/* toggle speaker-output according to the hp-jack state */ 8042static void alc883_medion_md2_automute(struct hda_codec *codec) 8043{ 8044 unsigned int present; 8045 8046 present = snd_hda_codec_read(codec, 0x14, 0, 8047 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 8048 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 8049 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 8050} 8051 8052static void alc883_medion_md2_unsol_event(struct hda_codec *codec, 8053 unsigned int res) 8054{ 8055 if ((res >> 26) == ALC880_HP_EVENT) 8056 alc883_medion_md2_automute(codec); 8057} 8058 8059/* toggle speaker-output according to the hp-jack state */ 8060static void alc883_tagra_automute(struct hda_codec *codec) 8061{ 8062 unsigned int present; 8063 unsigned char bits; 8064 8065 present = snd_hda_codec_read(codec, 0x14, 0, 8066 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 8067 bits = present ? HDA_AMP_MUTE : 0; 8068 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 8069 HDA_AMP_MUTE, bits); 8070 snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA, 8071 present ? 1 : 3); 8072} 8073 8074static void alc883_tagra_unsol_event(struct hda_codec *codec, unsigned int res) 8075{ 8076 if ((res >> 26) == ALC880_HP_EVENT) 8077 alc883_tagra_automute(codec); 8078} 8079 8080/* toggle speaker-output according to the hp-jack state */ 8081static void alc883_clevo_m720_hp_automute(struct hda_codec *codec) 8082{ 8083 unsigned int present; 8084 unsigned char bits; 8085 8086 present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0) 8087 & AC_PINSENSE_PRESENCE; 8088 bits = present ? HDA_AMP_MUTE : 0; 8089 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 8090 HDA_AMP_MUTE, bits); 8091} 8092 8093static void alc883_clevo_m720_mic_automute(struct hda_codec *codec) 8094{ 8095 unsigned int present; 8096 8097 present = snd_hda_codec_read(codec, 0x18, 0, 8098 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 8099 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, 8100 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 8101} 8102 8103static void alc883_clevo_m720_automute(struct hda_codec *codec) 8104{ 8105 alc883_clevo_m720_hp_automute(codec); 8106 alc883_clevo_m720_mic_automute(codec); 8107} 8108 8109static void alc883_clevo_m720_unsol_event(struct hda_codec *codec, 8110 unsigned int res) 8111{ 8112 switch (res >> 26) { 8113 case ALC880_HP_EVENT: 8114 alc883_clevo_m720_hp_automute(codec); 8115 break; 8116 case ALC880_MIC_EVENT: 8117 alc883_clevo_m720_mic_automute(codec); 8118 break; 8119 } 8120} 8121 8122/* toggle speaker-output according to the hp-jack state */ 8123static void alc883_2ch_fujitsu_pi2515_automute(struct hda_codec *codec) 8124{ 8125 unsigned int present; 8126 unsigned char bits; 8127 8128 present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0) 8129 & AC_PINSENSE_PRESENCE; 8130 bits = present ? HDA_AMP_MUTE : 0; 8131 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 8132 HDA_AMP_MUTE, bits); 8133} 8134 8135static void alc883_2ch_fujitsu_pi2515_unsol_event(struct hda_codec *codec, 8136 unsigned int res) 8137{ 8138 if ((res >> 26) == ALC880_HP_EVENT) 8139 alc883_2ch_fujitsu_pi2515_automute(codec); 8140} 8141 8142static void alc883_haier_w66_automute(struct hda_codec *codec) 8143{ 8144 unsigned int present; 8145 unsigned char bits; 8146 8147 present = snd_hda_codec_read(codec, 0x1b, 0, 8148 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 8149 bits = present ? 0x80 : 0; 8150 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 8151 0x80, bits); 8152} 8153 8154static void alc883_haier_w66_unsol_event(struct hda_codec *codec, 8155 unsigned int res) 8156{ 8157 if ((res >> 26) == ALC880_HP_EVENT) 8158 alc883_haier_w66_automute(codec); 8159} 8160 8161static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec) 8162{ 8163 unsigned int present; 8164 unsigned char bits; 8165 8166 present = snd_hda_codec_read(codec, 0x14, 0, 8167 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 8168 bits = present ? HDA_AMP_MUTE : 0; 8169 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 8170 HDA_AMP_MUTE, bits); 8171} 8172 8173static void alc883_lenovo_101e_all_automute(struct hda_codec *codec) 8174{ 8175 unsigned int present; 8176 unsigned char bits; 8177 8178 present = snd_hda_codec_read(codec, 0x1b, 0, 8179 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 8180 bits = present ? HDA_AMP_MUTE : 0; 8181 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 8182 HDA_AMP_MUTE, bits); 8183 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 8184 HDA_AMP_MUTE, bits); 8185} 8186 8187static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec, 8188 unsigned int res) 8189{ 8190 if ((res >> 26) == ALC880_HP_EVENT) 8191 alc883_lenovo_101e_all_automute(codec); 8192 if ((res >> 26) == ALC880_FRONT_EVENT) 8193 alc883_lenovo_101e_ispeaker_automute(codec); 8194} 8195 8196/* toggle speaker-output according to the hp-jack state */ 8197static void alc883_acer_aspire_automute(struct hda_codec *codec) 8198{ 8199 unsigned int present; 8200 8201 present = snd_hda_codec_read(codec, 0x14, 0, 8202 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 8203 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 8204 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 8205 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 8206 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 8207} 8208 8209static void alc883_acer_aspire_unsol_event(struct hda_codec *codec, 8210 unsigned int res) 8211{ 8212 if ((res >> 26) == ALC880_HP_EVENT) 8213 alc883_acer_aspire_automute(codec); 8214} 8215 8216static struct hda_verb alc883_acer_eapd_verbs[] = { 8217 /* HP Pin: output 0 (0x0c) */ 8218 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8219 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8220 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 8221 /* Front Pin: output 0 (0x0c) */ 8222 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8223 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 8224 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8225 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, 8226 /* eanable EAPD on medion laptop */ 8227 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 8228 {0x20, AC_VERB_SET_PROC_COEF, 0x3050}, 8229 /* enable unsolicited event */ 8230 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 8231 { } 8232}; 8233 8234static void alc888_6st_dell_front_automute(struct hda_codec *codec) 8235{ 8236 unsigned int present; 8237 8238 present = snd_hda_codec_read(codec, 0x1b, 0, 8239 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 8240 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 8241 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 8242 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 8243 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 8244 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 8245 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 8246 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0, 8247 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 8248} 8249 8250static void alc888_6st_dell_unsol_event(struct hda_codec *codec, 8251 unsigned int res) 8252{ 8253 switch (res >> 26) { 8254 case ALC880_HP_EVENT: 8255 /* printk(KERN_DEBUG "hp_event\n"); */ 8256 alc888_6st_dell_front_automute(codec); 8257 break; 8258 } 8259} 8260 8261static void alc888_lenovo_sky_front_automute(struct hda_codec *codec) 8262{ 8263 unsigned int mute; 8264 unsigned int present; 8265 8266 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0); 8267 present = snd_hda_codec_read(codec, 0x1b, 0, 8268 AC_VERB_GET_PIN_SENSE, 0); 8269 present = (present & 0x80000000) != 0; 8270 if (present) { 8271 /* mute internal speaker */ 8272 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 8273 HDA_AMP_MUTE, HDA_AMP_MUTE); 8274 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 8275 HDA_AMP_MUTE, HDA_AMP_MUTE); 8276 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 8277 HDA_AMP_MUTE, HDA_AMP_MUTE); 8278 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0, 8279 HDA_AMP_MUTE, HDA_AMP_MUTE); 8280 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0, 8281 HDA_AMP_MUTE, HDA_AMP_MUTE); 8282 } else { 8283 /* unmute internal speaker if necessary */ 8284 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0); 8285 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 8286 HDA_AMP_MUTE, mute); 8287 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 8288 HDA_AMP_MUTE, mute); 8289 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 8290 HDA_AMP_MUTE, mute); 8291 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0, 8292 HDA_AMP_MUTE, mute); 8293 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0, 8294 HDA_AMP_MUTE, mute); 8295 } 8296} 8297 8298static void alc883_lenovo_sky_unsol_event(struct hda_codec *codec, 8299 unsigned int res) 8300{ 8301 if ((res >> 26) == ALC880_HP_EVENT) 8302 alc888_lenovo_sky_front_automute(codec); 8303} 8304 8305/* 8306 * generic initialization of ADC, input mixers and output mixers 8307 */ 8308static struct hda_verb alc883_auto_init_verbs[] = { 8309 /* 8310 * Unmute ADC0-2 and set the default input to mic-in 8311 */ 8312 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 8313 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8314 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 8315 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8316 8317 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 8318 * mixer widget 8319 * Note: PASD motherboards uses the Line In 2 as the input for 8320 * front panel mic (mic 2) 8321 */ 8322 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 8323 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8324 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8325 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 8326 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 8327 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 8328 8329 /* 8330 * Set up output mixers (0x0c - 0x0f) 8331 */ 8332 /* set vol=0 to output mixers */ 8333 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8334 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8335 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8336 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8337 /* set up input amps for analog loopback */ 8338 /* Amp Indices: DAC = 0, mixer = 1 */ 8339 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8340 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8341 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8342 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8343 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8344 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8345 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8346 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8347 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8348 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8349 8350 /* FIXME: use matrix-type input source selection */ 8351 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 8352 /* Input mixer1 */ 8353 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8354 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8355 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 8356 /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */ 8357 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 8358 /* Input mixer2 */ 8359 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8360 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8361 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 8362 /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */ 8363 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 8364 8365 { } 8366}; 8367 8368static struct hda_verb alc888_asus_m90v_verbs[] = { 8369 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8370 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8371 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8372 /* enable unsolicited event */ 8373 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 8374 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, 8375 { } /* end */ 8376}; 8377 8378static void alc883_nb_mic_automute(struct hda_codec *codec) 8379{ 8380 unsigned int present; 8381 8382 present = snd_hda_codec_read(codec, 0x18, 0, 8383 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 8384 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE, 8385 0x7000 | (0x00 << 8) | (present ? 0 : 0x80)); 8386 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE, 8387 0x7000 | (0x01 << 8) | (present ? 0x80 : 0)); 8388} 8389 8390static void alc883_M90V_speaker_automute(struct hda_codec *codec) 8391{ 8392 unsigned int present; 8393 unsigned char bits; 8394 8395 present = snd_hda_codec_read(codec, 0x1b, 0, 8396 AC_VERB_GET_PIN_SENSE, 0) 8397 & AC_PINSENSE_PRESENCE; 8398 bits = present ? 0 : PIN_OUT; 8399 snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 8400 bits); 8401 snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 8402 bits); 8403 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 8404 bits); 8405} 8406 8407static void alc883_mode2_unsol_event(struct hda_codec *codec, 8408 unsigned int res) 8409{ 8410 switch (res >> 26) { 8411 case ALC880_HP_EVENT: 8412 alc883_M90V_speaker_automute(codec); 8413 break; 8414 case ALC880_MIC_EVENT: 8415 alc883_nb_mic_automute(codec); 8416 break; 8417 } 8418} 8419 8420static void alc883_mode2_inithook(struct hda_codec *codec) 8421{ 8422 alc883_M90V_speaker_automute(codec); 8423 alc883_nb_mic_automute(codec); 8424} 8425 8426static struct hda_verb alc888_asus_eee1601_verbs[] = { 8427 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8428 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8429 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8430 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8431 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8432 {0x20, AC_VERB_SET_COEF_INDEX, 0x0b}, 8433 {0x20, AC_VERB_SET_PROC_COEF, 0x0838}, 8434 /* enable unsolicited event */ 8435 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 8436 { } /* end */ 8437}; 8438 8439static void alc883_eee1601_speaker_automute(struct hda_codec *codec) 8440{ 8441 unsigned int present; 8442 unsigned char bits; 8443 8444 present = snd_hda_codec_read(codec, 0x14, 0, 8445 AC_VERB_GET_PIN_SENSE, 0) 8446 & AC_PINSENSE_PRESENCE; 8447 bits = present ? 0 : PIN_OUT; 8448 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 8449 bits); 8450} 8451 8452static void alc883_eee1601_unsol_event(struct hda_codec *codec, 8453 unsigned int res) 8454{ 8455 switch (res >> 26) { 8456 case ALC880_HP_EVENT: 8457 alc883_eee1601_speaker_automute(codec); 8458 break; 8459 } 8460} 8461 8462static void alc883_eee1601_inithook(struct hda_codec *codec) 8463{ 8464 alc883_eee1601_speaker_automute(codec); 8465} 8466 8467#ifdef CONFIG_SND_HDA_POWER_SAVE 8468#define alc883_loopbacks alc880_loopbacks 8469#endif 8470 8471/* pcm configuration: identiacal with ALC880 */ 8472#define alc883_pcm_analog_playback alc880_pcm_analog_playback 8473#define alc883_pcm_analog_capture alc880_pcm_analog_capture 8474#define alc883_pcm_analog_alt_capture alc880_pcm_analog_alt_capture 8475#define alc883_pcm_digital_playback alc880_pcm_digital_playback 8476#define alc883_pcm_digital_capture alc880_pcm_digital_capture 8477 8478/* 8479 * configuration and preset 8480 */ 8481static const char *alc883_models[ALC883_MODEL_LAST] = { 8482 [ALC883_3ST_2ch_DIG] = "3stack-dig", 8483 [ALC883_3ST_6ch_DIG] = "3stack-6ch-dig", 8484 [ALC883_3ST_6ch] = "3stack-6ch", 8485 [ALC883_6ST_DIG] = "6stack-dig", 8486 [ALC883_TARGA_DIG] = "targa-dig", 8487 [ALC883_TARGA_2ch_DIG] = "targa-2ch-dig", 8488 [ALC883_ACER] = "acer", 8489 [ALC883_ACER_ASPIRE] = "acer-aspire", 8490 [ALC888_ACER_ASPIRE_4930G] = "acer-aspire-4930g", 8491 [ALC883_MEDION] = "medion", 8492 [ALC883_MEDION_MD2] = "medion-md2", 8493 [ALC883_LAPTOP_EAPD] = "laptop-eapd", 8494 [ALC883_LENOVO_101E_2ch] = "lenovo-101e", 8495 [ALC883_LENOVO_NB0763] = "lenovo-nb0763", 8496 [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig", 8497 [ALC888_LENOVO_SKY] = "lenovo-sky", 8498 [ALC883_HAIER_W66] = "haier-w66", 8499 [ALC888_3ST_HP] = "3stack-hp", 8500 [ALC888_6ST_DELL] = "6stack-dell", 8501 [ALC883_MITAC] = "mitac", 8502 [ALC883_CLEVO_M720] = "clevo-m720", 8503 [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515", 8504 [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530", 8505 [ALC883_3ST_6ch_INTEL] = "3stack-6ch-intel", 8506 [ALC1200_ASUS_P5Q] = "asus-p5q", 8507 [ALC883_AUTO] = "auto", 8508}; 8509 8510static struct snd_pci_quirk alc883_cfg_tbl[] = { 8511 SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG), 8512 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE), 8513 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE), 8514 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE), 8515 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE), 8516 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE), 8517 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G", 8518 ALC888_ACER_ASPIRE_4930G), 8519 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G", 8520 ALC888_ACER_ASPIRE_4930G), 8521 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G", 8522 ALC888_ACER_ASPIRE_4930G), 8523 SND_PCI_QUIRK(0x1025, 0, "Acer laptop", ALC883_ACER), /* default Acer */ 8524 SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL), 8525 SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG), 8526 SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP), 8527 SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP), 8528 SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG), 8529 SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP), 8530 SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V), 8531 SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG), 8532 SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q), 8533 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601), 8534 SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG), 8535 SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG), 8536 SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC), 8537 SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC), 8538 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD), 8539 SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL), 8540 SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch), 8541 SND_PCI_QUIRK(0x1458, 0xa002, "MSI", ALC883_6ST_DIG), 8542 SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG), 8543 SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG), 8544 SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG), 8545 SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG), 8546 SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG), 8547 SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG), 8548 SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG), 8549 SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG), 8550 SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG), 8551 SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG), 8552 SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG), 8553 SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG), 8554 SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG), 8555 SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG), 8556 SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG), 8557 SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG), 8558 SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG), 8559 SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG), 8560 SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG), 8561 SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG), 8562 SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG), 8563 SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG), 8564 SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG), 8565 SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG), 8566 SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720), 8567 SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720), 8568 SND_PCI_QUIRK(0x1558, 0, "Clevo laptop", ALC883_LAPTOP_EAPD), 8569 SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch), 8570 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION), 8571 SND_PCI_QUIRK(0x1734, 0x1107, "FSC AMILO Xi2550", 8572 ALC883_FUJITSU_PI2515), 8573 SND_PCI_QUIRK(0x1734, 0x1108, "Fujitsu AMILO Pi2515", ALC883_FUJITSU_PI2515), 8574 SND_PCI_QUIRK(0x1734, 0x113d, "Fujitsu AMILO Xa3530", 8575 ALC888_FUJITSU_XA3530), 8576 SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch), 8577 SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763), 8578 SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763), 8579 SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763), 8580 SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY), 8581 SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2), 8582 SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG), 8583 SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG), 8584 SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66), 8585 SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL), 8586 SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL), 8587 SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC), 8588 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC883_3ST_6ch_INTEL), 8589 SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch), 8590 {} 8591}; 8592 8593static hda_nid_t alc1200_slave_dig_outs[] = { 8594 ALC883_DIGOUT_NID, 0, 8595}; 8596 8597static struct alc_config_preset alc883_presets[] = { 8598 [ALC883_3ST_2ch_DIG] = { 8599 .mixers = { alc883_3ST_2ch_mixer }, 8600 .init_verbs = { alc883_init_verbs }, 8601 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8602 .dac_nids = alc883_dac_nids, 8603 .dig_out_nid = ALC883_DIGOUT_NID, 8604 .dig_in_nid = ALC883_DIGIN_NID, 8605 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8606 .channel_mode = alc883_3ST_2ch_modes, 8607 .input_mux = &alc883_capture_source, 8608 }, 8609 [ALC883_3ST_6ch_DIG] = { 8610 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 8611 .init_verbs = { alc883_init_verbs }, 8612 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8613 .dac_nids = alc883_dac_nids, 8614 .dig_out_nid = ALC883_DIGOUT_NID, 8615 .dig_in_nid = ALC883_DIGIN_NID, 8616 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 8617 .channel_mode = alc883_3ST_6ch_modes, 8618 .need_dac_fix = 1, 8619 .input_mux = &alc883_capture_source, 8620 }, 8621 [ALC883_3ST_6ch] = { 8622 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 8623 .init_verbs = { alc883_init_verbs }, 8624 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8625 .dac_nids = alc883_dac_nids, 8626 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 8627 .channel_mode = alc883_3ST_6ch_modes, 8628 .need_dac_fix = 1, 8629 .input_mux = &alc883_capture_source, 8630 }, 8631 [ALC883_3ST_6ch_INTEL] = { 8632 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer }, 8633 .init_verbs = { alc883_init_verbs }, 8634 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8635 .dac_nids = alc883_dac_nids, 8636 .dig_out_nid = ALC883_DIGOUT_NID, 8637 .dig_in_nid = ALC883_DIGIN_NID, 8638 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes), 8639 .channel_mode = alc883_3ST_6ch_intel_modes, 8640 .need_dac_fix = 1, 8641 .input_mux = &alc883_3stack_6ch_intel, 8642 }, 8643 [ALC883_6ST_DIG] = { 8644 .mixers = { alc883_base_mixer, alc883_chmode_mixer }, 8645 .init_verbs = { alc883_init_verbs }, 8646 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8647 .dac_nids = alc883_dac_nids, 8648 .dig_out_nid = ALC883_DIGOUT_NID, 8649 .dig_in_nid = ALC883_DIGIN_NID, 8650 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes), 8651 .channel_mode = alc883_sixstack_modes, 8652 .input_mux = &alc883_capture_source, 8653 }, 8654 [ALC883_TARGA_DIG] = { 8655 .mixers = { alc883_tagra_mixer, alc883_chmode_mixer }, 8656 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs}, 8657 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8658 .dac_nids = alc883_dac_nids, 8659 .dig_out_nid = ALC883_DIGOUT_NID, 8660 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 8661 .channel_mode = alc883_3ST_6ch_modes, 8662 .need_dac_fix = 1, 8663 .input_mux = &alc883_capture_source, 8664 .unsol_event = alc883_tagra_unsol_event, 8665 .init_hook = alc883_tagra_automute, 8666 }, 8667 [ALC883_TARGA_2ch_DIG] = { 8668 .mixers = { alc883_tagra_2ch_mixer}, 8669 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs}, 8670 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8671 .dac_nids = alc883_dac_nids, 8672 .adc_nids = alc883_adc_nids_alt, 8673 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt), 8674 .dig_out_nid = ALC883_DIGOUT_NID, 8675 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8676 .channel_mode = alc883_3ST_2ch_modes, 8677 .input_mux = &alc883_capture_source, 8678 .unsol_event = alc883_tagra_unsol_event, 8679 .init_hook = alc883_tagra_automute, 8680 }, 8681 [ALC883_ACER] = { 8682 .mixers = { alc883_base_mixer }, 8683 /* On TravelMate laptops, GPIO 0 enables the internal speaker 8684 * and the headphone jack. Turn this on and rely on the 8685 * standard mute methods whenever the user wants to turn 8686 * these outputs off. 8687 */ 8688 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs }, 8689 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8690 .dac_nids = alc883_dac_nids, 8691 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8692 .channel_mode = alc883_3ST_2ch_modes, 8693 .input_mux = &alc883_capture_source, 8694 }, 8695 [ALC883_ACER_ASPIRE] = { 8696 .mixers = { alc883_acer_aspire_mixer }, 8697 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs }, 8698 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8699 .dac_nids = alc883_dac_nids, 8700 .dig_out_nid = ALC883_DIGOUT_NID, 8701 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8702 .channel_mode = alc883_3ST_2ch_modes, 8703 .input_mux = &alc883_capture_source, 8704 .unsol_event = alc883_acer_aspire_unsol_event, 8705 .init_hook = alc883_acer_aspire_automute, 8706 }, 8707 [ALC888_ACER_ASPIRE_4930G] = { 8708 .mixers = { alc888_base_mixer, 8709 alc883_chmode_mixer }, 8710 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs, 8711 alc888_acer_aspire_4930g_verbs }, 8712 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8713 .dac_nids = alc883_dac_nids, 8714 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev), 8715 .adc_nids = alc883_adc_nids_rev, 8716 .capsrc_nids = alc883_capsrc_nids_rev, 8717 .dig_out_nid = ALC883_DIGOUT_NID, 8718 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 8719 .channel_mode = alc883_3ST_6ch_modes, 8720 .need_dac_fix = 1, 8721 .num_mux_defs = 8722 ARRAY_SIZE(alc888_2_capture_sources), 8723 .input_mux = alc888_2_capture_sources, 8724 .unsol_event = alc888_acer_aspire_4930g_unsol_event, 8725 .init_hook = alc888_acer_aspire_4930g_automute, 8726 }, 8727 [ALC883_MEDION] = { 8728 .mixers = { alc883_fivestack_mixer, 8729 alc883_chmode_mixer }, 8730 .init_verbs = { alc883_init_verbs, 8731 alc883_medion_eapd_verbs }, 8732 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8733 .dac_nids = alc883_dac_nids, 8734 .adc_nids = alc883_adc_nids_alt, 8735 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt), 8736 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes), 8737 .channel_mode = alc883_sixstack_modes, 8738 .input_mux = &alc883_capture_source, 8739 }, 8740 [ALC883_MEDION_MD2] = { 8741 .mixers = { alc883_medion_md2_mixer}, 8742 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs}, 8743 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8744 .dac_nids = alc883_dac_nids, 8745 .dig_out_nid = ALC883_DIGOUT_NID, 8746 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8747 .channel_mode = alc883_3ST_2ch_modes, 8748 .input_mux = &alc883_capture_source, 8749 .unsol_event = alc883_medion_md2_unsol_event, 8750 .init_hook = alc883_medion_md2_automute, 8751 }, 8752 [ALC883_LAPTOP_EAPD] = { 8753 .mixers = { alc883_base_mixer }, 8754 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs }, 8755 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8756 .dac_nids = alc883_dac_nids, 8757 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8758 .channel_mode = alc883_3ST_2ch_modes, 8759 .input_mux = &alc883_capture_source, 8760 }, 8761 [ALC883_CLEVO_M720] = { 8762 .mixers = { alc883_clevo_m720_mixer }, 8763 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs }, 8764 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8765 .dac_nids = alc883_dac_nids, 8766 .dig_out_nid = ALC883_DIGOUT_NID, 8767 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8768 .channel_mode = alc883_3ST_2ch_modes, 8769 .input_mux = &alc883_capture_source, 8770 .unsol_event = alc883_clevo_m720_unsol_event, 8771 .init_hook = alc883_clevo_m720_automute, 8772 }, 8773 [ALC883_LENOVO_101E_2ch] = { 8774 .mixers = { alc883_lenovo_101e_2ch_mixer}, 8775 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs}, 8776 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8777 .dac_nids = alc883_dac_nids, 8778 .adc_nids = alc883_adc_nids_alt, 8779 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt), 8780 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8781 .channel_mode = alc883_3ST_2ch_modes, 8782 .input_mux = &alc883_lenovo_101e_capture_source, 8783 .unsol_event = alc883_lenovo_101e_unsol_event, 8784 .init_hook = alc883_lenovo_101e_all_automute, 8785 }, 8786 [ALC883_LENOVO_NB0763] = { 8787 .mixers = { alc883_lenovo_nb0763_mixer }, 8788 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs}, 8789 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8790 .dac_nids = alc883_dac_nids, 8791 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8792 .channel_mode = alc883_3ST_2ch_modes, 8793 .need_dac_fix = 1, 8794 .input_mux = &alc883_lenovo_nb0763_capture_source, 8795 .unsol_event = alc883_medion_md2_unsol_event, 8796 .init_hook = alc883_medion_md2_automute, 8797 }, 8798 [ALC888_LENOVO_MS7195_DIG] = { 8799 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 8800 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs}, 8801 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8802 .dac_nids = alc883_dac_nids, 8803 .dig_out_nid = ALC883_DIGOUT_NID, 8804 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 8805 .channel_mode = alc883_3ST_6ch_modes, 8806 .need_dac_fix = 1, 8807 .input_mux = &alc883_capture_source, 8808 .unsol_event = alc883_lenovo_ms7195_unsol_event, 8809 .init_hook = alc888_lenovo_ms7195_front_automute, 8810 }, 8811 [ALC883_HAIER_W66] = { 8812 .mixers = { alc883_tagra_2ch_mixer}, 8813 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs}, 8814 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8815 .dac_nids = alc883_dac_nids, 8816 .dig_out_nid = ALC883_DIGOUT_NID, 8817 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8818 .channel_mode = alc883_3ST_2ch_modes, 8819 .input_mux = &alc883_capture_source, 8820 .unsol_event = alc883_haier_w66_unsol_event, 8821 .init_hook = alc883_haier_w66_automute, 8822 }, 8823 [ALC888_3ST_HP] = { 8824 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 8825 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs }, 8826 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8827 .dac_nids = alc883_dac_nids, 8828 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes), 8829 .channel_mode = alc888_3st_hp_modes, 8830 .need_dac_fix = 1, 8831 .input_mux = &alc883_capture_source, 8832 }, 8833 [ALC888_6ST_DELL] = { 8834 .mixers = { alc883_base_mixer, alc883_chmode_mixer }, 8835 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs }, 8836 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8837 .dac_nids = alc883_dac_nids, 8838 .dig_out_nid = ALC883_DIGOUT_NID, 8839 .dig_in_nid = ALC883_DIGIN_NID, 8840 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes), 8841 .channel_mode = alc883_sixstack_modes, 8842 .input_mux = &alc883_capture_source, 8843 .unsol_event = alc888_6st_dell_unsol_event, 8844 .init_hook = alc888_6st_dell_front_automute, 8845 }, 8846 [ALC883_MITAC] = { 8847 .mixers = { alc883_mitac_mixer }, 8848 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs }, 8849 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8850 .dac_nids = alc883_dac_nids, 8851 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8852 .channel_mode = alc883_3ST_2ch_modes, 8853 .input_mux = &alc883_capture_source, 8854 .unsol_event = alc883_mitac_unsol_event, 8855 .init_hook = alc883_mitac_automute, 8856 }, 8857 [ALC883_FUJITSU_PI2515] = { 8858 .mixers = { alc883_2ch_fujitsu_pi2515_mixer }, 8859 .init_verbs = { alc883_init_verbs, 8860 alc883_2ch_fujitsu_pi2515_verbs}, 8861 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8862 .dac_nids = alc883_dac_nids, 8863 .dig_out_nid = ALC883_DIGOUT_NID, 8864 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8865 .channel_mode = alc883_3ST_2ch_modes, 8866 .input_mux = &alc883_fujitsu_pi2515_capture_source, 8867 .unsol_event = alc883_2ch_fujitsu_pi2515_unsol_event, 8868 .init_hook = alc883_2ch_fujitsu_pi2515_automute, 8869 }, 8870 [ALC888_FUJITSU_XA3530] = { 8871 .mixers = { alc888_base_mixer, alc883_chmode_mixer }, 8872 .init_verbs = { alc883_init_verbs, 8873 alc888_fujitsu_xa3530_verbs }, 8874 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8875 .dac_nids = alc883_dac_nids, 8876 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev), 8877 .adc_nids = alc883_adc_nids_rev, 8878 .capsrc_nids = alc883_capsrc_nids_rev, 8879 .dig_out_nid = ALC883_DIGOUT_NID, 8880 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes), 8881 .channel_mode = alc888_4ST_8ch_intel_modes, 8882 .num_mux_defs = 8883 ARRAY_SIZE(alc888_2_capture_sources), 8884 .input_mux = alc888_2_capture_sources, 8885 .unsol_event = alc888_fujitsu_xa3530_unsol_event, 8886 .init_hook = alc888_fujitsu_xa3530_automute, 8887 }, 8888 [ALC888_LENOVO_SKY] = { 8889 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer }, 8890 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs}, 8891 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8892 .dac_nids = alc883_dac_nids, 8893 .dig_out_nid = ALC883_DIGOUT_NID, 8894 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes), 8895 .channel_mode = alc883_sixstack_modes, 8896 .need_dac_fix = 1, 8897 .input_mux = &alc883_lenovo_sky_capture_source, 8898 .unsol_event = alc883_lenovo_sky_unsol_event, 8899 .init_hook = alc888_lenovo_sky_front_automute, 8900 }, 8901 [ALC888_ASUS_M90V] = { 8902 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 8903 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs }, 8904 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8905 .dac_nids = alc883_dac_nids, 8906 .dig_out_nid = ALC883_DIGOUT_NID, 8907 .dig_in_nid = ALC883_DIGIN_NID, 8908 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 8909 .channel_mode = alc883_3ST_6ch_modes, 8910 .need_dac_fix = 1, 8911 .input_mux = &alc883_fujitsu_pi2515_capture_source, 8912 .unsol_event = alc883_mode2_unsol_event, 8913 .init_hook = alc883_mode2_inithook, 8914 }, 8915 [ALC888_ASUS_EEE1601] = { 8916 .mixers = { alc883_asus_eee1601_mixer }, 8917 .cap_mixer = alc883_asus_eee1601_cap_mixer, 8918 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs }, 8919 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8920 .dac_nids = alc883_dac_nids, 8921 .dig_out_nid = ALC883_DIGOUT_NID, 8922 .dig_in_nid = ALC883_DIGIN_NID, 8923 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8924 .channel_mode = alc883_3ST_2ch_modes, 8925 .need_dac_fix = 1, 8926 .input_mux = &alc883_asus_eee1601_capture_source, 8927 .unsol_event = alc883_eee1601_unsol_event, 8928 .init_hook = alc883_eee1601_inithook, 8929 }, 8930 [ALC1200_ASUS_P5Q] = { 8931 .mixers = { alc883_base_mixer, alc883_chmode_mixer }, 8932 .init_verbs = { alc883_init_verbs }, 8933 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8934 .dac_nids = alc883_dac_nids, 8935 .dig_out_nid = ALC1200_DIGOUT_NID, 8936 .dig_in_nid = ALC883_DIGIN_NID, 8937 .slave_dig_outs = alc1200_slave_dig_outs, 8938 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes), 8939 .channel_mode = alc883_sixstack_modes, 8940 .input_mux = &alc883_capture_source, 8941 }, 8942}; 8943 8944 8945/* 8946 * BIOS auto configuration 8947 */ 8948static void alc883_auto_set_output_and_unmute(struct hda_codec *codec, 8949 hda_nid_t nid, int pin_type, 8950 int dac_idx) 8951{ 8952 /* set as output */ 8953 struct alc_spec *spec = codec->spec; 8954 int idx; 8955 8956 alc_set_pin_output(codec, nid, pin_type); 8957 if (spec->multiout.dac_nids[dac_idx] == 0x25) 8958 idx = 4; 8959 else 8960 idx = spec->multiout.dac_nids[dac_idx] - 2; 8961 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx); 8962 8963} 8964 8965static void alc883_auto_init_multi_out(struct hda_codec *codec) 8966{ 8967 struct alc_spec *spec = codec->spec; 8968 int i; 8969 8970 alc_subsystem_id(codec, 0x15, 0x1b, 0x14); 8971 for (i = 0; i <= HDA_SIDE; i++) { 8972 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 8973 int pin_type = get_pin_type(spec->autocfg.line_out_type); 8974 if (nid) 8975 alc883_auto_set_output_and_unmute(codec, nid, pin_type, 8976 i); 8977 } 8978} 8979 8980static void alc883_auto_init_hp_out(struct hda_codec *codec) 8981{ 8982 struct alc_spec *spec = codec->spec; 8983 hda_nid_t pin; 8984 8985 pin = spec->autocfg.hp_pins[0]; 8986 if (pin) /* connect to front */ 8987 /* use dac 0 */ 8988 alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 8989 pin = spec->autocfg.speaker_pins[0]; 8990 if (pin) 8991 alc883_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 8992} 8993 8994#define alc883_is_input_pin(nid) alc880_is_input_pin(nid) 8995#define ALC883_PIN_CD_NID ALC880_PIN_CD_NID 8996 8997static void alc883_auto_init_analog_input(struct hda_codec *codec) 8998{ 8999 struct alc_spec *spec = codec->spec; 9000 int i; 9001 9002 for (i = 0; i < AUTO_PIN_LAST; i++) { 9003 hda_nid_t nid = spec->autocfg.input_pins[i]; 9004 if (alc883_is_input_pin(nid)) { 9005 snd_hda_codec_write(codec, nid, 0, 9006 AC_VERB_SET_PIN_WIDGET_CONTROL, 9007 (i <= AUTO_PIN_FRONT_MIC ? 9008 PIN_VREF80 : PIN_IN)); 9009 if (nid != ALC883_PIN_CD_NID) 9010 snd_hda_codec_write(codec, nid, 0, 9011 AC_VERB_SET_AMP_GAIN_MUTE, 9012 AMP_OUT_MUTE); 9013 } 9014 } 9015} 9016 9017#define alc883_auto_init_input_src alc882_auto_init_input_src 9018 9019/* almost identical with ALC880 parser... */ 9020static int alc883_parse_auto_config(struct hda_codec *codec) 9021{ 9022 struct alc_spec *spec = codec->spec; 9023 int err = alc880_parse_auto_config(codec); 9024 struct auto_pin_cfg *cfg = &spec->autocfg; 9025 int i; 9026 9027 if (err < 0) 9028 return err; 9029 else if (!err) 9030 return 0; /* no config found */ 9031 9032 err = alc_auto_add_mic_boost(codec); 9033 if (err < 0) 9034 return err; 9035 9036 /* hack - override the init verbs */ 9037 spec->init_verbs[0] = alc883_auto_init_verbs; 9038 9039 /* setup input_mux for ALC889 */ 9040 if (codec->vendor_id == 0x10ec0889) { 9041 /* digital-mic input pin is excluded in alc880_auto_create..() 9042 * because it's under 0x18 9043 */ 9044 if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 || 9045 cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) { 9046 struct hda_input_mux *imux = &spec->private_imux[0]; 9047 for (i = 1; i < 3; i++) 9048 memcpy(&spec->private_imux[i], 9049 &spec->private_imux[0], 9050 sizeof(spec->private_imux[0])); 9051 imux->items[imux->num_items].label = "Int DMic"; 9052 imux->items[imux->num_items].index = 0x0b; 9053 imux->num_items++; 9054 spec->num_mux_defs = 3; 9055 spec->input_mux = spec->private_imux; 9056 } 9057 } 9058 9059 return 1; /* config found */ 9060} 9061 9062/* additional initialization for auto-configuration model */ 9063static void alc883_auto_init(struct hda_codec *codec) 9064{ 9065 struct alc_spec *spec = codec->spec; 9066 alc883_auto_init_multi_out(codec); 9067 alc883_auto_init_hp_out(codec); 9068 alc883_auto_init_analog_input(codec); 9069 alc883_auto_init_input_src(codec); 9070 if (spec->unsol_event) 9071 alc_inithook(codec); 9072} 9073 9074static int patch_alc883(struct hda_codec *codec) 9075{ 9076 struct alc_spec *spec; 9077 int err, board_config; 9078 9079 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 9080 if (spec == NULL) 9081 return -ENOMEM; 9082 9083 codec->spec = spec; 9084 9085 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 9086 9087 board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST, 9088 alc883_models, 9089 alc883_cfg_tbl); 9090 if (board_config < 0) { 9091 printk(KERN_INFO "hda_codec: Unknown model for ALC883, " 9092 "trying auto-probe from BIOS...\n"); 9093 board_config = ALC883_AUTO; 9094 } 9095 9096 if (board_config == ALC883_AUTO) { 9097 /* automatic parse from the BIOS config */ 9098 err = alc883_parse_auto_config(codec); 9099 if (err < 0) { 9100 alc_free(codec); 9101 return err; 9102 } else if (!err) { 9103 printk(KERN_INFO 9104 "hda_codec: Cannot set up configuration " 9105 "from BIOS. Using base mode...\n"); 9106 board_config = ALC883_3ST_2ch_DIG; 9107 } 9108 } 9109 9110 err = snd_hda_attach_beep_device(codec, 0x1); 9111 if (err < 0) { 9112 alc_free(codec); 9113 return err; 9114 } 9115 9116 if (board_config != ALC883_AUTO) 9117 setup_preset(spec, &alc883_presets[board_config]); 9118 9119 switch (codec->vendor_id) { 9120 case 0x10ec0888: 9121 if (codec->revision_id == 0x100101) { 9122 spec->stream_name_analog = "ALC1200 Analog"; 9123 spec->stream_name_digital = "ALC1200 Digital"; 9124 } else { 9125 spec->stream_name_analog = "ALC888 Analog"; 9126 spec->stream_name_digital = "ALC888 Digital"; 9127 } 9128 if (!spec->num_adc_nids) { 9129 spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids); 9130 spec->adc_nids = alc883_adc_nids; 9131 } 9132 if (!spec->capsrc_nids) 9133 spec->capsrc_nids = alc883_capsrc_nids; 9134 spec->capture_style = CAPT_MIX; /* matrix-style capture */ 9135 break; 9136 case 0x10ec0889: 9137 spec->stream_name_analog = "ALC889 Analog"; 9138 spec->stream_name_digital = "ALC889 Digital"; 9139 if (!spec->num_adc_nids) { 9140 spec->num_adc_nids = ARRAY_SIZE(alc889_adc_nids); 9141 spec->adc_nids = alc889_adc_nids; 9142 } 9143 if (!spec->capsrc_nids) 9144 spec->capsrc_nids = alc889_capsrc_nids; 9145 spec->capture_style = CAPT_1MUX_MIX; /* 1mux/Nmix-style 9146 capture */ 9147 break; 9148 default: 9149 spec->stream_name_analog = "ALC883 Analog"; 9150 spec->stream_name_digital = "ALC883 Digital"; 9151 if (!spec->num_adc_nids) { 9152 spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids); 9153 spec->adc_nids = alc883_adc_nids; 9154 } 9155 if (!spec->capsrc_nids) 9156 spec->capsrc_nids = alc883_capsrc_nids; 9157 spec->capture_style = CAPT_MIX; /* matrix-style capture */ 9158 break; 9159 } 9160 9161 spec->stream_analog_playback = &alc883_pcm_analog_playback; 9162 spec->stream_analog_capture = &alc883_pcm_analog_capture; 9163 spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture; 9164 9165 spec->stream_digital_playback = &alc883_pcm_digital_playback; 9166 spec->stream_digital_capture = &alc883_pcm_digital_capture; 9167 9168 if (!spec->cap_mixer) 9169 set_capture_mixer(spec); 9170 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 9171 9172 spec->vmaster_nid = 0x0c; 9173 9174 codec->patch_ops = alc_patch_ops; 9175 if (board_config == ALC883_AUTO) 9176 spec->init_hook = alc883_auto_init; 9177 9178#ifdef CONFIG_SND_HDA_POWER_SAVE 9179 if (!spec->loopback.amplist) 9180 spec->loopback.amplist = alc883_loopbacks; 9181#endif 9182 codec->proc_widget_hook = print_realtek_coef; 9183 9184 return 0; 9185} 9186 9187/* 9188 * ALC262 support 9189 */ 9190 9191#define ALC262_DIGOUT_NID ALC880_DIGOUT_NID 9192#define ALC262_DIGIN_NID ALC880_DIGIN_NID 9193 9194#define alc262_dac_nids alc260_dac_nids 9195#define alc262_adc_nids alc882_adc_nids 9196#define alc262_adc_nids_alt alc882_adc_nids_alt 9197#define alc262_capsrc_nids alc882_capsrc_nids 9198#define alc262_capsrc_nids_alt alc882_capsrc_nids_alt 9199 9200#define alc262_modes alc260_modes 9201#define alc262_capture_source alc882_capture_source 9202 9203static hda_nid_t alc262_dmic_adc_nids[1] = { 9204 /* ADC0 */ 9205 0x09 9206}; 9207 9208static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 }; 9209 9210static struct snd_kcontrol_new alc262_base_mixer[] = { 9211 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9212 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 9213 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 9214 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 9215 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 9216 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 9217 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9218 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9219 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 9220 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 9221 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 9222 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 9223 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT), 9224 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 9225 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 9226 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT), 9227 { } /* end */ 9228}; 9229 9230static struct snd_kcontrol_new alc262_hippo1_mixer[] = { 9231 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9232 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 9233 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 9234 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 9235 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 9236 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 9237 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9238 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9239 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 9240 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 9241 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 9242 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 9243 /*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/ 9244 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 9245 { } /* end */ 9246}; 9247 9248/* update HP, line and mono-out pins according to the master switch */ 9249static void alc262_hp_master_update(struct hda_codec *codec) 9250{ 9251 struct alc_spec *spec = codec->spec; 9252 int val = spec->master_sw; 9253 9254 /* HP & line-out */ 9255 snd_hda_codec_write_cache(codec, 0x1b, 0, 9256 AC_VERB_SET_PIN_WIDGET_CONTROL, 9257 val ? PIN_HP : 0); 9258 snd_hda_codec_write_cache(codec, 0x15, 0, 9259 AC_VERB_SET_PIN_WIDGET_CONTROL, 9260 val ? PIN_HP : 0); 9261 /* mono (speaker) depending on the HP jack sense */ 9262 val = val && !spec->jack_present; 9263 snd_hda_codec_write_cache(codec, 0x16, 0, 9264 AC_VERB_SET_PIN_WIDGET_CONTROL, 9265 val ? PIN_OUT : 0); 9266} 9267 9268static void alc262_hp_bpc_automute(struct hda_codec *codec) 9269{ 9270 struct alc_spec *spec = codec->spec; 9271 unsigned int presence; 9272 presence = snd_hda_codec_read(codec, 0x1b, 0, 9273 AC_VERB_GET_PIN_SENSE, 0); 9274 spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE); 9275 alc262_hp_master_update(codec); 9276} 9277 9278static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res) 9279{ 9280 if ((res >> 26) != ALC880_HP_EVENT) 9281 return; 9282 alc262_hp_bpc_automute(codec); 9283} 9284 9285static void alc262_hp_wildwest_automute(struct hda_codec *codec) 9286{ 9287 struct alc_spec *spec = codec->spec; 9288 unsigned int presence; 9289 presence = snd_hda_codec_read(codec, 0x15, 0, 9290 AC_VERB_GET_PIN_SENSE, 0); 9291 spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE); 9292 alc262_hp_master_update(codec); 9293} 9294 9295static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec, 9296 unsigned int res) 9297{ 9298 if ((res >> 26) != ALC880_HP_EVENT) 9299 return; 9300 alc262_hp_wildwest_automute(codec); 9301} 9302 9303static int alc262_hp_master_sw_get(struct snd_kcontrol *kcontrol, 9304 struct snd_ctl_elem_value *ucontrol) 9305{ 9306 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 9307 struct alc_spec *spec = codec->spec; 9308 *ucontrol->value.integer.value = spec->master_sw; 9309 return 0; 9310} 9311 9312static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol, 9313 struct snd_ctl_elem_value *ucontrol) 9314{ 9315 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 9316 struct alc_spec *spec = codec->spec; 9317 int val = !!*ucontrol->value.integer.value; 9318 9319 if (val == spec->master_sw) 9320 return 0; 9321 spec->master_sw = val; 9322 alc262_hp_master_update(codec); 9323 return 1; 9324} 9325 9326static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = { 9327 { 9328 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 9329 .name = "Master Playback Switch", 9330 .info = snd_ctl_boolean_mono_info, 9331 .get = alc262_hp_master_sw_get, 9332 .put = alc262_hp_master_sw_put, 9333 }, 9334 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9335 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT), 9336 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 9337 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0, 9338 HDA_OUTPUT), 9339 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0, 9340 HDA_OUTPUT), 9341 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9342 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9343 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 9344 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 9345 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 9346 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 9347 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 9348 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 9349 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 9350 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 9351 HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT), 9352 HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT), 9353 { } /* end */ 9354}; 9355 9356static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = { 9357 { 9358 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 9359 .name = "Master Playback Switch", 9360 .info = snd_ctl_boolean_mono_info, 9361 .get = alc262_hp_master_sw_get, 9362 .put = alc262_hp_master_sw_put, 9363 }, 9364 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9365 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 9366 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 9367 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 9368 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0, 9369 HDA_OUTPUT), 9370 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0, 9371 HDA_OUTPUT), 9372 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT), 9373 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT), 9374 HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT), 9375 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT), 9376 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT), 9377 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 9378 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 9379 { } /* end */ 9380}; 9381 9382static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = { 9383 HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9384 HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9385 HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT), 9386 { } /* end */ 9387}; 9388 9389/* mute/unmute internal speaker according to the hp jack and mute state */ 9390static void alc262_hp_t5735_automute(struct hda_codec *codec, int force) 9391{ 9392 struct alc_spec *spec = codec->spec; 9393 9394 if (force || !spec->sense_updated) { 9395 unsigned int present; 9396 present = snd_hda_codec_read(codec, 0x15, 0, 9397 AC_VERB_GET_PIN_SENSE, 0); 9398 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0; 9399 spec->sense_updated = 1; 9400 } 9401 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, HDA_AMP_MUTE, 9402 spec->jack_present ? HDA_AMP_MUTE : 0); 9403} 9404 9405static void alc262_hp_t5735_unsol_event(struct hda_codec *codec, 9406 unsigned int res) 9407{ 9408 if ((res >> 26) != ALC880_HP_EVENT) 9409 return; 9410 alc262_hp_t5735_automute(codec, 1); 9411} 9412 9413static void alc262_hp_t5735_init_hook(struct hda_codec *codec) 9414{ 9415 alc262_hp_t5735_automute(codec, 1); 9416} 9417 9418static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = { 9419 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9420 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 9421 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 9422 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 9423 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9424 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9425 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 9426 { } /* end */ 9427}; 9428 9429static struct hda_verb alc262_hp_t5735_verbs[] = { 9430 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9431 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9432 9433 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9434 { } 9435}; 9436 9437static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = { 9438 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9439 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 9440 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT), 9441 HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT), 9442 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT), 9443 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT), 9444 { } /* end */ 9445}; 9446 9447static struct hda_verb alc262_hp_rp5700_verbs[] = { 9448 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 9449 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 9450 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9451 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9452 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 9453 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 9454 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 9455 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 9456 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))}, 9457 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))}, 9458 {} 9459}; 9460 9461static struct hda_input_mux alc262_hp_rp5700_capture_source = { 9462 .num_items = 1, 9463 .items = { 9464 { "Line", 0x1 }, 9465 }, 9466}; 9467 9468/* bind hp and internal speaker mute (with plug check) */ 9469static int alc262_sony_master_sw_put(struct snd_kcontrol *kcontrol, 9470 struct snd_ctl_elem_value *ucontrol) 9471{ 9472 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 9473 long *valp = ucontrol->value.integer.value; 9474 int change; 9475 9476 /* change hp mute */ 9477 change = snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0, 9478 HDA_AMP_MUTE, 9479 valp[0] ? 0 : HDA_AMP_MUTE); 9480 change |= snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0, 9481 HDA_AMP_MUTE, 9482 valp[1] ? 0 : HDA_AMP_MUTE); 9483 if (change) { 9484 /* change speaker according to HP jack state */ 9485 struct alc_spec *spec = codec->spec; 9486 unsigned int mute; 9487 if (spec->jack_present) 9488 mute = HDA_AMP_MUTE; 9489 else 9490 mute = snd_hda_codec_amp_read(codec, 0x15, 0, 9491 HDA_OUTPUT, 0); 9492 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9493 HDA_AMP_MUTE, mute); 9494 } 9495 return change; 9496} 9497 9498static struct snd_kcontrol_new alc262_sony_mixer[] = { 9499 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9500 { 9501 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 9502 .name = "Master Playback Switch", 9503 .info = snd_hda_mixer_amp_switch_info, 9504 .get = snd_hda_mixer_amp_switch_get, 9505 .put = alc262_sony_master_sw_put, 9506 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT), 9507 }, 9508 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9509 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9510 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 9511 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 9512 { } /* end */ 9513}; 9514 9515static struct snd_kcontrol_new alc262_benq_t31_mixer[] = { 9516 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9517 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 9518 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 9519 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9520 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9521 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 9522 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 9523 { } /* end */ 9524}; 9525 9526static struct snd_kcontrol_new alc262_tyan_mixer[] = { 9527 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9528 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT), 9529 HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT), 9530 HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT), 9531 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 9532 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 9533 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9534 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9535 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 9536 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 9537 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 9538 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 9539 { } /* end */ 9540}; 9541 9542static struct hda_verb alc262_tyan_verbs[] = { 9543 /* Headphone automute */ 9544 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 9545 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9546 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 9547 9548 /* P11 AUX_IN, white 4-pin connector */ 9549 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 9550 {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1}, 9551 {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93}, 9552 {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19}, 9553 9554 {} 9555}; 9556 9557/* unsolicited event for HP jack sensing */ 9558static void alc262_tyan_automute(struct hda_codec *codec) 9559{ 9560 unsigned int mute; 9561 unsigned int present; 9562 9563 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0); 9564 present = snd_hda_codec_read(codec, 0x1b, 0, 9565 AC_VERB_GET_PIN_SENSE, 0); 9566 present = (present & 0x80000000) != 0; 9567 if (present) { 9568 /* mute line output on ATX panel */ 9569 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 9570 HDA_AMP_MUTE, HDA_AMP_MUTE); 9571 } else { 9572 /* unmute line output if necessary */ 9573 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0); 9574 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 9575 HDA_AMP_MUTE, mute); 9576 } 9577} 9578 9579static void alc262_tyan_unsol_event(struct hda_codec *codec, 9580 unsigned int res) 9581{ 9582 if ((res >> 26) != ALC880_HP_EVENT) 9583 return; 9584 alc262_tyan_automute(codec); 9585} 9586 9587#define alc262_capture_mixer alc882_capture_mixer 9588#define alc262_capture_alt_mixer alc882_capture_alt_mixer 9589 9590/* 9591 * generic initialization of ADC, input mixers and output mixers 9592 */ 9593static struct hda_verb alc262_init_verbs[] = { 9594 /* 9595 * Unmute ADC0-2 and set the default input to mic-in 9596 */ 9597 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 9598 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9599 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 9600 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9601 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 9602 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9603 9604 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 9605 * mixer widget 9606 * Note: PASD motherboards uses the Line In 2 as the input for 9607 * front panel mic (mic 2) 9608 */ 9609 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 9610 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 9611 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 9612 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 9613 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 9614 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 9615 9616 /* 9617 * Set up output mixers (0x0c - 0x0e) 9618 */ 9619 /* set vol=0 to output mixers */ 9620 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9621 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9622 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9623 /* set up input amps for analog loopback */ 9624 /* Amp Indices: DAC = 0, mixer = 1 */ 9625 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9626 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9627 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9628 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9629 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9630 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9631 9632 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 9633 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 9634 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 9635 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 9636 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 9637 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 9638 9639 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 9640 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 9641 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 9642 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 9643 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 9644 9645 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 9646 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 9647 9648 /* FIXME: use matrix-type input source selection */ 9649 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 9650 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 9651 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 9652 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 9653 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 9654 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 9655 /* Input mixer2 */ 9656 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 9657 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 9658 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 9659 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 9660 /* Input mixer3 */ 9661 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 9662 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 9663 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 9664 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 9665 9666 { } 9667}; 9668 9669static struct hda_verb alc262_eapd_verbs[] = { 9670 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 9671 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 9672 { } 9673}; 9674 9675static struct hda_verb alc262_hippo_unsol_verbs[] = { 9676 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 9677 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9678 {} 9679}; 9680 9681static struct hda_verb alc262_hippo1_unsol_verbs[] = { 9682 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 9683 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 9684 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 9685 9686 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 9687 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9688 {} 9689}; 9690 9691static struct hda_verb alc262_sony_unsol_verbs[] = { 9692 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 9693 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 9694 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, // Front Mic 9695 9696 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 9697 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9698 {} 9699}; 9700 9701static struct hda_input_mux alc262_dmic_capture_source = { 9702 .num_items = 2, 9703 .items = { 9704 { "Int DMic", 0x9 }, 9705 { "Mic", 0x0 }, 9706 }, 9707}; 9708 9709static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = { 9710 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9711 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 9712 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 9713 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9714 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9715 { } /* end */ 9716}; 9717 9718static struct hda_verb alc262_toshiba_s06_verbs[] = { 9719 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 9720 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9721 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9722 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 9723 {0x22, AC_VERB_SET_CONNECT_SEL, 0x09}, 9724 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 9725 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 9726 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 9727 {} 9728}; 9729 9730static void alc262_dmic_automute(struct hda_codec *codec) 9731{ 9732 unsigned int present; 9733 9734 present = snd_hda_codec_read(codec, 0x18, 0, 9735 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 9736 snd_hda_codec_write(codec, 0x22, 0, 9737 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x09); 9738} 9739 9740/* toggle speaker-output according to the hp-jack state */ 9741static void alc262_toshiba_s06_speaker_automute(struct hda_codec *codec) 9742{ 9743 unsigned int present; 9744 unsigned char bits; 9745 9746 present = snd_hda_codec_read(codec, 0x15, 0, 9747 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 9748 bits = present ? 0 : PIN_OUT; 9749 snd_hda_codec_write(codec, 0x14, 0, 9750 AC_VERB_SET_PIN_WIDGET_CONTROL, bits); 9751} 9752 9753 9754 9755/* unsolicited event for HP jack sensing */ 9756static void alc262_toshiba_s06_unsol_event(struct hda_codec *codec, 9757 unsigned int res) 9758{ 9759 if ((res >> 26) == ALC880_HP_EVENT) 9760 alc262_toshiba_s06_speaker_automute(codec); 9761 if ((res >> 26) == ALC880_MIC_EVENT) 9762 alc262_dmic_automute(codec); 9763 9764} 9765 9766static void alc262_toshiba_s06_init_hook(struct hda_codec *codec) 9767{ 9768 alc262_toshiba_s06_speaker_automute(codec); 9769 alc262_dmic_automute(codec); 9770} 9771 9772/* mute/unmute internal speaker according to the hp jack and mute state */ 9773static void alc262_hippo_automute(struct hda_codec *codec) 9774{ 9775 struct alc_spec *spec = codec->spec; 9776 unsigned int mute; 9777 unsigned int present; 9778 9779 /* need to execute and sync at first */ 9780 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0); 9781 present = snd_hda_codec_read(codec, 0x15, 0, 9782 AC_VERB_GET_PIN_SENSE, 0); 9783 spec->jack_present = (present & 0x80000000) != 0; 9784 if (spec->jack_present) { 9785 /* mute internal speaker */ 9786 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9787 HDA_AMP_MUTE, HDA_AMP_MUTE); 9788 } else { 9789 /* unmute internal speaker if necessary */ 9790 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0); 9791 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9792 HDA_AMP_MUTE, mute); 9793 } 9794} 9795 9796/* unsolicited event for HP jack sensing */ 9797static void alc262_hippo_unsol_event(struct hda_codec *codec, 9798 unsigned int res) 9799{ 9800 if ((res >> 26) != ALC880_HP_EVENT) 9801 return; 9802 alc262_hippo_automute(codec); 9803} 9804 9805static void alc262_hippo1_automute(struct hda_codec *codec) 9806{ 9807 unsigned int mute; 9808 unsigned int present; 9809 9810 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0); 9811 present = snd_hda_codec_read(codec, 0x1b, 0, 9812 AC_VERB_GET_PIN_SENSE, 0); 9813 present = (present & 0x80000000) != 0; 9814 if (present) { 9815 /* mute internal speaker */ 9816 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9817 HDA_AMP_MUTE, HDA_AMP_MUTE); 9818 } else { 9819 /* unmute internal speaker if necessary */ 9820 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0); 9821 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9822 HDA_AMP_MUTE, mute); 9823 } 9824} 9825 9826/* unsolicited event for HP jack sensing */ 9827static void alc262_hippo1_unsol_event(struct hda_codec *codec, 9828 unsigned int res) 9829{ 9830 if ((res >> 26) != ALC880_HP_EVENT) 9831 return; 9832 alc262_hippo1_automute(codec); 9833} 9834 9835/* 9836 * nec model 9837 * 0x15 = headphone 9838 * 0x16 = internal speaker 9839 * 0x18 = external mic 9840 */ 9841 9842static struct snd_kcontrol_new alc262_nec_mixer[] = { 9843 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 9844 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT), 9845 9846 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9847 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9848 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 9849 9850 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 9851 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 9852 { } /* end */ 9853}; 9854 9855static struct hda_verb alc262_nec_verbs[] = { 9856 /* Unmute Speaker */ 9857 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 9858 9859 /* Headphone */ 9860 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 9861 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9862 9863 /* External mic to headphone */ 9864 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9865 /* External mic to speaker */ 9866 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9867 {} 9868}; 9869 9870/* 9871 * fujitsu model 9872 * 0x14 = headphone/spdif-out, 0x15 = internal speaker, 9873 * 0x1b = port replicator headphone out 9874 */ 9875 9876#define ALC_HP_EVENT 0x37 9877 9878static struct hda_verb alc262_fujitsu_unsol_verbs[] = { 9879 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT}, 9880 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9881 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT}, 9882 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9883 {} 9884}; 9885 9886static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = { 9887 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT}, 9888 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9889 {} 9890}; 9891 9892static struct hda_input_mux alc262_fujitsu_capture_source = { 9893 .num_items = 3, 9894 .items = { 9895 { "Mic", 0x0 }, 9896 { "Int Mic", 0x1 }, 9897 { "CD", 0x4 }, 9898 }, 9899}; 9900 9901static struct hda_input_mux alc262_HP_capture_source = { 9902 .num_items = 5, 9903 .items = { 9904 { "Mic", 0x0 }, 9905 { "Front Mic", 0x1 }, 9906 { "Line", 0x2 }, 9907 { "CD", 0x4 }, 9908 { "AUX IN", 0x6 }, 9909 }, 9910}; 9911 9912static struct hda_input_mux alc262_HP_D7000_capture_source = { 9913 .num_items = 4, 9914 .items = { 9915 { "Mic", 0x0 }, 9916 { "Front Mic", 0x2 }, 9917 { "Line", 0x1 }, 9918 { "CD", 0x4 }, 9919 }, 9920}; 9921 9922/* mute/unmute internal speaker according to the hp jacks and mute state */ 9923static void alc262_fujitsu_automute(struct hda_codec *codec, int force) 9924{ 9925 struct alc_spec *spec = codec->spec; 9926 unsigned int mute; 9927 9928 if (force || !spec->sense_updated) { 9929 unsigned int present; 9930 /* need to execute and sync at first */ 9931 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0); 9932 /* check laptop HP jack */ 9933 present = snd_hda_codec_read(codec, 0x14, 0, 9934 AC_VERB_GET_PIN_SENSE, 0); 9935 /* need to execute and sync at first */ 9936 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0); 9937 /* check docking HP jack */ 9938 present |= snd_hda_codec_read(codec, 0x1b, 0, 9939 AC_VERB_GET_PIN_SENSE, 0); 9940 if (present & AC_PINSENSE_PRESENCE) 9941 spec->jack_present = 1; 9942 else 9943 spec->jack_present = 0; 9944 spec->sense_updated = 1; 9945 } 9946 /* unmute internal speaker only if both HPs are unplugged and 9947 * master switch is on 9948 */ 9949 if (spec->jack_present) 9950 mute = HDA_AMP_MUTE; 9951 else 9952 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0); 9953 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 9954 HDA_AMP_MUTE, mute); 9955} 9956 9957/* unsolicited event for HP jack sensing */ 9958static void alc262_fujitsu_unsol_event(struct hda_codec *codec, 9959 unsigned int res) 9960{ 9961 if ((res >> 26) != ALC_HP_EVENT) 9962 return; 9963 alc262_fujitsu_automute(codec, 1); 9964} 9965 9966static void alc262_fujitsu_init_hook(struct hda_codec *codec) 9967{ 9968 alc262_fujitsu_automute(codec, 1); 9969} 9970 9971/* bind volumes of both NID 0x0c and 0x0d */ 9972static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = { 9973 .ops = &snd_hda_bind_vol, 9974 .values = { 9975 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT), 9976 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT), 9977 0 9978 }, 9979}; 9980 9981/* mute/unmute internal speaker according to the hp jack and mute state */ 9982static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force) 9983{ 9984 struct alc_spec *spec = codec->spec; 9985 unsigned int mute; 9986 9987 if (force || !spec->sense_updated) { 9988 unsigned int present_int_hp; 9989 /* need to execute and sync at first */ 9990 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0); 9991 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0, 9992 AC_VERB_GET_PIN_SENSE, 0); 9993 spec->jack_present = (present_int_hp & 0x80000000) != 0; 9994 spec->sense_updated = 1; 9995 } 9996 if (spec->jack_present) { 9997 /* mute internal speaker */ 9998 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9999 HDA_AMP_MUTE, HDA_AMP_MUTE); 10000 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 10001 HDA_AMP_MUTE, HDA_AMP_MUTE); 10002 } else { 10003 /* unmute internal speaker if necessary */ 10004 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0); 10005 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 10006 HDA_AMP_MUTE, mute); 10007 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 10008 HDA_AMP_MUTE, mute); 10009 } 10010} 10011 10012/* unsolicited event for HP jack sensing */ 10013static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec, 10014 unsigned int res) 10015{ 10016 if ((res >> 26) != ALC_HP_EVENT) 10017 return; 10018 alc262_lenovo_3000_automute(codec, 1); 10019} 10020 10021/* bind hp and internal speaker mute (with plug check) */ 10022static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol, 10023 struct snd_ctl_elem_value *ucontrol) 10024{ 10025 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 10026 long *valp = ucontrol->value.integer.value; 10027 int change; 10028 10029 change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 10030 HDA_AMP_MUTE, 10031 valp ? 0 : HDA_AMP_MUTE); 10032 change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 10033 HDA_AMP_MUTE, 10034 valp ? 0 : HDA_AMP_MUTE); 10035 10036 if (change) 10037 alc262_fujitsu_automute(codec, 0); 10038 return change; 10039} 10040 10041static struct snd_kcontrol_new alc262_fujitsu_mixer[] = { 10042 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol), 10043 { 10044 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 10045 .name = "Master Playback Switch", 10046 .info = snd_hda_mixer_amp_switch_info, 10047 .get = snd_hda_mixer_amp_switch_get, 10048 .put = alc262_fujitsu_master_sw_put, 10049 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 10050 }, 10051 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 10052 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 10053 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 10054 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 10055 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 10056 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 10057 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 10058 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 10059 { } /* end */ 10060}; 10061 10062/* bind hp and internal speaker mute (with plug check) */ 10063static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol, 10064 struct snd_ctl_elem_value *ucontrol) 10065{ 10066 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 10067 long *valp = ucontrol->value.integer.value; 10068 int change; 10069 10070 change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 10071 HDA_AMP_MUTE, 10072 valp ? 0 : HDA_AMP_MUTE); 10073 10074 if (change) 10075 alc262_lenovo_3000_automute(codec, 0); 10076 return change; 10077} 10078 10079static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = { 10080 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol), 10081 { 10082 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 10083 .name = "Master Playback Switch", 10084 .info = snd_hda_mixer_amp_switch_info, 10085 .get = snd_hda_mixer_amp_switch_get, 10086 .put = alc262_lenovo_3000_master_sw_put, 10087 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT), 10088 }, 10089 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 10090 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 10091 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 10092 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 10093 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 10094 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 10095 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 10096 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 10097 { } /* end */ 10098}; 10099 10100static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = { 10101 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol), 10102 { 10103 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 10104 .name = "Master Playback Switch", 10105 .info = snd_hda_mixer_amp_switch_info, 10106 .get = snd_hda_mixer_amp_switch_get, 10107 .put = alc262_sony_master_sw_put, 10108 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT), 10109 }, 10110 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 10111 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 10112 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 10113 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 10114 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 10115 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 10116 { } /* end */ 10117}; 10118 10119/* additional init verbs for Benq laptops */ 10120static struct hda_verb alc262_EAPD_verbs[] = { 10121 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 10122 {0x20, AC_VERB_SET_PROC_COEF, 0x3070}, 10123 {} 10124}; 10125 10126static struct hda_verb alc262_benq_t31_EAPD_verbs[] = { 10127 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 10128 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 10129 10130 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 10131 {0x20, AC_VERB_SET_PROC_COEF, 0x3050}, 10132 {} 10133}; 10134 10135/* Samsung Q1 Ultra Vista model setup */ 10136static struct snd_kcontrol_new alc262_ultra_mixer[] = { 10137 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 10138 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT), 10139 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 10140 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 10141 HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT), 10142 HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT), 10143 { } /* end */ 10144}; 10145 10146static struct hda_verb alc262_ultra_verbs[] = { 10147 /* output mixer */ 10148 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 10149 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 10150 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10151 /* speaker */ 10152 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 10153 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10154 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10155 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 10156 /* HP */ 10157 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 10158 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10159 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10160 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 10161 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 10162 /* internal mic */ 10163 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 10164 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 10165 /* ADC, choose mic */ 10166 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 10167 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 10168 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10169 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 10170 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 10171 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 10172 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 10173 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 10174 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 10175 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)}, 10176 {} 10177}; 10178 10179/* mute/unmute internal speaker according to the hp jack and mute state */ 10180static void alc262_ultra_automute(struct hda_codec *codec) 10181{ 10182 struct alc_spec *spec = codec->spec; 10183 unsigned int mute; 10184 10185 mute = 0; 10186 /* auto-mute only when HP is used as HP */ 10187 if (!spec->cur_mux[0]) { 10188 unsigned int present; 10189 /* need to execute and sync at first */ 10190 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0); 10191 present = snd_hda_codec_read(codec, 0x15, 0, 10192 AC_VERB_GET_PIN_SENSE, 0); 10193 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0; 10194 if (spec->jack_present) 10195 mute = HDA_AMP_MUTE; 10196 } 10197 /* mute/unmute internal speaker */ 10198 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 10199 HDA_AMP_MUTE, mute); 10200 /* mute/unmute HP */ 10201 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 10202 HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE); 10203} 10204 10205/* unsolicited event for HP jack sensing */ 10206static void alc262_ultra_unsol_event(struct hda_codec *codec, 10207 unsigned int res) 10208{ 10209 if ((res >> 26) != ALC880_HP_EVENT) 10210 return; 10211 alc262_ultra_automute(codec); 10212} 10213 10214static struct hda_input_mux alc262_ultra_capture_source = { 10215 .num_items = 2, 10216 .items = { 10217 { "Mic", 0x1 }, 10218 { "Headphone", 0x7 }, 10219 }, 10220}; 10221 10222static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol, 10223 struct snd_ctl_elem_value *ucontrol) 10224{ 10225 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 10226 struct alc_spec *spec = codec->spec; 10227 int ret; 10228 10229 ret = alc_mux_enum_put(kcontrol, ucontrol); 10230 if (!ret) 10231 return 0; 10232 /* reprogram the HP pin as mic or HP according to the input source */ 10233 snd_hda_codec_write_cache(codec, 0x15, 0, 10234 AC_VERB_SET_PIN_WIDGET_CONTROL, 10235 spec->cur_mux[0] ? PIN_VREF80 : PIN_HP); 10236 alc262_ultra_automute(codec); /* mute/unmute HP */ 10237 return ret; 10238} 10239 10240static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = { 10241 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT), 10242 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT), 10243 { 10244 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 10245 .name = "Capture Source", 10246 .info = alc_mux_enum_info, 10247 .get = alc_mux_enum_get, 10248 .put = alc262_ultra_mux_enum_put, 10249 }, 10250 { } /* end */ 10251}; 10252 10253/* add playback controls from the parsed DAC table */ 10254static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec, 10255 const struct auto_pin_cfg *cfg) 10256{ 10257 hda_nid_t nid; 10258 int err; 10259 10260 spec->multiout.num_dacs = 1; /* only use one dac */ 10261 spec->multiout.dac_nids = spec->private_dac_nids; 10262 spec->multiout.dac_nids[0] = 2; 10263 10264 nid = cfg->line_out_pins[0]; 10265 if (nid) { 10266 err = add_control(spec, ALC_CTL_WIDGET_VOL, 10267 "Front Playback Volume", 10268 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT)); 10269 if (err < 0) 10270 return err; 10271 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 10272 "Front Playback Switch", 10273 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 10274 if (err < 0) 10275 return err; 10276 } 10277 10278 nid = cfg->speaker_pins[0]; 10279 if (nid) { 10280 if (nid == 0x16) { 10281 err = add_control(spec, ALC_CTL_WIDGET_VOL, 10282 "Speaker Playback Volume", 10283 HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, 10284 HDA_OUTPUT)); 10285 if (err < 0) 10286 return err; 10287 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 10288 "Speaker Playback Switch", 10289 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 10290 HDA_OUTPUT)); 10291 if (err < 0) 10292 return err; 10293 } else { 10294 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 10295 "Speaker Playback Switch", 10296 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 10297 HDA_OUTPUT)); 10298 if (err < 0) 10299 return err; 10300 } 10301 } 10302 nid = cfg->hp_pins[0]; 10303 if (nid) { 10304 /* spec->multiout.hp_nid = 2; */ 10305 if (nid == 0x16) { 10306 err = add_control(spec, ALC_CTL_WIDGET_VOL, 10307 "Headphone Playback Volume", 10308 HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, 10309 HDA_OUTPUT)); 10310 if (err < 0) 10311 return err; 10312 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 10313 "Headphone Playback Switch", 10314 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 10315 HDA_OUTPUT)); 10316 if (err < 0) 10317 return err; 10318 } else { 10319 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 10320 "Headphone Playback Switch", 10321 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 10322 HDA_OUTPUT)); 10323 if (err < 0) 10324 return err; 10325 } 10326 } 10327 return 0; 10328} 10329 10330/* identical with ALC880 */ 10331#define alc262_auto_create_analog_input_ctls \ 10332 alc880_auto_create_analog_input_ctls 10333 10334/* 10335 * generic initialization of ADC, input mixers and output mixers 10336 */ 10337static struct hda_verb alc262_volume_init_verbs[] = { 10338 /* 10339 * Unmute ADC0-2 and set the default input to mic-in 10340 */ 10341 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 10342 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10343 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 10344 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10345 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 10346 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10347 10348 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 10349 * mixer widget 10350 * Note: PASD motherboards uses the Line In 2 as the input for 10351 * front panel mic (mic 2) 10352 */ 10353 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 10354 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 10355 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 10356 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 10357 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 10358 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 10359 10360 /* 10361 * Set up output mixers (0x0c - 0x0f) 10362 */ 10363 /* set vol=0 to output mixers */ 10364 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10365 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10366 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10367 10368 /* set up input amps for analog loopback */ 10369 /* Amp Indices: DAC = 0, mixer = 1 */ 10370 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10371 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10372 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10373 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10374 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10375 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10376 10377 /* FIXME: use matrix-type input source selection */ 10378 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 10379 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 10380 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 10381 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 10382 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 10383 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 10384 /* Input mixer2 */ 10385 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 10386 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 10387 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 10388 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 10389 /* Input mixer3 */ 10390 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 10391 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 10392 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 10393 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 10394 10395 { } 10396}; 10397 10398static struct hda_verb alc262_HP_BPC_init_verbs[] = { 10399 /* 10400 * Unmute ADC0-2 and set the default input to mic-in 10401 */ 10402 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 10403 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10404 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 10405 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10406 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 10407 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10408 10409 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 10410 * mixer widget 10411 * Note: PASD motherboards uses the Line In 2 as the input for 10412 * front panel mic (mic 2) 10413 */ 10414 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 10415 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 10416 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 10417 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 10418 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 10419 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 10420 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 10421 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 10422 10423 /* 10424 * Set up output mixers (0x0c - 0x0e) 10425 */ 10426 /* set vol=0 to output mixers */ 10427 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10428 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10429 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10430 10431 /* set up input amps for analog loopback */ 10432 /* Amp Indices: DAC = 0, mixer = 1 */ 10433 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10434 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10435 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10436 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10437 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10438 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10439 10440 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 10441 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 10442 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 10443 10444 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 10445 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 10446 10447 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 10448 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 10449 10450 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 10451 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 10452 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 10453 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 10454 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 10455 10456 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, 10457 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 10458 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 10459 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, 10460 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 10461 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 10462 10463 10464 /* FIXME: use matrix-type input source selection */ 10465 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 10466 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 10467 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 10468 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, 10469 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, 10470 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, 10471 /* Input mixer2 */ 10472 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 10473 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, 10474 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, 10475 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, 10476 /* Input mixer3 */ 10477 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 10478 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, 10479 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, 10480 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, 10481 10482 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 10483 10484 { } 10485}; 10486 10487static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = { 10488 /* 10489 * Unmute ADC0-2 and set the default input to mic-in 10490 */ 10491 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 10492 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10493 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 10494 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10495 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 10496 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10497 10498 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 10499 * mixer widget 10500 * Note: PASD motherboards uses the Line In 2 as the input for front 10501 * panel mic (mic 2) 10502 */ 10503 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 10504 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 10505 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 10506 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 10507 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 10508 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 10509 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 10510 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 10511 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 10512 /* 10513 * Set up output mixers (0x0c - 0x0e) 10514 */ 10515 /* set vol=0 to output mixers */ 10516 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10517 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10518 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10519 10520 /* set up input amps for analog loopback */ 10521 /* Amp Indices: DAC = 0, mixer = 1 */ 10522 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10523 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10524 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10525 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10526 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10527 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10528 10529 10530 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP */ 10531 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Mono */ 10532 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* rear MIC */ 10533 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* Line in */ 10534 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Front MIC */ 10535 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Line out */ 10536 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD in */ 10537 10538 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 10539 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 10540 10541 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 10542 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 10543 10544 /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */ 10545 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 10546 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 10547 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, 10548 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 10549 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 10550 10551 /* FIXME: use matrix-type input source selection */ 10552 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 10553 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 10554 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/ 10555 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/ 10556 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/ 10557 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/ 10558 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/ 10559 /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */ 10560 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/ 10561 /* Input mixer2 */ 10562 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 10563 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 10564 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, 10565 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, 10566 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, 10567 /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */ 10568 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, 10569 /* Input mixer3 */ 10570 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 10571 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 10572 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, 10573 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, 10574 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, 10575 /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */ 10576 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, 10577 10578 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 10579 10580 { } 10581}; 10582 10583static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = { 10584 10585 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Front Speaker */ 10586 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 10587 {0x14, AC_VERB_SET_CONNECT_SEL, 0x01}, 10588 10589 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* MIC jack */ 10590 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Front MIC */ 10591 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) }, 10592 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) }, 10593 10594 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP jack */ 10595 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 10596 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 10597 {} 10598}; 10599 10600 10601#ifdef CONFIG_SND_HDA_POWER_SAVE 10602#define alc262_loopbacks alc880_loopbacks 10603#endif 10604 10605/* pcm configuration: identiacal with ALC880 */ 10606#define alc262_pcm_analog_playback alc880_pcm_analog_playback 10607#define alc262_pcm_analog_capture alc880_pcm_analog_capture 10608#define alc262_pcm_digital_playback alc880_pcm_digital_playback 10609#define alc262_pcm_digital_capture alc880_pcm_digital_capture 10610 10611/* 10612 * BIOS auto configuration 10613 */ 10614static int alc262_parse_auto_config(struct hda_codec *codec) 10615{ 10616 struct alc_spec *spec = codec->spec; 10617 int err; 10618 static hda_nid_t alc262_ignore[] = { 0x1d, 0 }; 10619 10620 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 10621 alc262_ignore); 10622 if (err < 0) 10623 return err; 10624 if (!spec->autocfg.line_outs) { 10625 if (spec->autocfg.dig_out_pin || spec->autocfg.dig_in_pin) { 10626 spec->multiout.max_channels = 2; 10627 spec->no_analog = 1; 10628 goto dig_only; 10629 } 10630 return 0; /* can't find valid BIOS pin config */ 10631 } 10632 err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg); 10633 if (err < 0) 10634 return err; 10635 err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg); 10636 if (err < 0) 10637 return err; 10638 10639 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 10640 10641 dig_only: 10642 if (spec->autocfg.dig_out_pin) { 10643 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID; 10644 spec->dig_out_type = spec->autocfg.dig_out_type; 10645 } 10646 if (spec->autocfg.dig_in_pin) 10647 spec->dig_in_nid = ALC262_DIGIN_NID; 10648 10649 if (spec->kctls.list) 10650 add_mixer(spec, spec->kctls.list); 10651 10652 add_verb(spec, alc262_volume_init_verbs); 10653 spec->num_mux_defs = 1; 10654 spec->input_mux = &spec->private_imux[0]; 10655 10656 err = alc_auto_add_mic_boost(codec); 10657 if (err < 0) 10658 return err; 10659 10660 store_pin_configs(codec); 10661 return 1; 10662} 10663 10664#define alc262_auto_init_multi_out alc882_auto_init_multi_out 10665#define alc262_auto_init_hp_out alc882_auto_init_hp_out 10666#define alc262_auto_init_analog_input alc882_auto_init_analog_input 10667#define alc262_auto_init_input_src alc882_auto_init_input_src 10668 10669 10670/* init callback for auto-configuration model -- overriding the default init */ 10671static void alc262_auto_init(struct hda_codec *codec) 10672{ 10673 struct alc_spec *spec = codec->spec; 10674 alc262_auto_init_multi_out(codec); 10675 alc262_auto_init_hp_out(codec); 10676 alc262_auto_init_analog_input(codec); 10677 alc262_auto_init_input_src(codec); 10678 if (spec->unsol_event) 10679 alc_inithook(codec); 10680} 10681 10682/* 10683 * configuration and preset 10684 */ 10685static const char *alc262_models[ALC262_MODEL_LAST] = { 10686 [ALC262_BASIC] = "basic", 10687 [ALC262_HIPPO] = "hippo", 10688 [ALC262_HIPPO_1] = "hippo_1", 10689 [ALC262_FUJITSU] = "fujitsu", 10690 [ALC262_HP_BPC] = "hp-bpc", 10691 [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000", 10692 [ALC262_HP_TC_T5735] = "hp-tc-t5735", 10693 [ALC262_HP_RP5700] = "hp-rp5700", 10694 [ALC262_BENQ_ED8] = "benq", 10695 [ALC262_BENQ_T31] = "benq-t31", 10696 [ALC262_SONY_ASSAMD] = "sony-assamd", 10697 [ALC262_TOSHIBA_S06] = "toshiba-s06", 10698 [ALC262_TOSHIBA_RX1] = "toshiba-rx1", 10699 [ALC262_ULTRA] = "ultra", 10700 [ALC262_LENOVO_3000] = "lenovo-3000", 10701 [ALC262_NEC] = "nec", 10702 [ALC262_TYAN] = "tyan", 10703 [ALC262_AUTO] = "auto", 10704}; 10705 10706static struct snd_pci_quirk alc262_cfg_tbl[] = { 10707 SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO), 10708 SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC), 10709 SND_PCI_QUIRK(0x103c, 0x12fe, "HP xw9400", ALC262_HP_BPC), 10710 SND_PCI_QUIRK(0x103c, 0x12ff, "HP xw4550", ALC262_HP_BPC), 10711 SND_PCI_QUIRK(0x103c, 0x1306, "HP xw8600", ALC262_HP_BPC), 10712 SND_PCI_QUIRK(0x103c, 0x1307, "HP xw6600", ALC262_HP_BPC), 10713 SND_PCI_QUIRK(0x103c, 0x1308, "HP xw4600", ALC262_HP_BPC), 10714 SND_PCI_QUIRK(0x103c, 0x1309, "HP xw4*00", ALC262_HP_BPC), 10715 SND_PCI_QUIRK(0x103c, 0x130a, "HP xw6*00", ALC262_HP_BPC), 10716 SND_PCI_QUIRK(0x103c, 0x130b, "HP xw8*00", ALC262_HP_BPC), 10717 SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL), 10718 SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF), 10719 SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL), 10720 SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF), 10721 SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL), 10722 SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF), 10723 SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL), 10724 SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF), 10725 SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC), 10726 SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC), 10727 SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC), 10728 SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735", 10729 ALC262_HP_TC_T5735), 10730 SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700), 10731 SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD), 10732 SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO), 10733 SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD), 10734 SND_PCI_QUIRK(0x104d, 0x900e, "Sony ASSAMD", ALC262_SONY_ASSAMD), 10735 SND_PCI_QUIRK(0x104d, 0x9015, "Sony 0x9015", ALC262_SONY_ASSAMD), 10736 SND_PCI_QUIRK(0x104d, 0x9033, "Sony VAIO VGN-SR19XN", 10737 ALC262_SONY_ASSAMD), 10738 SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1", 10739 ALC262_TOSHIBA_RX1), 10740 SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06), 10741 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU), 10742 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU), 10743 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN), 10744 SND_PCI_QUIRK(0x144d, 0xc032, "Samsung Q1 Ultra", ALC262_ULTRA), 10745 SND_PCI_QUIRK(0x144d, 0xc039, "Samsung Q1U EL", ALC262_ULTRA), 10746 SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO), 10747 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000), 10748 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8), 10749 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31), 10750 SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1), 10751 {} 10752}; 10753 10754static struct alc_config_preset alc262_presets[] = { 10755 [ALC262_BASIC] = { 10756 .mixers = { alc262_base_mixer }, 10757 .init_verbs = { alc262_init_verbs }, 10758 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10759 .dac_nids = alc262_dac_nids, 10760 .hp_nid = 0x03, 10761 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10762 .channel_mode = alc262_modes, 10763 .input_mux = &alc262_capture_source, 10764 }, 10765 [ALC262_HIPPO] = { 10766 .mixers = { alc262_base_mixer }, 10767 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs}, 10768 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10769 .dac_nids = alc262_dac_nids, 10770 .hp_nid = 0x03, 10771 .dig_out_nid = ALC262_DIGOUT_NID, 10772 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10773 .channel_mode = alc262_modes, 10774 .input_mux = &alc262_capture_source, 10775 .unsol_event = alc262_hippo_unsol_event, 10776 .init_hook = alc262_hippo_automute, 10777 }, 10778 [ALC262_HIPPO_1] = { 10779 .mixers = { alc262_hippo1_mixer }, 10780 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs}, 10781 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10782 .dac_nids = alc262_dac_nids, 10783 .hp_nid = 0x02, 10784 .dig_out_nid = ALC262_DIGOUT_NID, 10785 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10786 .channel_mode = alc262_modes, 10787 .input_mux = &alc262_capture_source, 10788 .unsol_event = alc262_hippo1_unsol_event, 10789 .init_hook = alc262_hippo1_automute, 10790 }, 10791 [ALC262_FUJITSU] = { 10792 .mixers = { alc262_fujitsu_mixer }, 10793 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs, 10794 alc262_fujitsu_unsol_verbs }, 10795 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10796 .dac_nids = alc262_dac_nids, 10797 .hp_nid = 0x03, 10798 .dig_out_nid = ALC262_DIGOUT_NID, 10799 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10800 .channel_mode = alc262_modes, 10801 .input_mux = &alc262_fujitsu_capture_source, 10802 .unsol_event = alc262_fujitsu_unsol_event, 10803 .init_hook = alc262_fujitsu_init_hook, 10804 }, 10805 [ALC262_HP_BPC] = { 10806 .mixers = { alc262_HP_BPC_mixer }, 10807 .init_verbs = { alc262_HP_BPC_init_verbs }, 10808 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10809 .dac_nids = alc262_dac_nids, 10810 .hp_nid = 0x03, 10811 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10812 .channel_mode = alc262_modes, 10813 .input_mux = &alc262_HP_capture_source, 10814 .unsol_event = alc262_hp_bpc_unsol_event, 10815 .init_hook = alc262_hp_bpc_automute, 10816 }, 10817 [ALC262_HP_BPC_D7000_WF] = { 10818 .mixers = { alc262_HP_BPC_WildWest_mixer }, 10819 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs }, 10820 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10821 .dac_nids = alc262_dac_nids, 10822 .hp_nid = 0x03, 10823 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10824 .channel_mode = alc262_modes, 10825 .input_mux = &alc262_HP_D7000_capture_source, 10826 .unsol_event = alc262_hp_wildwest_unsol_event, 10827 .init_hook = alc262_hp_wildwest_automute, 10828 }, 10829 [ALC262_HP_BPC_D7000_WL] = { 10830 .mixers = { alc262_HP_BPC_WildWest_mixer, 10831 alc262_HP_BPC_WildWest_option_mixer }, 10832 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs }, 10833 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10834 .dac_nids = alc262_dac_nids, 10835 .hp_nid = 0x03, 10836 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10837 .channel_mode = alc262_modes, 10838 .input_mux = &alc262_HP_D7000_capture_source, 10839 .unsol_event = alc262_hp_wildwest_unsol_event, 10840 .init_hook = alc262_hp_wildwest_automute, 10841 }, 10842 [ALC262_HP_TC_T5735] = { 10843 .mixers = { alc262_hp_t5735_mixer }, 10844 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs }, 10845 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10846 .dac_nids = alc262_dac_nids, 10847 .hp_nid = 0x03, 10848 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10849 .channel_mode = alc262_modes, 10850 .input_mux = &alc262_capture_source, 10851 .unsol_event = alc262_hp_t5735_unsol_event, 10852 .init_hook = alc262_hp_t5735_init_hook, 10853 }, 10854 [ALC262_HP_RP5700] = { 10855 .mixers = { alc262_hp_rp5700_mixer }, 10856 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs }, 10857 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10858 .dac_nids = alc262_dac_nids, 10859 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10860 .channel_mode = alc262_modes, 10861 .input_mux = &alc262_hp_rp5700_capture_source, 10862 }, 10863 [ALC262_BENQ_ED8] = { 10864 .mixers = { alc262_base_mixer }, 10865 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs }, 10866 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10867 .dac_nids = alc262_dac_nids, 10868 .hp_nid = 0x03, 10869 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10870 .channel_mode = alc262_modes, 10871 .input_mux = &alc262_capture_source, 10872 }, 10873 [ALC262_SONY_ASSAMD] = { 10874 .mixers = { alc262_sony_mixer }, 10875 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs}, 10876 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10877 .dac_nids = alc262_dac_nids, 10878 .hp_nid = 0x02, 10879 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10880 .channel_mode = alc262_modes, 10881 .input_mux = &alc262_capture_source, 10882 .unsol_event = alc262_hippo_unsol_event, 10883 .init_hook = alc262_hippo_automute, 10884 }, 10885 [ALC262_BENQ_T31] = { 10886 .mixers = { alc262_benq_t31_mixer }, 10887 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs }, 10888 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10889 .dac_nids = alc262_dac_nids, 10890 .hp_nid = 0x03, 10891 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10892 .channel_mode = alc262_modes, 10893 .input_mux = &alc262_capture_source, 10894 .unsol_event = alc262_hippo_unsol_event, 10895 .init_hook = alc262_hippo_automute, 10896 }, 10897 [ALC262_ULTRA] = { 10898 .mixers = { alc262_ultra_mixer }, 10899 .cap_mixer = alc262_ultra_capture_mixer, 10900 .init_verbs = { alc262_ultra_verbs }, 10901 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10902 .dac_nids = alc262_dac_nids, 10903 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10904 .channel_mode = alc262_modes, 10905 .input_mux = &alc262_ultra_capture_source, 10906 .adc_nids = alc262_adc_nids, /* ADC0 */ 10907 .capsrc_nids = alc262_capsrc_nids, 10908 .num_adc_nids = 1, /* single ADC */ 10909 .unsol_event = alc262_ultra_unsol_event, 10910 .init_hook = alc262_ultra_automute, 10911 }, 10912 [ALC262_LENOVO_3000] = { 10913 .mixers = { alc262_lenovo_3000_mixer }, 10914 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs, 10915 alc262_lenovo_3000_unsol_verbs }, 10916 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10917 .dac_nids = alc262_dac_nids, 10918 .hp_nid = 0x03, 10919 .dig_out_nid = ALC262_DIGOUT_NID, 10920 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10921 .channel_mode = alc262_modes, 10922 .input_mux = &alc262_fujitsu_capture_source, 10923 .unsol_event = alc262_lenovo_3000_unsol_event, 10924 }, 10925 [ALC262_NEC] = { 10926 .mixers = { alc262_nec_mixer }, 10927 .init_verbs = { alc262_nec_verbs }, 10928 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10929 .dac_nids = alc262_dac_nids, 10930 .hp_nid = 0x03, 10931 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10932 .channel_mode = alc262_modes, 10933 .input_mux = &alc262_capture_source, 10934 }, 10935 [ALC262_TOSHIBA_S06] = { 10936 .mixers = { alc262_toshiba_s06_mixer }, 10937 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs, 10938 alc262_eapd_verbs }, 10939 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10940 .capsrc_nids = alc262_dmic_capsrc_nids, 10941 .dac_nids = alc262_dac_nids, 10942 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */ 10943 .dig_out_nid = ALC262_DIGOUT_NID, 10944 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10945 .channel_mode = alc262_modes, 10946 .input_mux = &alc262_dmic_capture_source, 10947 .unsol_event = alc262_toshiba_s06_unsol_event, 10948 .init_hook = alc262_toshiba_s06_init_hook, 10949 }, 10950 [ALC262_TOSHIBA_RX1] = { 10951 .mixers = { alc262_toshiba_rx1_mixer }, 10952 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs }, 10953 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10954 .dac_nids = alc262_dac_nids, 10955 .hp_nid = 0x03, 10956 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10957 .channel_mode = alc262_modes, 10958 .input_mux = &alc262_capture_source, 10959 .unsol_event = alc262_hippo_unsol_event, 10960 .init_hook = alc262_hippo_automute, 10961 }, 10962 [ALC262_TYAN] = { 10963 .mixers = { alc262_tyan_mixer }, 10964 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs}, 10965 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10966 .dac_nids = alc262_dac_nids, 10967 .hp_nid = 0x02, 10968 .dig_out_nid = ALC262_DIGOUT_NID, 10969 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10970 .channel_mode = alc262_modes, 10971 .input_mux = &alc262_capture_source, 10972 .unsol_event = alc262_tyan_unsol_event, 10973 .init_hook = alc262_tyan_automute, 10974 }, 10975}; 10976 10977static int patch_alc262(struct hda_codec *codec) 10978{ 10979 struct alc_spec *spec; 10980 int board_config; 10981 int err; 10982 10983 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 10984 if (spec == NULL) 10985 return -ENOMEM; 10986 10987 codec->spec = spec; 10988#if 0 10989 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is 10990 * under-run 10991 */ 10992 { 10993 int tmp; 10994 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7); 10995 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0); 10996 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7); 10997 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80); 10998 } 10999#endif 11000 11001 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 11002 11003 board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST, 11004 alc262_models, 11005 alc262_cfg_tbl); 11006 11007 if (board_config < 0) { 11008 printk(KERN_INFO "hda_codec: Unknown model for ALC262, " 11009 "trying auto-probe from BIOS...\n"); 11010 board_config = ALC262_AUTO; 11011 } 11012 11013 if (board_config == ALC262_AUTO) { 11014 /* automatic parse from the BIOS config */ 11015 err = alc262_parse_auto_config(codec); 11016 if (err < 0) { 11017 alc_free(codec); 11018 return err; 11019 } else if (!err) { 11020 printk(KERN_INFO 11021 "hda_codec: Cannot set up configuration " 11022 "from BIOS. Using base mode...\n"); 11023 board_config = ALC262_BASIC; 11024 } 11025 } 11026 11027 err = snd_hda_attach_beep_device(codec, 0x1); 11028 if (err < 0) { 11029 alc_free(codec); 11030 return err; 11031 } 11032 11033 if (board_config != ALC262_AUTO) 11034 setup_preset(spec, &alc262_presets[board_config]); 11035 11036 spec->stream_name_analog = "ALC262 Analog"; 11037 spec->stream_analog_playback = &alc262_pcm_analog_playback; 11038 spec->stream_analog_capture = &alc262_pcm_analog_capture; 11039 11040 spec->stream_name_digital = "ALC262 Digital"; 11041 spec->stream_digital_playback = &alc262_pcm_digital_playback; 11042 spec->stream_digital_capture = &alc262_pcm_digital_capture; 11043 11044 spec->capture_style = CAPT_MIX; 11045 if (!spec->adc_nids && spec->input_mux) { 11046 /* check whether NID 0x07 is valid */ 11047 unsigned int wcap = get_wcaps(codec, 0x07); 11048 11049 /* get type */ 11050 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 11051 if (wcap != AC_WID_AUD_IN) { 11052 spec->adc_nids = alc262_adc_nids_alt; 11053 spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt); 11054 spec->capsrc_nids = alc262_capsrc_nids_alt; 11055 } else { 11056 spec->adc_nids = alc262_adc_nids; 11057 spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids); 11058 spec->capsrc_nids = alc262_capsrc_nids; 11059 } 11060 } 11061 if (!spec->cap_mixer && !spec->no_analog) 11062 set_capture_mixer(spec); 11063 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 11064 11065 spec->vmaster_nid = 0x0c; 11066 11067 codec->patch_ops = alc_patch_ops; 11068 if (board_config == ALC262_AUTO) 11069 spec->init_hook = alc262_auto_init; 11070#ifdef CONFIG_SND_HDA_POWER_SAVE 11071 if (!spec->loopback.amplist) 11072 spec->loopback.amplist = alc262_loopbacks; 11073#endif 11074 codec->proc_widget_hook = print_realtek_coef; 11075 11076 return 0; 11077} 11078 11079/* 11080 * ALC268 channel source setting (2 channel) 11081 */ 11082#define ALC268_DIGOUT_NID ALC880_DIGOUT_NID 11083#define alc268_modes alc260_modes 11084 11085static hda_nid_t alc268_dac_nids[2] = { 11086 /* front, hp */ 11087 0x02, 0x03 11088}; 11089 11090static hda_nid_t alc268_adc_nids[2] = { 11091 /* ADC0-1 */ 11092 0x08, 0x07 11093}; 11094 11095static hda_nid_t alc268_adc_nids_alt[1] = { 11096 /* ADC0 */ 11097 0x08 11098}; 11099 11100static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 }; 11101 11102static struct snd_kcontrol_new alc268_base_mixer[] = { 11103 /* output mixer control */ 11104 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT), 11105 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 11106 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT), 11107 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 11108 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 11109 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 11110 HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT), 11111 { } 11112}; 11113 11114/* bind Beep switches of both NID 0x0f and 0x10 */ 11115static struct hda_bind_ctls alc268_bind_beep_sw = { 11116 .ops = &snd_hda_bind_sw, 11117 .values = { 11118 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT), 11119 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT), 11120 0 11121 }, 11122}; 11123 11124static struct snd_kcontrol_new alc268_beep_mixer[] = { 11125 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT), 11126 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw), 11127 { } 11128}; 11129 11130static struct hda_verb alc268_eapd_verbs[] = { 11131 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 11132 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 11133 { } 11134}; 11135 11136/* Toshiba specific */ 11137#define alc268_toshiba_automute alc262_hippo_automute 11138 11139static struct hda_verb alc268_toshiba_verbs[] = { 11140 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 11141 { } /* end */ 11142}; 11143 11144static struct hda_input_mux alc268_acer_lc_capture_source = { 11145 .num_items = 2, 11146 .items = { 11147 { "i-Mic", 0x6 }, 11148 { "E-Mic", 0x0 }, 11149 }, 11150}; 11151 11152/* Acer specific */ 11153/* bind volumes of both NID 0x02 and 0x03 */ 11154static struct hda_bind_ctls alc268_acer_bind_master_vol = { 11155 .ops = &snd_hda_bind_vol, 11156 .values = { 11157 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT), 11158 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT), 11159 0 11160 }, 11161}; 11162 11163/* mute/unmute internal speaker according to the hp jack and mute state */ 11164static void alc268_acer_automute(struct hda_codec *codec, int force) 11165{ 11166 struct alc_spec *spec = codec->spec; 11167 unsigned int mute; 11168 11169 if (force || !spec->sense_updated) { 11170 unsigned int present; 11171 present = snd_hda_codec_read(codec, 0x14, 0, 11172 AC_VERB_GET_PIN_SENSE, 0); 11173 spec->jack_present = (present & 0x80000000) != 0; 11174 spec->sense_updated = 1; 11175 } 11176 if (spec->jack_present) 11177 mute = HDA_AMP_MUTE; /* mute internal speaker */ 11178 else /* unmute internal speaker if necessary */ 11179 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0); 11180 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 11181 HDA_AMP_MUTE, mute); 11182} 11183 11184 11185/* bind hp and internal speaker mute (with plug check) */ 11186static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol, 11187 struct snd_ctl_elem_value *ucontrol) 11188{ 11189 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 11190 long *valp = ucontrol->value.integer.value; 11191 int change; 11192 11193 change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0, 11194 HDA_AMP_MUTE, 11195 valp[0] ? 0 : HDA_AMP_MUTE); 11196 change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0, 11197 HDA_AMP_MUTE, 11198 valp[1] ? 0 : HDA_AMP_MUTE); 11199 if (change) 11200 alc268_acer_automute(codec, 0); 11201 return change; 11202} 11203 11204static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = { 11205 /* output mixer control */ 11206 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol), 11207 { 11208 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11209 .name = "Master Playback Switch", 11210 .info = snd_hda_mixer_amp_switch_info, 11211 .get = snd_hda_mixer_amp_switch_get, 11212 .put = alc268_acer_master_sw_put, 11213 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 11214 }, 11215 HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT), 11216 { } 11217}; 11218 11219static struct snd_kcontrol_new alc268_acer_mixer[] = { 11220 /* output mixer control */ 11221 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol), 11222 { 11223 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11224 .name = "Master Playback Switch", 11225 .info = snd_hda_mixer_amp_switch_info, 11226 .get = snd_hda_mixer_amp_switch_get, 11227 .put = alc268_acer_master_sw_put, 11228 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 11229 }, 11230 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 11231 HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT), 11232 HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT), 11233 { } 11234}; 11235 11236static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = { 11237 /* output mixer control */ 11238 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol), 11239 { 11240 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11241 .name = "Master Playback Switch", 11242 .info = snd_hda_mixer_amp_switch_info, 11243 .get = snd_hda_mixer_amp_switch_get, 11244 .put = alc268_acer_master_sw_put, 11245 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 11246 }, 11247 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 11248 HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT), 11249 { } 11250}; 11251 11252static struct hda_verb alc268_acer_aspire_one_verbs[] = { 11253 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 11254 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 11255 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 11256 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 11257 {0x23, AC_VERB_SET_CONNECT_SEL, 0x06}, 11258 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017}, 11259 { } 11260}; 11261 11262static struct hda_verb alc268_acer_verbs[] = { 11263 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */ 11264 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 11265 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 11266 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 11267 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 11268 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 11269 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 11270 { } 11271}; 11272 11273/* unsolicited event for HP jack sensing */ 11274static void alc268_toshiba_unsol_event(struct hda_codec *codec, 11275 unsigned int res) 11276{ 11277 if ((res >> 26) != ALC880_HP_EVENT) 11278 return; 11279 alc268_toshiba_automute(codec); 11280} 11281 11282static void alc268_acer_unsol_event(struct hda_codec *codec, 11283 unsigned int res) 11284{ 11285 if ((res >> 26) != ALC880_HP_EVENT) 11286 return; 11287 alc268_acer_automute(codec, 1); 11288} 11289 11290static void alc268_acer_init_hook(struct hda_codec *codec) 11291{ 11292 alc268_acer_automute(codec, 1); 11293} 11294 11295/* toggle speaker-output according to the hp-jack state */ 11296static void alc268_aspire_one_speaker_automute(struct hda_codec *codec) 11297{ 11298 unsigned int present; 11299 unsigned char bits; 11300 11301 present = snd_hda_codec_read(codec, 0x15, 0, 11302 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 11303 bits = present ? AMP_IN_MUTE(0) : 0; 11304 snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0, 11305 AMP_IN_MUTE(0), bits); 11306 snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1, 11307 AMP_IN_MUTE(0), bits); 11308} 11309 11310 11311static void alc268_acer_mic_automute(struct hda_codec *codec) 11312{ 11313 unsigned int present; 11314 11315 present = snd_hda_codec_read(codec, 0x18, 0, 11316 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 11317 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL, 11318 present ? 0x0 : 0x6); 11319} 11320 11321static void alc268_acer_lc_unsol_event(struct hda_codec *codec, 11322 unsigned int res) 11323{ 11324 if ((res >> 26) == ALC880_HP_EVENT) 11325 alc268_aspire_one_speaker_automute(codec); 11326 if ((res >> 26) == ALC880_MIC_EVENT) 11327 alc268_acer_mic_automute(codec); 11328} 11329 11330static void alc268_acer_lc_init_hook(struct hda_codec *codec) 11331{ 11332 alc268_aspire_one_speaker_automute(codec); 11333 alc268_acer_mic_automute(codec); 11334} 11335 11336static struct snd_kcontrol_new alc268_dell_mixer[] = { 11337 /* output mixer control */ 11338 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 11339 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 11340 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 11341 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 11342 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 11343 HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT), 11344 { } 11345}; 11346 11347static struct hda_verb alc268_dell_verbs[] = { 11348 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 11349 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 11350 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 11351 { } 11352}; 11353 11354/* mute/unmute internal speaker according to the hp jack and mute state */ 11355static void alc268_dell_automute(struct hda_codec *codec) 11356{ 11357 unsigned int present; 11358 unsigned int mute; 11359 11360 present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0); 11361 if (present & 0x80000000) 11362 mute = HDA_AMP_MUTE; 11363 else 11364 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0); 11365 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 11366 HDA_AMP_MUTE, mute); 11367} 11368 11369static void alc268_dell_unsol_event(struct hda_codec *codec, 11370 unsigned int res) 11371{ 11372 if ((res >> 26) != ALC880_HP_EVENT) 11373 return; 11374 alc268_dell_automute(codec); 11375} 11376 11377#define alc268_dell_init_hook alc268_dell_automute 11378 11379static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = { 11380 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT), 11381 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 11382 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT), 11383 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 11384 HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT), 11385 HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT), 11386 HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT), 11387 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 11388 { } 11389}; 11390 11391static struct hda_verb alc267_quanta_il1_verbs[] = { 11392 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 11393 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, 11394 { } 11395}; 11396 11397static void alc267_quanta_il1_hp_automute(struct hda_codec *codec) 11398{ 11399 unsigned int present; 11400 11401 present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0) 11402 & AC_PINSENSE_PRESENCE; 11403 snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 11404 present ? 0 : PIN_OUT); 11405} 11406 11407static void alc267_quanta_il1_mic_automute(struct hda_codec *codec) 11408{ 11409 unsigned int present; 11410 11411 present = snd_hda_codec_read(codec, 0x18, 0, 11412 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 11413 snd_hda_codec_write(codec, 0x23, 0, 11414 AC_VERB_SET_CONNECT_SEL, 11415 present ? 0x00 : 0x01); 11416} 11417 11418static void alc267_quanta_il1_automute(struct hda_codec *codec) 11419{ 11420 alc267_quanta_il1_hp_automute(codec); 11421 alc267_quanta_il1_mic_automute(codec); 11422} 11423 11424static void alc267_quanta_il1_unsol_event(struct hda_codec *codec, 11425 unsigned int res) 11426{ 11427 switch (res >> 26) { 11428 case ALC880_HP_EVENT: 11429 alc267_quanta_il1_hp_automute(codec); 11430 break; 11431 case ALC880_MIC_EVENT: 11432 alc267_quanta_il1_mic_automute(codec); 11433 break; 11434 } 11435} 11436 11437/* 11438 * generic initialization of ADC, input mixers and output mixers 11439 */ 11440static struct hda_verb alc268_base_init_verbs[] = { 11441 /* Unmute DAC0-1 and set vol = 0 */ 11442 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 11443 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 11444 11445 /* 11446 * Set up output mixers (0x0c - 0x0e) 11447 */ 11448 /* set vol=0 to output mixers */ 11449 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11450 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00}, 11451 11452 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11453 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11454 11455 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 11456 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 11457 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 11458 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 11459 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 11460 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 11461 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 11462 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 11463 11464 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11465 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11466 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11467 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11468 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11469 11470 /* set PCBEEP vol = 0, mute connections */ 11471 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11472 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 11473 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 11474 11475 /* Unmute Selector 23h,24h and set the default input to mic-in */ 11476 11477 {0x23, AC_VERB_SET_CONNECT_SEL, 0x00}, 11478 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11479 {0x24, AC_VERB_SET_CONNECT_SEL, 0x00}, 11480 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11481 11482 { } 11483}; 11484 11485/* 11486 * generic initialization of ADC, input mixers and output mixers 11487 */ 11488static struct hda_verb alc268_volume_init_verbs[] = { 11489 /* set output DAC */ 11490 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 11491 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 11492 11493 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 11494 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 11495 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 11496 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 11497 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 11498 11499 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11500 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11501 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11502 11503 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11504 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11505 11506 /* set PCBEEP vol = 0, mute connections */ 11507 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11508 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 11509 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 11510 11511 { } 11512}; 11513 11514static struct snd_kcontrol_new alc268_capture_alt_mixer[] = { 11515 HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT), 11516 HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT), 11517 { 11518 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11519 /* The multiple "Capture Source" controls confuse alsamixer 11520 * So call somewhat different.. 11521 */ 11522 /* .name = "Capture Source", */ 11523 .name = "Input Source", 11524 .count = 1, 11525 .info = alc_mux_enum_info, 11526 .get = alc_mux_enum_get, 11527 .put = alc_mux_enum_put, 11528 }, 11529 { } /* end */ 11530}; 11531 11532static struct snd_kcontrol_new alc268_capture_mixer[] = { 11533 HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT), 11534 HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT), 11535 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT), 11536 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT), 11537 { 11538 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11539 /* The multiple "Capture Source" controls confuse alsamixer 11540 * So call somewhat different.. 11541 */ 11542 /* .name = "Capture Source", */ 11543 .name = "Input Source", 11544 .count = 2, 11545 .info = alc_mux_enum_info, 11546 .get = alc_mux_enum_get, 11547 .put = alc_mux_enum_put, 11548 }, 11549 { } /* end */ 11550}; 11551 11552static struct hda_input_mux alc268_capture_source = { 11553 .num_items = 4, 11554 .items = { 11555 { "Mic", 0x0 }, 11556 { "Front Mic", 0x1 }, 11557 { "Line", 0x2 }, 11558 { "CD", 0x3 }, 11559 }, 11560}; 11561 11562static struct hda_input_mux alc268_acer_capture_source = { 11563 .num_items = 3, 11564 .items = { 11565 { "Mic", 0x0 }, 11566 { "Internal Mic", 0x1 }, 11567 { "Line", 0x2 }, 11568 }, 11569}; 11570 11571static struct hda_input_mux alc268_acer_dmic_capture_source = { 11572 .num_items = 3, 11573 .items = { 11574 { "Mic", 0x0 }, 11575 { "Internal Mic", 0x6 }, 11576 { "Line", 0x2 }, 11577 }, 11578}; 11579 11580#ifdef CONFIG_SND_DEBUG 11581static struct snd_kcontrol_new alc268_test_mixer[] = { 11582 /* Volume widgets */ 11583 HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT), 11584 HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT), 11585 HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT), 11586 HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT), 11587 HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT), 11588 HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT), 11589 HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT), 11590 HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT), 11591 HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT), 11592 HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT), 11593 HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT), 11594 HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT), 11595 HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT), 11596 /* The below appears problematic on some hardwares */ 11597 /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/ 11598 HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT), 11599 HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT), 11600 HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT), 11601 HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT), 11602 11603 /* Modes for retasking pin widgets */ 11604 ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT), 11605 ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT), 11606 ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT), 11607 ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT), 11608 11609 /* Controls for GPIO pins, assuming they are configured as outputs */ 11610 ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01), 11611 ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02), 11612 ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04), 11613 ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08), 11614 11615 /* Switches to allow the digital SPDIF output pin to be enabled. 11616 * The ALC268 does not have an SPDIF input. 11617 */ 11618 ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01), 11619 11620 /* A switch allowing EAPD to be enabled. Some laptops seem to use 11621 * this output to turn on an external amplifier. 11622 */ 11623 ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02), 11624 ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02), 11625 11626 { } /* end */ 11627}; 11628#endif 11629 11630/* create input playback/capture controls for the given pin */ 11631static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid, 11632 const char *ctlname, int idx) 11633{ 11634 char name[32]; 11635 int err; 11636 11637 sprintf(name, "%s Playback Volume", ctlname); 11638 if (nid == 0x14) { 11639 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 11640 HDA_COMPOSE_AMP_VAL(0x02, 3, idx, 11641 HDA_OUTPUT)); 11642 if (err < 0) 11643 return err; 11644 } else if (nid == 0x15) { 11645 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 11646 HDA_COMPOSE_AMP_VAL(0x03, 3, idx, 11647 HDA_OUTPUT)); 11648 if (err < 0) 11649 return err; 11650 } else 11651 return -1; 11652 sprintf(name, "%s Playback Switch", ctlname); 11653 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 11654 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT)); 11655 if (err < 0) 11656 return err; 11657 return 0; 11658} 11659 11660/* add playback controls from the parsed DAC table */ 11661static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec, 11662 const struct auto_pin_cfg *cfg) 11663{ 11664 hda_nid_t nid; 11665 int err; 11666 11667 spec->multiout.num_dacs = 2; /* only use one dac */ 11668 spec->multiout.dac_nids = spec->private_dac_nids; 11669 spec->multiout.dac_nids[0] = 2; 11670 spec->multiout.dac_nids[1] = 3; 11671 11672 nid = cfg->line_out_pins[0]; 11673 if (nid) 11674 alc268_new_analog_output(spec, nid, "Front", 0); 11675 11676 nid = cfg->speaker_pins[0]; 11677 if (nid == 0x1d) { 11678 err = add_control(spec, ALC_CTL_WIDGET_VOL, 11679 "Speaker Playback Volume", 11680 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT)); 11681 if (err < 0) 11682 return err; 11683 } 11684 nid = cfg->hp_pins[0]; 11685 if (nid) 11686 alc268_new_analog_output(spec, nid, "Headphone", 0); 11687 11688 nid = cfg->line_out_pins[1] | cfg->line_out_pins[2]; 11689 if (nid == 0x16) { 11690 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 11691 "Mono Playback Switch", 11692 HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT)); 11693 if (err < 0) 11694 return err; 11695 } 11696 return 0; 11697} 11698 11699/* create playback/capture controls for input pins */ 11700static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec, 11701 const struct auto_pin_cfg *cfg) 11702{ 11703 struct hda_input_mux *imux = &spec->private_imux[0]; 11704 int i, idx1; 11705 11706 for (i = 0; i < AUTO_PIN_LAST; i++) { 11707 switch(cfg->input_pins[i]) { 11708 case 0x18: 11709 idx1 = 0; /* Mic 1 */ 11710 break; 11711 case 0x19: 11712 idx1 = 1; /* Mic 2 */ 11713 break; 11714 case 0x1a: 11715 idx1 = 2; /* Line In */ 11716 break; 11717 case 0x1c: 11718 idx1 = 3; /* CD */ 11719 break; 11720 case 0x12: 11721 case 0x13: 11722 idx1 = 6; /* digital mics */ 11723 break; 11724 default: 11725 continue; 11726 } 11727 imux->items[imux->num_items].label = auto_pin_cfg_labels[i]; 11728 imux->items[imux->num_items].index = idx1; 11729 imux->num_items++; 11730 } 11731 return 0; 11732} 11733 11734static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec) 11735{ 11736 struct alc_spec *spec = codec->spec; 11737 hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0]; 11738 hda_nid_t hp_nid = spec->autocfg.hp_pins[0]; 11739 hda_nid_t line_nid = spec->autocfg.line_out_pins[0]; 11740 unsigned int dac_vol1, dac_vol2; 11741 11742 if (speaker_nid) { 11743 snd_hda_codec_write(codec, speaker_nid, 0, 11744 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 11745 snd_hda_codec_write(codec, 0x0f, 0, 11746 AC_VERB_SET_AMP_GAIN_MUTE, 11747 AMP_IN_UNMUTE(1)); 11748 snd_hda_codec_write(codec, 0x10, 0, 11749 AC_VERB_SET_AMP_GAIN_MUTE, 11750 AMP_IN_UNMUTE(1)); 11751 } else { 11752 snd_hda_codec_write(codec, 0x0f, 0, 11753 AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)); 11754 snd_hda_codec_write(codec, 0x10, 0, 11755 AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)); 11756 } 11757 11758 dac_vol1 = dac_vol2 = 0xb000 | 0x40; /* set max volume */ 11759 if (line_nid == 0x14) 11760 dac_vol2 = AMP_OUT_ZERO; 11761 else if (line_nid == 0x15) 11762 dac_vol1 = AMP_OUT_ZERO; 11763 if (hp_nid == 0x14) 11764 dac_vol2 = AMP_OUT_ZERO; 11765 else if (hp_nid == 0x15) 11766 dac_vol1 = AMP_OUT_ZERO; 11767 if (line_nid != 0x16 || hp_nid != 0x16 || 11768 spec->autocfg.line_out_pins[1] != 0x16 || 11769 spec->autocfg.line_out_pins[2] != 0x16) 11770 dac_vol1 = dac_vol2 = AMP_OUT_ZERO; 11771 11772 snd_hda_codec_write(codec, 0x02, 0, 11773 AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1); 11774 snd_hda_codec_write(codec, 0x03, 0, 11775 AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2); 11776} 11777 11778/* pcm configuration: identiacal with ALC880 */ 11779#define alc268_pcm_analog_playback alc880_pcm_analog_playback 11780#define alc268_pcm_analog_capture alc880_pcm_analog_capture 11781#define alc268_pcm_analog_alt_capture alc880_pcm_analog_alt_capture 11782#define alc268_pcm_digital_playback alc880_pcm_digital_playback 11783 11784/* 11785 * BIOS auto configuration 11786 */ 11787static int alc268_parse_auto_config(struct hda_codec *codec) 11788{ 11789 struct alc_spec *spec = codec->spec; 11790 int err; 11791 static hda_nid_t alc268_ignore[] = { 0 }; 11792 11793 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 11794 alc268_ignore); 11795 if (err < 0) 11796 return err; 11797 if (!spec->autocfg.line_outs) 11798 return 0; /* can't find valid BIOS pin config */ 11799 11800 err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg); 11801 if (err < 0) 11802 return err; 11803 err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg); 11804 if (err < 0) 11805 return err; 11806 11807 spec->multiout.max_channels = 2; 11808 11809 /* digital only support output */ 11810 if (spec->autocfg.dig_out_pin) 11811 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID; 11812 11813 if (spec->kctls.list) 11814 add_mixer(spec, spec->kctls.list); 11815 11816 if (spec->autocfg.speaker_pins[0] != 0x1d) 11817 add_mixer(spec, alc268_beep_mixer); 11818 11819 add_verb(spec, alc268_volume_init_verbs); 11820 spec->num_mux_defs = 1; 11821 spec->input_mux = &spec->private_imux[0]; 11822 11823 err = alc_auto_add_mic_boost(codec); 11824 if (err < 0) 11825 return err; 11826 11827 store_pin_configs(codec); 11828 return 1; 11829} 11830 11831#define alc268_auto_init_multi_out alc882_auto_init_multi_out 11832#define alc268_auto_init_hp_out alc882_auto_init_hp_out 11833#define alc268_auto_init_analog_input alc882_auto_init_analog_input 11834 11835/* init callback for auto-configuration model -- overriding the default init */ 11836static void alc268_auto_init(struct hda_codec *codec) 11837{ 11838 struct alc_spec *spec = codec->spec; 11839 alc268_auto_init_multi_out(codec); 11840 alc268_auto_init_hp_out(codec); 11841 alc268_auto_init_mono_speaker_out(codec); 11842 alc268_auto_init_analog_input(codec); 11843 if (spec->unsol_event) 11844 alc_inithook(codec); 11845} 11846 11847/* 11848 * configuration and preset 11849 */ 11850static const char *alc268_models[ALC268_MODEL_LAST] = { 11851 [ALC267_QUANTA_IL1] = "quanta-il1", 11852 [ALC268_3ST] = "3stack", 11853 [ALC268_TOSHIBA] = "toshiba", 11854 [ALC268_ACER] = "acer", 11855 [ALC268_ACER_DMIC] = "acer-dmic", 11856 [ALC268_ACER_ASPIRE_ONE] = "acer-aspire", 11857 [ALC268_DELL] = "dell", 11858 [ALC268_ZEPTO] = "zepto", 11859#ifdef CONFIG_SND_DEBUG 11860 [ALC268_TEST] = "test", 11861#endif 11862 [ALC268_AUTO] = "auto", 11863}; 11864 11865static struct snd_pci_quirk alc268_cfg_tbl[] = { 11866 SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER), 11867 SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER), 11868 SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER), 11869 SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER), 11870 SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER), 11871 SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One", 11872 ALC268_ACER_ASPIRE_ONE), 11873 SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL), 11874 SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron Mini9", ALC268_DELL), 11875 SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA), 11876 SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST), 11877 SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA), 11878 SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA), 11879 SND_PCI_QUIRK(0x1179, 0xff64, "TOSHIBA L305", ALC268_TOSHIBA), 11880 SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA), 11881 SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER), 11882 SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1), 11883 SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO), 11884 {} 11885}; 11886 11887static struct alc_config_preset alc268_presets[] = { 11888 [ALC267_QUANTA_IL1] = { 11889 .mixers = { alc267_quanta_il1_mixer }, 11890 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 11891 alc267_quanta_il1_verbs }, 11892 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 11893 .dac_nids = alc268_dac_nids, 11894 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 11895 .adc_nids = alc268_adc_nids_alt, 11896 .hp_nid = 0x03, 11897 .num_channel_mode = ARRAY_SIZE(alc268_modes), 11898 .channel_mode = alc268_modes, 11899 .input_mux = &alc268_capture_source, 11900 .unsol_event = alc267_quanta_il1_unsol_event, 11901 .init_hook = alc267_quanta_il1_automute, 11902 }, 11903 [ALC268_3ST] = { 11904 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer, 11905 alc268_beep_mixer }, 11906 .init_verbs = { alc268_base_init_verbs }, 11907 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 11908 .dac_nids = alc268_dac_nids, 11909 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 11910 .adc_nids = alc268_adc_nids_alt, 11911 .capsrc_nids = alc268_capsrc_nids, 11912 .hp_nid = 0x03, 11913 .dig_out_nid = ALC268_DIGOUT_NID, 11914 .num_channel_mode = ARRAY_SIZE(alc268_modes), 11915 .channel_mode = alc268_modes, 11916 .input_mux = &alc268_capture_source, 11917 }, 11918 [ALC268_TOSHIBA] = { 11919 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer, 11920 alc268_beep_mixer }, 11921 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 11922 alc268_toshiba_verbs }, 11923 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 11924 .dac_nids = alc268_dac_nids, 11925 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 11926 .adc_nids = alc268_adc_nids_alt, 11927 .capsrc_nids = alc268_capsrc_nids, 11928 .hp_nid = 0x03, 11929 .num_channel_mode = ARRAY_SIZE(alc268_modes), 11930 .channel_mode = alc268_modes, 11931 .input_mux = &alc268_capture_source, 11932 .unsol_event = alc268_toshiba_unsol_event, 11933 .init_hook = alc268_toshiba_automute, 11934 }, 11935 [ALC268_ACER] = { 11936 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer, 11937 alc268_beep_mixer }, 11938 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 11939 alc268_acer_verbs }, 11940 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 11941 .dac_nids = alc268_dac_nids, 11942 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 11943 .adc_nids = alc268_adc_nids_alt, 11944 .capsrc_nids = alc268_capsrc_nids, 11945 .hp_nid = 0x02, 11946 .num_channel_mode = ARRAY_SIZE(alc268_modes), 11947 .channel_mode = alc268_modes, 11948 .input_mux = &alc268_acer_capture_source, 11949 .unsol_event = alc268_acer_unsol_event, 11950 .init_hook = alc268_acer_init_hook, 11951 }, 11952 [ALC268_ACER_DMIC] = { 11953 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer, 11954 alc268_beep_mixer }, 11955 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 11956 alc268_acer_verbs }, 11957 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 11958 .dac_nids = alc268_dac_nids, 11959 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 11960 .adc_nids = alc268_adc_nids_alt, 11961 .capsrc_nids = alc268_capsrc_nids, 11962 .hp_nid = 0x02, 11963 .num_channel_mode = ARRAY_SIZE(alc268_modes), 11964 .channel_mode = alc268_modes, 11965 .input_mux = &alc268_acer_dmic_capture_source, 11966 .unsol_event = alc268_acer_unsol_event, 11967 .init_hook = alc268_acer_init_hook, 11968 }, 11969 [ALC268_ACER_ASPIRE_ONE] = { 11970 .mixers = { alc268_acer_aspire_one_mixer, 11971 alc268_capture_alt_mixer }, 11972 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 11973 alc268_acer_aspire_one_verbs }, 11974 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 11975 .dac_nids = alc268_dac_nids, 11976 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 11977 .adc_nids = alc268_adc_nids_alt, 11978 .capsrc_nids = alc268_capsrc_nids, 11979 .hp_nid = 0x03, 11980 .num_channel_mode = ARRAY_SIZE(alc268_modes), 11981 .channel_mode = alc268_modes, 11982 .input_mux = &alc268_acer_lc_capture_source, 11983 .unsol_event = alc268_acer_lc_unsol_event, 11984 .init_hook = alc268_acer_lc_init_hook, 11985 }, 11986 [ALC268_DELL] = { 11987 .mixers = { alc268_dell_mixer, alc268_beep_mixer }, 11988 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 11989 alc268_dell_verbs }, 11990 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 11991 .dac_nids = alc268_dac_nids, 11992 .hp_nid = 0x02, 11993 .num_channel_mode = ARRAY_SIZE(alc268_modes), 11994 .channel_mode = alc268_modes, 11995 .unsol_event = alc268_dell_unsol_event, 11996 .init_hook = alc268_dell_init_hook, 11997 .input_mux = &alc268_capture_source, 11998 }, 11999 [ALC268_ZEPTO] = { 12000 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer, 12001 alc268_beep_mixer }, 12002 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 12003 alc268_toshiba_verbs }, 12004 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 12005 .dac_nids = alc268_dac_nids, 12006 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 12007 .adc_nids = alc268_adc_nids_alt, 12008 .capsrc_nids = alc268_capsrc_nids, 12009 .hp_nid = 0x03, 12010 .dig_out_nid = ALC268_DIGOUT_NID, 12011 .num_channel_mode = ARRAY_SIZE(alc268_modes), 12012 .channel_mode = alc268_modes, 12013 .input_mux = &alc268_capture_source, 12014 .unsol_event = alc268_toshiba_unsol_event, 12015 .init_hook = alc268_toshiba_automute 12016 }, 12017#ifdef CONFIG_SND_DEBUG 12018 [ALC268_TEST] = { 12019 .mixers = { alc268_test_mixer, alc268_capture_mixer }, 12020 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 12021 alc268_volume_init_verbs }, 12022 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 12023 .dac_nids = alc268_dac_nids, 12024 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 12025 .adc_nids = alc268_adc_nids_alt, 12026 .capsrc_nids = alc268_capsrc_nids, 12027 .hp_nid = 0x03, 12028 .dig_out_nid = ALC268_DIGOUT_NID, 12029 .num_channel_mode = ARRAY_SIZE(alc268_modes), 12030 .channel_mode = alc268_modes, 12031 .input_mux = &alc268_capture_source, 12032 }, 12033#endif 12034}; 12035 12036static int patch_alc268(struct hda_codec *codec) 12037{ 12038 struct alc_spec *spec; 12039 int board_config; 12040 int err; 12041 12042 spec = kcalloc(1, sizeof(*spec), GFP_KERNEL); 12043 if (spec == NULL) 12044 return -ENOMEM; 12045 12046 codec->spec = spec; 12047 12048 board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST, 12049 alc268_models, 12050 alc268_cfg_tbl); 12051 12052 if (board_config < 0 || board_config >= ALC268_MODEL_LAST) { 12053 printk(KERN_INFO "hda_codec: Unknown model for ALC268, " 12054 "trying auto-probe from BIOS...\n"); 12055 board_config = ALC268_AUTO; 12056 } 12057 12058 if (board_config == ALC268_AUTO) { 12059 /* automatic parse from the BIOS config */ 12060 err = alc268_parse_auto_config(codec); 12061 if (err < 0) { 12062 alc_free(codec); 12063 return err; 12064 } else if (!err) { 12065 printk(KERN_INFO 12066 "hda_codec: Cannot set up configuration " 12067 "from BIOS. Using base mode...\n"); 12068 board_config = ALC268_3ST; 12069 } 12070 } 12071 12072 err = snd_hda_attach_beep_device(codec, 0x1); 12073 if (err < 0) { 12074 alc_free(codec); 12075 return err; 12076 } 12077 12078 if (board_config != ALC268_AUTO) 12079 setup_preset(spec, &alc268_presets[board_config]); 12080 12081 if (codec->vendor_id == 0x10ec0267) { 12082 spec->stream_name_analog = "ALC267 Analog"; 12083 spec->stream_name_digital = "ALC267 Digital"; 12084 } else { 12085 spec->stream_name_analog = "ALC268 Analog"; 12086 spec->stream_name_digital = "ALC268 Digital"; 12087 } 12088 12089 spec->stream_analog_playback = &alc268_pcm_analog_playback; 12090 spec->stream_analog_capture = &alc268_pcm_analog_capture; 12091 spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture; 12092 12093 spec->stream_digital_playback = &alc268_pcm_digital_playback; 12094 12095 if (!query_amp_caps(codec, 0x1d, HDA_INPUT)) 12096 /* override the amp caps for beep generator */ 12097 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT, 12098 (0x0c << AC_AMPCAP_OFFSET_SHIFT) | 12099 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) | 12100 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) | 12101 (0 << AC_AMPCAP_MUTE_SHIFT)); 12102 12103 if (!spec->adc_nids && spec->input_mux) { 12104 /* check whether NID 0x07 is valid */ 12105 unsigned int wcap = get_wcaps(codec, 0x07); 12106 int i; 12107 12108 /* get type */ 12109 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 12110 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) { 12111 spec->adc_nids = alc268_adc_nids_alt; 12112 spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt); 12113 add_mixer(spec, alc268_capture_alt_mixer); 12114 } else { 12115 spec->adc_nids = alc268_adc_nids; 12116 spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids); 12117 add_mixer(spec, alc268_capture_mixer); 12118 } 12119 spec->capsrc_nids = alc268_capsrc_nids; 12120 /* set default input source */ 12121 for (i = 0; i < spec->num_adc_nids; i++) 12122 snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i], 12123 0, AC_VERB_SET_CONNECT_SEL, 12124 spec->input_mux->items[0].index); 12125 } 12126 12127 spec->vmaster_nid = 0x02; 12128 12129 codec->patch_ops = alc_patch_ops; 12130 if (board_config == ALC268_AUTO) 12131 spec->init_hook = alc268_auto_init; 12132 12133 codec->proc_widget_hook = print_realtek_coef; 12134 12135 return 0; 12136} 12137 12138/* 12139 * ALC269 channel source setting (2 channel) 12140 */ 12141#define ALC269_DIGOUT_NID ALC880_DIGOUT_NID 12142 12143#define alc269_dac_nids alc260_dac_nids 12144 12145static hda_nid_t alc269_adc_nids[1] = { 12146 /* ADC1 */ 12147 0x08, 12148}; 12149 12150static hda_nid_t alc269_capsrc_nids[1] = { 12151 0x23, 12152}; 12153 12154/* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24), 12155 * not a mux! 12156 */ 12157 12158static struct hda_input_mux alc269_eeepc_dmic_capture_source = { 12159 .num_items = 2, 12160 .items = { 12161 { "i-Mic", 0x5 }, 12162 { "e-Mic", 0x0 }, 12163 }, 12164}; 12165 12166static struct hda_input_mux alc269_eeepc_amic_capture_source = { 12167 .num_items = 2, 12168 .items = { 12169 { "i-Mic", 0x1 }, 12170 { "e-Mic", 0x0 }, 12171 }, 12172}; 12173 12174#define alc269_modes alc260_modes 12175#define alc269_capture_source alc880_lg_lw_capture_source 12176 12177static struct snd_kcontrol_new alc269_base_mixer[] = { 12178 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 12179 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 12180 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 12181 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 12182 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 12183 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 12184 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 12185 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 12186 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 12187 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 12188 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 12189 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT), 12190 { } /* end */ 12191}; 12192 12193static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = { 12194 /* output mixer control */ 12195 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol), 12196 { 12197 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 12198 .name = "Master Playback Switch", 12199 .info = snd_hda_mixer_amp_switch_info, 12200 .get = snd_hda_mixer_amp_switch_get, 12201 .put = alc268_acer_master_sw_put, 12202 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 12203 }, 12204 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 12205 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 12206 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 12207 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 12208 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 12209 HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT), 12210 { } 12211}; 12212 12213static struct snd_kcontrol_new alc269_lifebook_mixer[] = { 12214 /* output mixer control */ 12215 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol), 12216 { 12217 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 12218 .name = "Master Playback Switch", 12219 .info = snd_hda_mixer_amp_switch_info, 12220 .get = snd_hda_mixer_amp_switch_get, 12221 .put = alc268_acer_master_sw_put, 12222 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 12223 }, 12224 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 12225 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 12226 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 12227 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 12228 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 12229 HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT), 12230 HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT), 12231 HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT), 12232 HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT), 12233 { } 12234}; 12235 12236/* bind volumes of both NID 0x0c and 0x0d */ 12237static struct hda_bind_ctls alc269_epc_bind_vol = { 12238 .ops = &snd_hda_bind_vol, 12239 .values = { 12240 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT), 12241 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT), 12242 0 12243 }, 12244}; 12245 12246static struct snd_kcontrol_new alc269_eeepc_mixer[] = { 12247 HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 12248 HDA_BIND_VOL("LineOut Playback Volume", &alc269_epc_bind_vol), 12249 HDA_CODEC_MUTE("LineOut Playback Switch", 0x15, 0x0, HDA_OUTPUT), 12250 { } /* end */ 12251}; 12252 12253/* capture mixer elements */ 12254static struct snd_kcontrol_new alc269_epc_capture_mixer[] = { 12255 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 12256 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 12257 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 12258 { } /* end */ 12259}; 12260 12261/* FSC amilo */ 12262static struct snd_kcontrol_new alc269_fujitsu_mixer[] = { 12263 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 12264 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 12265 HDA_BIND_VOL("PCM Playback Volume", &alc269_epc_bind_vol), 12266 { } /* end */ 12267}; 12268 12269static struct hda_verb alc269_quanta_fl1_verbs[] = { 12270 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 12271 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 12272 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 12273 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 12274 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 12275 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 12276 { } 12277}; 12278 12279static struct hda_verb alc269_lifebook_verbs[] = { 12280 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 12281 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, 12282 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 12283 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 12284 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 12285 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12286 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 12287 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 12288 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 12289 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 12290 { } 12291}; 12292 12293/* toggle speaker-output according to the hp-jack state */ 12294static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec) 12295{ 12296 unsigned int present; 12297 unsigned char bits; 12298 12299 present = snd_hda_codec_read(codec, 0x15, 0, 12300 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 12301 bits = present ? AMP_IN_MUTE(0) : 0; 12302 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 12303 AMP_IN_MUTE(0), bits); 12304 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 12305 AMP_IN_MUTE(0), bits); 12306 12307 snd_hda_codec_write(codec, 0x20, 0, 12308 AC_VERB_SET_COEF_INDEX, 0x0c); 12309 snd_hda_codec_write(codec, 0x20, 0, 12310 AC_VERB_SET_PROC_COEF, 0x680); 12311 12312 snd_hda_codec_write(codec, 0x20, 0, 12313 AC_VERB_SET_COEF_INDEX, 0x0c); 12314 snd_hda_codec_write(codec, 0x20, 0, 12315 AC_VERB_SET_PROC_COEF, 0x480); 12316} 12317 12318/* toggle speaker-output according to the hp-jacks state */ 12319static void alc269_lifebook_speaker_automute(struct hda_codec *codec) 12320{ 12321 unsigned int present; 12322 unsigned char bits; 12323 12324 /* Check laptop headphone socket */ 12325 present = snd_hda_codec_read(codec, 0x15, 0, 12326 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 12327 12328 /* Check port replicator headphone socket */ 12329 present |= snd_hda_codec_read(codec, 0x1a, 0, 12330 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 12331 12332 bits = present ? AMP_IN_MUTE(0) : 0; 12333 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 12334 AMP_IN_MUTE(0), bits); 12335 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 12336 AMP_IN_MUTE(0), bits); 12337 12338 snd_hda_codec_write(codec, 0x20, 0, 12339 AC_VERB_SET_COEF_INDEX, 0x0c); 12340 snd_hda_codec_write(codec, 0x20, 0, 12341 AC_VERB_SET_PROC_COEF, 0x680); 12342 12343 snd_hda_codec_write(codec, 0x20, 0, 12344 AC_VERB_SET_COEF_INDEX, 0x0c); 12345 snd_hda_codec_write(codec, 0x20, 0, 12346 AC_VERB_SET_PROC_COEF, 0x480); 12347} 12348 12349static void alc269_quanta_fl1_mic_automute(struct hda_codec *codec) 12350{ 12351 unsigned int present; 12352 12353 present = snd_hda_codec_read(codec, 0x18, 0, 12354 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 12355 snd_hda_codec_write(codec, 0x23, 0, 12356 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x1); 12357} 12358 12359static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec) 12360{ 12361 unsigned int present_laptop; 12362 unsigned int present_dock; 12363 12364 present_laptop = snd_hda_codec_read(codec, 0x18, 0, 12365 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 12366 12367 present_dock = snd_hda_codec_read(codec, 0x1b, 0, 12368 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 12369 12370 /* Laptop mic port overrides dock mic port, design decision */ 12371 if (present_dock) 12372 snd_hda_codec_write(codec, 0x23, 0, 12373 AC_VERB_SET_CONNECT_SEL, 0x3); 12374 if (present_laptop) 12375 snd_hda_codec_write(codec, 0x23, 0, 12376 AC_VERB_SET_CONNECT_SEL, 0x0); 12377 if (!present_dock && !present_laptop) 12378 snd_hda_codec_write(codec, 0x23, 0, 12379 AC_VERB_SET_CONNECT_SEL, 0x1); 12380} 12381 12382static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec, 12383 unsigned int res) 12384{ 12385 if ((res >> 26) == ALC880_HP_EVENT) 12386 alc269_quanta_fl1_speaker_automute(codec); 12387 if ((res >> 26) == ALC880_MIC_EVENT) 12388 alc269_quanta_fl1_mic_automute(codec); 12389} 12390 12391static void alc269_lifebook_unsol_event(struct hda_codec *codec, 12392 unsigned int res) 12393{ 12394 if ((res >> 26) == ALC880_HP_EVENT) 12395 alc269_lifebook_speaker_automute(codec); 12396 if ((res >> 26) == ALC880_MIC_EVENT) 12397 alc269_lifebook_mic_autoswitch(codec); 12398} 12399 12400static void alc269_quanta_fl1_init_hook(struct hda_codec *codec) 12401{ 12402 alc269_quanta_fl1_speaker_automute(codec); 12403 alc269_quanta_fl1_mic_automute(codec); 12404} 12405 12406static void alc269_lifebook_init_hook(struct hda_codec *codec) 12407{ 12408 alc269_lifebook_speaker_automute(codec); 12409 alc269_lifebook_mic_autoswitch(codec); 12410} 12411 12412static struct hda_verb alc269_eeepc_dmic_init_verbs[] = { 12413 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 12414 {0x23, AC_VERB_SET_CONNECT_SEL, 0x05}, 12415 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 }, 12416 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))}, 12417 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 12418 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 12419 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 12420 {} 12421}; 12422 12423static struct hda_verb alc269_eeepc_amic_init_verbs[] = { 12424 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 12425 {0x23, AC_VERB_SET_CONNECT_SEL, 0x01}, 12426 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 }, 12427 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))}, 12428 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 12429 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 12430 {} 12431}; 12432 12433/* toggle speaker-output according to the hp-jack state */ 12434static void alc269_speaker_automute(struct hda_codec *codec) 12435{ 12436 unsigned int present; 12437 unsigned char bits; 12438 12439 present = snd_hda_codec_read(codec, 0x15, 0, 12440 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 12441 bits = present ? AMP_IN_MUTE(0) : 0; 12442 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 12443 AMP_IN_MUTE(0), bits); 12444 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 12445 AMP_IN_MUTE(0), bits); 12446} 12447 12448static void alc269_eeepc_dmic_automute(struct hda_codec *codec) 12449{ 12450 unsigned int present; 12451 12452 present = snd_hda_codec_read(codec, 0x18, 0, 12453 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 12454 snd_hda_codec_write(codec, 0x23, 0, 12455 AC_VERB_SET_CONNECT_SEL, (present ? 0 : 5)); 12456} 12457 12458static void alc269_eeepc_amic_automute(struct hda_codec *codec) 12459{ 12460 unsigned int present; 12461 12462 present = snd_hda_codec_read(codec, 0x18, 0, 12463 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 12464 snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE, 12465 0x7000 | (0x00 << 8) | (present ? 0 : 0x80)); 12466 snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE, 12467 0x7000 | (0x01 << 8) | (present ? 0x80 : 0)); 12468} 12469 12470/* unsolicited event for HP jack sensing */ 12471static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec, 12472 unsigned int res) 12473{ 12474 if ((res >> 26) == ALC880_HP_EVENT) 12475 alc269_speaker_automute(codec); 12476 12477 if ((res >> 26) == ALC880_MIC_EVENT) 12478 alc269_eeepc_dmic_automute(codec); 12479} 12480 12481static void alc269_eeepc_dmic_inithook(struct hda_codec *codec) 12482{ 12483 alc269_speaker_automute(codec); 12484 alc269_eeepc_dmic_automute(codec); 12485} 12486 12487/* unsolicited event for HP jack sensing */ 12488static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec, 12489 unsigned int res) 12490{ 12491 if ((res >> 26) == ALC880_HP_EVENT) 12492 alc269_speaker_automute(codec); 12493 12494 if ((res >> 26) == ALC880_MIC_EVENT) 12495 alc269_eeepc_amic_automute(codec); 12496} 12497 12498static void alc269_eeepc_amic_inithook(struct hda_codec *codec) 12499{ 12500 alc269_speaker_automute(codec); 12501 alc269_eeepc_amic_automute(codec); 12502} 12503 12504/* 12505 * generic initialization of ADC, input mixers and output mixers 12506 */ 12507static struct hda_verb alc269_init_verbs[] = { 12508 /* 12509 * Unmute ADC0 and set the default input to mic-in 12510 */ 12511 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12512 12513 /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the 12514 * analog-loopback mixer widget 12515 * Note: PASD motherboards uses the Line In 2 as the input for 12516 * front panel mic (mic 2) 12517 */ 12518 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 12519 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 12520 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 12521 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 12522 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 12523 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 12524 12525 /* 12526 * Set up output mixers (0x0c - 0x0e) 12527 */ 12528 /* set vol=0 to output mixers */ 12529 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 12530 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 12531 12532 /* set up input amps for analog loopback */ 12533 /* Amp Indices: DAC = 0, mixer = 1 */ 12534 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12535 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12536 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12537 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12538 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12539 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12540 12541 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 12542 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 12543 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 12544 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 12545 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 12546 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 12547 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 12548 12549 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12550 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12551 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12552 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12553 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12554 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12555 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12556 12557 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 12558 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 12559 12560 /* FIXME: use matrix-type input source selection */ 12561 /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */ 12562 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 12563 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 12564 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12565 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 12566 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 12567 12568 /* set EAPD */ 12569 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 12570 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 12571 { } 12572}; 12573 12574/* add playback controls from the parsed DAC table */ 12575static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec, 12576 const struct auto_pin_cfg *cfg) 12577{ 12578 hda_nid_t nid; 12579 int err; 12580 12581 spec->multiout.num_dacs = 1; /* only use one dac */ 12582 spec->multiout.dac_nids = spec->private_dac_nids; 12583 spec->multiout.dac_nids[0] = 2; 12584 12585 nid = cfg->line_out_pins[0]; 12586 if (nid) { 12587 err = add_control(spec, ALC_CTL_WIDGET_VOL, 12588 "Front Playback Volume", 12589 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT)); 12590 if (err < 0) 12591 return err; 12592 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 12593 "Front Playback Switch", 12594 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 12595 if (err < 0) 12596 return err; 12597 } 12598 12599 nid = cfg->speaker_pins[0]; 12600 if (nid) { 12601 if (!cfg->line_out_pins[0]) { 12602 err = add_control(spec, ALC_CTL_WIDGET_VOL, 12603 "Speaker Playback Volume", 12604 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, 12605 HDA_OUTPUT)); 12606 if (err < 0) 12607 return err; 12608 } 12609 if (nid == 0x16) { 12610 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 12611 "Speaker Playback Switch", 12612 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 12613 HDA_OUTPUT)); 12614 if (err < 0) 12615 return err; 12616 } else { 12617 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 12618 "Speaker Playback Switch", 12619 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 12620 HDA_OUTPUT)); 12621 if (err < 0) 12622 return err; 12623 } 12624 } 12625 nid = cfg->hp_pins[0]; 12626 if (nid) { 12627 /* spec->multiout.hp_nid = 2; */ 12628 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) { 12629 err = add_control(spec, ALC_CTL_WIDGET_VOL, 12630 "Headphone Playback Volume", 12631 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, 12632 HDA_OUTPUT)); 12633 if (err < 0) 12634 return err; 12635 } 12636 if (nid == 0x16) { 12637 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 12638 "Headphone Playback Switch", 12639 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 12640 HDA_OUTPUT)); 12641 if (err < 0) 12642 return err; 12643 } else { 12644 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 12645 "Headphone Playback Switch", 12646 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 12647 HDA_OUTPUT)); 12648 if (err < 0) 12649 return err; 12650 } 12651 } 12652 return 0; 12653} 12654 12655static int alc269_auto_create_analog_input_ctls(struct alc_spec *spec, 12656 const struct auto_pin_cfg *cfg) 12657{ 12658 int err; 12659 12660 err = alc880_auto_create_analog_input_ctls(spec, cfg); 12661 if (err < 0) 12662 return err; 12663 /* digital-mic input pin is excluded in alc880_auto_create..() 12664 * because it's under 0x18 12665 */ 12666 if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 || 12667 cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) { 12668 struct hda_input_mux *imux = &spec->private_imux[0]; 12669 imux->items[imux->num_items].label = "Int Mic"; 12670 imux->items[imux->num_items].index = 0x05; 12671 imux->num_items++; 12672 } 12673 return 0; 12674} 12675 12676#ifdef CONFIG_SND_HDA_POWER_SAVE 12677#define alc269_loopbacks alc880_loopbacks 12678#endif 12679 12680/* pcm configuration: identiacal with ALC880 */ 12681#define alc269_pcm_analog_playback alc880_pcm_analog_playback 12682#define alc269_pcm_analog_capture alc880_pcm_analog_capture 12683#define alc269_pcm_digital_playback alc880_pcm_digital_playback 12684#define alc269_pcm_digital_capture alc880_pcm_digital_capture 12685 12686/* 12687 * BIOS auto configuration 12688 */ 12689static int alc269_parse_auto_config(struct hda_codec *codec) 12690{ 12691 struct alc_spec *spec = codec->spec; 12692 int i, err; 12693 static hda_nid_t alc269_ignore[] = { 0x1d, 0 }; 12694 12695 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 12696 alc269_ignore); 12697 if (err < 0) 12698 return err; 12699 12700 err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg); 12701 if (err < 0) 12702 return err; 12703 err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg); 12704 if (err < 0) 12705 return err; 12706 12707 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 12708 12709 if (spec->autocfg.dig_out_pin) 12710 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID; 12711 12712 if (spec->kctls.list) 12713 add_mixer(spec, spec->kctls.list); 12714 12715 add_verb(spec, alc269_init_verbs); 12716 spec->num_mux_defs = 1; 12717 spec->input_mux = &spec->private_imux[0]; 12718 /* set default input source */ 12719 snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0], 12720 0, AC_VERB_SET_CONNECT_SEL, 12721 spec->input_mux->items[0].index); 12722 12723 err = alc_auto_add_mic_boost(codec); 12724 if (err < 0) 12725 return err; 12726 12727 if (!spec->cap_mixer) 12728 set_capture_mixer(spec); 12729 12730 store_pin_configs(codec); 12731 return 1; 12732} 12733 12734#define alc269_auto_init_multi_out alc882_auto_init_multi_out 12735#define alc269_auto_init_hp_out alc882_auto_init_hp_out 12736#define alc269_auto_init_analog_input alc882_auto_init_analog_input 12737 12738 12739/* init callback for auto-configuration model -- overriding the default init */ 12740static void alc269_auto_init(struct hda_codec *codec) 12741{ 12742 struct alc_spec *spec = codec->spec; 12743 alc269_auto_init_multi_out(codec); 12744 alc269_auto_init_hp_out(codec); 12745 alc269_auto_init_analog_input(codec); 12746 if (spec->unsol_event) 12747 alc_inithook(codec); 12748} 12749 12750/* 12751 * configuration and preset 12752 */ 12753static const char *alc269_models[ALC269_MODEL_LAST] = { 12754 [ALC269_BASIC] = "basic", 12755 [ALC269_QUANTA_FL1] = "quanta", 12756 [ALC269_ASUS_EEEPC_P703] = "eeepc-p703", 12757 [ALC269_ASUS_EEEPC_P901] = "eeepc-p901", 12758 [ALC269_FUJITSU] = "fujitsu", 12759 [ALC269_LIFEBOOK] = "lifebook" 12760}; 12761 12762static struct snd_pci_quirk alc269_cfg_tbl[] = { 12763 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1), 12764 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A", 12765 ALC269_ASUS_EEEPC_P703), 12766 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901", 12767 ALC269_ASUS_EEEPC_P901), 12768 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101", 12769 ALC269_ASUS_EEEPC_P901), 12770 SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU), 12771 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK), 12772 {} 12773}; 12774 12775static struct alc_config_preset alc269_presets[] = { 12776 [ALC269_BASIC] = { 12777 .mixers = { alc269_base_mixer }, 12778 .init_verbs = { alc269_init_verbs }, 12779 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 12780 .dac_nids = alc269_dac_nids, 12781 .hp_nid = 0x03, 12782 .num_channel_mode = ARRAY_SIZE(alc269_modes), 12783 .channel_mode = alc269_modes, 12784 .input_mux = &alc269_capture_source, 12785 }, 12786 [ALC269_QUANTA_FL1] = { 12787 .mixers = { alc269_quanta_fl1_mixer }, 12788 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs }, 12789 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 12790 .dac_nids = alc269_dac_nids, 12791 .hp_nid = 0x03, 12792 .num_channel_mode = ARRAY_SIZE(alc269_modes), 12793 .channel_mode = alc269_modes, 12794 .input_mux = &alc269_capture_source, 12795 .unsol_event = alc269_quanta_fl1_unsol_event, 12796 .init_hook = alc269_quanta_fl1_init_hook, 12797 }, 12798 [ALC269_ASUS_EEEPC_P703] = { 12799 .mixers = { alc269_eeepc_mixer }, 12800 .cap_mixer = alc269_epc_capture_mixer, 12801 .init_verbs = { alc269_init_verbs, 12802 alc269_eeepc_amic_init_verbs }, 12803 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 12804 .dac_nids = alc269_dac_nids, 12805 .hp_nid = 0x03, 12806 .num_channel_mode = ARRAY_SIZE(alc269_modes), 12807 .channel_mode = alc269_modes, 12808 .input_mux = &alc269_eeepc_amic_capture_source, 12809 .unsol_event = alc269_eeepc_amic_unsol_event, 12810 .init_hook = alc269_eeepc_amic_inithook, 12811 }, 12812 [ALC269_ASUS_EEEPC_P901] = { 12813 .mixers = { alc269_eeepc_mixer }, 12814 .cap_mixer = alc269_epc_capture_mixer, 12815 .init_verbs = { alc269_init_verbs, 12816 alc269_eeepc_dmic_init_verbs }, 12817 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 12818 .dac_nids = alc269_dac_nids, 12819 .hp_nid = 0x03, 12820 .num_channel_mode = ARRAY_SIZE(alc269_modes), 12821 .channel_mode = alc269_modes, 12822 .input_mux = &alc269_eeepc_dmic_capture_source, 12823 .unsol_event = alc269_eeepc_dmic_unsol_event, 12824 .init_hook = alc269_eeepc_dmic_inithook, 12825 }, 12826 [ALC269_FUJITSU] = { 12827 .mixers = { alc269_fujitsu_mixer }, 12828 .cap_mixer = alc269_epc_capture_mixer, 12829 .init_verbs = { alc269_init_verbs, 12830 alc269_eeepc_dmic_init_verbs }, 12831 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 12832 .dac_nids = alc269_dac_nids, 12833 .hp_nid = 0x03, 12834 .num_channel_mode = ARRAY_SIZE(alc269_modes), 12835 .channel_mode = alc269_modes, 12836 .input_mux = &alc269_eeepc_dmic_capture_source, 12837 .unsol_event = alc269_eeepc_dmic_unsol_event, 12838 .init_hook = alc269_eeepc_dmic_inithook, 12839 }, 12840 [ALC269_LIFEBOOK] = { 12841 .mixers = { alc269_lifebook_mixer }, 12842 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs }, 12843 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 12844 .dac_nids = alc269_dac_nids, 12845 .hp_nid = 0x03, 12846 .num_channel_mode = ARRAY_SIZE(alc269_modes), 12847 .channel_mode = alc269_modes, 12848 .input_mux = &alc269_capture_source, 12849 .unsol_event = alc269_lifebook_unsol_event, 12850 .init_hook = alc269_lifebook_init_hook, 12851 }, 12852}; 12853 12854static int patch_alc269(struct hda_codec *codec) 12855{ 12856 struct alc_spec *spec; 12857 int board_config; 12858 int err; 12859 12860 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 12861 if (spec == NULL) 12862 return -ENOMEM; 12863 12864 codec->spec = spec; 12865 12866 alc_fix_pll_init(codec, 0x20, 0x04, 15); 12867 12868 board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST, 12869 alc269_models, 12870 alc269_cfg_tbl); 12871 12872 if (board_config < 0) { 12873 printk(KERN_INFO "hda_codec: Unknown model for ALC269, " 12874 "trying auto-probe from BIOS...\n"); 12875 board_config = ALC269_AUTO; 12876 } 12877 12878 if (board_config == ALC269_AUTO) { 12879 /* automatic parse from the BIOS config */ 12880 err = alc269_parse_auto_config(codec); 12881 if (err < 0) { 12882 alc_free(codec); 12883 return err; 12884 } else if (!err) { 12885 printk(KERN_INFO 12886 "hda_codec: Cannot set up configuration " 12887 "from BIOS. Using base mode...\n"); 12888 board_config = ALC269_BASIC; 12889 } 12890 } 12891 12892 err = snd_hda_attach_beep_device(codec, 0x1); 12893 if (err < 0) { 12894 alc_free(codec); 12895 return err; 12896 } 12897 12898 if (board_config != ALC269_AUTO) 12899 setup_preset(spec, &alc269_presets[board_config]); 12900 12901 spec->stream_name_analog = "ALC269 Analog"; 12902 spec->stream_analog_playback = &alc269_pcm_analog_playback; 12903 spec->stream_analog_capture = &alc269_pcm_analog_capture; 12904 12905 spec->stream_name_digital = "ALC269 Digital"; 12906 spec->stream_digital_playback = &alc269_pcm_digital_playback; 12907 spec->stream_digital_capture = &alc269_pcm_digital_capture; 12908 12909 spec->adc_nids = alc269_adc_nids; 12910 spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids); 12911 spec->capsrc_nids = alc269_capsrc_nids; 12912 if (!spec->cap_mixer) 12913 set_capture_mixer(spec); 12914 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT); 12915 12916 codec->patch_ops = alc_patch_ops; 12917 if (board_config == ALC269_AUTO) 12918 spec->init_hook = alc269_auto_init; 12919#ifdef CONFIG_SND_HDA_POWER_SAVE 12920 if (!spec->loopback.amplist) 12921 spec->loopback.amplist = alc269_loopbacks; 12922#endif 12923 codec->proc_widget_hook = print_realtek_coef; 12924 12925 return 0; 12926} 12927 12928/* 12929 * ALC861 channel source setting (2/6 channel selection for 3-stack) 12930 */ 12931 12932/* 12933 * set the path ways for 2 channel output 12934 * need to set the codec line out and mic 1 pin widgets to inputs 12935 */ 12936static struct hda_verb alc861_threestack_ch2_init[] = { 12937 /* set pin widget 1Ah (line in) for input */ 12938 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 12939 /* set pin widget 18h (mic1/2) for input, for mic also enable 12940 * the vref 12941 */ 12942 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 12943 12944 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c }, 12945#if 0 12946 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/ 12947 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/ 12948#endif 12949 { } /* end */ 12950}; 12951/* 12952 * 6ch mode 12953 * need to set the codec line out and mic 1 pin widgets to outputs 12954 */ 12955static struct hda_verb alc861_threestack_ch6_init[] = { 12956 /* set pin widget 1Ah (line in) for output (Back Surround)*/ 12957 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 12958 /* set pin widget 18h (mic1) for output (CLFE)*/ 12959 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 12960 12961 { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 }, 12962 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 }, 12963 12964 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 }, 12965#if 0 12966 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/ 12967 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/ 12968#endif 12969 { } /* end */ 12970}; 12971 12972static struct hda_channel_mode alc861_threestack_modes[2] = { 12973 { 2, alc861_threestack_ch2_init }, 12974 { 6, alc861_threestack_ch6_init }, 12975}; 12976/* Set mic1 as input and unmute the mixer */ 12977static struct hda_verb alc861_uniwill_m31_ch2_init[] = { 12978 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 12979 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/ 12980 { } /* end */ 12981}; 12982/* Set mic1 as output and mute mixer */ 12983static struct hda_verb alc861_uniwill_m31_ch4_init[] = { 12984 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 12985 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/ 12986 { } /* end */ 12987}; 12988 12989static struct hda_channel_mode alc861_uniwill_m31_modes[2] = { 12990 { 2, alc861_uniwill_m31_ch2_init }, 12991 { 4, alc861_uniwill_m31_ch4_init }, 12992}; 12993 12994/* Set mic1 and line-in as input and unmute the mixer */ 12995static struct hda_verb alc861_asus_ch2_init[] = { 12996 /* set pin widget 1Ah (line in) for input */ 12997 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 12998 /* set pin widget 18h (mic1/2) for input, for mic also enable 12999 * the vref 13000 */ 13001 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 13002 13003 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c }, 13004#if 0 13005 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/ 13006 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/ 13007#endif 13008 { } /* end */ 13009}; 13010/* Set mic1 nad line-in as output and mute mixer */ 13011static struct hda_verb alc861_asus_ch6_init[] = { 13012 /* set pin widget 1Ah (line in) for output (Back Surround)*/ 13013 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13014 /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */ 13015 /* set pin widget 18h (mic1) for output (CLFE)*/ 13016 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13017 /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */ 13018 { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13019 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13020 13021 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 }, 13022#if 0 13023 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/ 13024 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/ 13025#endif 13026 { } /* end */ 13027}; 13028 13029static struct hda_channel_mode alc861_asus_modes[2] = { 13030 { 2, alc861_asus_ch2_init }, 13031 { 6, alc861_asus_ch6_init }, 13032}; 13033 13034/* patch-ALC861 */ 13035 13036static struct snd_kcontrol_new alc861_base_mixer[] = { 13037 /* output mixer control */ 13038 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT), 13039 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT), 13040 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT), 13041 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT), 13042 HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), 13043 13044 /*Input mixer control */ 13045 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT), 13046 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */ 13047 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 13048 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 13049 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT), 13050 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT), 13051 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 13052 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 13053 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT), 13054 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT), 13055 13056 { } /* end */ 13057}; 13058 13059static struct snd_kcontrol_new alc861_3ST_mixer[] = { 13060 /* output mixer control */ 13061 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT), 13062 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT), 13063 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT), 13064 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT), 13065 /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */ 13066 13067 /* Input mixer control */ 13068 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT), 13069 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */ 13070 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 13071 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 13072 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT), 13073 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT), 13074 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 13075 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 13076 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT), 13077 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT), 13078 13079 { 13080 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 13081 .name = "Channel Mode", 13082 .info = alc_ch_mode_info, 13083 .get = alc_ch_mode_get, 13084 .put = alc_ch_mode_put, 13085 .private_value = ARRAY_SIZE(alc861_threestack_modes), 13086 }, 13087 { } /* end */ 13088}; 13089 13090static struct snd_kcontrol_new alc861_toshiba_mixer[] = { 13091 /* output mixer control */ 13092 HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT), 13093 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 13094 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 13095 13096 { } /* end */ 13097}; 13098 13099static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = { 13100 /* output mixer control */ 13101 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT), 13102 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT), 13103 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT), 13104 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT), 13105 /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */ 13106 13107 /* Input mixer control */ 13108 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT), 13109 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */ 13110 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 13111 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 13112 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT), 13113 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT), 13114 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 13115 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 13116 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT), 13117 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT), 13118 13119 { 13120 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 13121 .name = "Channel Mode", 13122 .info = alc_ch_mode_info, 13123 .get = alc_ch_mode_get, 13124 .put = alc_ch_mode_put, 13125 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes), 13126 }, 13127 { } /* end */ 13128}; 13129 13130static struct snd_kcontrol_new alc861_asus_mixer[] = { 13131 /* output mixer control */ 13132 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT), 13133 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT), 13134 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT), 13135 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT), 13136 HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), 13137 13138 /* Input mixer control */ 13139 HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT), 13140 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), 13141 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 13142 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 13143 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT), 13144 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT), 13145 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 13146 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 13147 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT), 13148 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT), 13149 13150 { 13151 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 13152 .name = "Channel Mode", 13153 .info = alc_ch_mode_info, 13154 .get = alc_ch_mode_get, 13155 .put = alc_ch_mode_put, 13156 .private_value = ARRAY_SIZE(alc861_asus_modes), 13157 }, 13158 { } 13159}; 13160 13161/* additional mixer */ 13162static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = { 13163 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 13164 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 13165 { } 13166}; 13167 13168/* 13169 * generic initialization of ADC, input mixers and output mixers 13170 */ 13171static struct hda_verb alc861_base_init_verbs[] = { 13172 /* 13173 * Unmute ADC0 and set the default input to mic-in 13174 */ 13175 /* port-A for surround (rear panel) */ 13176 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13177 { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13178 /* port-B for mic-in (rear panel) with vref */ 13179 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 13180 /* port-C for line-in (rear panel) */ 13181 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 13182 /* port-D for Front */ 13183 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13184 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13185 /* port-E for HP out (front panel) */ 13186 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 13187 /* route front PCM to HP */ 13188 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13189 /* port-F for mic-in (front panel) with vref */ 13190 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 13191 /* port-G for CLFE (rear panel) */ 13192 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13193 { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13194 /* port-H for side (rear panel) */ 13195 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13196 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13197 /* CD-in */ 13198 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 13199 /* route front mic to ADC1*/ 13200 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 13201 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13202 13203 /* Unmute DAC0~3 & spdif out*/ 13204 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13205 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13206 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13207 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13208 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13209 13210 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 13211 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13212 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13213 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13214 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13215 13216 /* Unmute Stereo Mixer 15 */ 13217 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13218 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13219 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13220 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */ 13221 13222 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13223 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13224 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13225 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13226 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13227 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13228 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13229 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13230 /* hp used DAC 3 (Front) */ 13231 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 13232 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13233 13234 { } 13235}; 13236 13237static struct hda_verb alc861_threestack_init_verbs[] = { 13238 /* 13239 * Unmute ADC0 and set the default input to mic-in 13240 */ 13241 /* port-A for surround (rear panel) */ 13242 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 13243 /* port-B for mic-in (rear panel) with vref */ 13244 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 13245 /* port-C for line-in (rear panel) */ 13246 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 13247 /* port-D for Front */ 13248 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13249 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13250 /* port-E for HP out (front panel) */ 13251 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 13252 /* route front PCM to HP */ 13253 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13254 /* port-F for mic-in (front panel) with vref */ 13255 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 13256 /* port-G for CLFE (rear panel) */ 13257 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 13258 /* port-H for side (rear panel) */ 13259 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 13260 /* CD-in */ 13261 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 13262 /* route front mic to ADC1*/ 13263 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 13264 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13265 /* Unmute DAC0~3 & spdif out*/ 13266 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13267 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13268 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13269 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13270 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13271 13272 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 13273 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13274 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13275 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13276 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13277 13278 /* Unmute Stereo Mixer 15 */ 13279 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13280 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13281 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13282 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */ 13283 13284 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13285 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13286 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13287 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13288 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13289 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13290 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13291 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13292 /* hp used DAC 3 (Front) */ 13293 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 13294 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13295 { } 13296}; 13297 13298static struct hda_verb alc861_uniwill_m31_init_verbs[] = { 13299 /* 13300 * Unmute ADC0 and set the default input to mic-in 13301 */ 13302 /* port-A for surround (rear panel) */ 13303 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 13304 /* port-B for mic-in (rear panel) with vref */ 13305 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 13306 /* port-C for line-in (rear panel) */ 13307 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 13308 /* port-D for Front */ 13309 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13310 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13311 /* port-E for HP out (front panel) */ 13312 /* this has to be set to VREF80 */ 13313 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 13314 /* route front PCM to HP */ 13315 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13316 /* port-F for mic-in (front panel) with vref */ 13317 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 13318 /* port-G for CLFE (rear panel) */ 13319 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 13320 /* port-H for side (rear panel) */ 13321 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 13322 /* CD-in */ 13323 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 13324 /* route front mic to ADC1*/ 13325 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 13326 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13327 /* Unmute DAC0~3 & spdif out*/ 13328 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13329 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13330 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13331 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13332 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13333 13334 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 13335 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13336 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13337 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13338 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13339 13340 /* Unmute Stereo Mixer 15 */ 13341 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13342 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13343 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13344 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */ 13345 13346 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13347 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13348 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13349 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13350 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13351 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13352 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13353 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13354 /* hp used DAC 3 (Front) */ 13355 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 13356 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13357 { } 13358}; 13359 13360static struct hda_verb alc861_asus_init_verbs[] = { 13361 /* 13362 * Unmute ADC0 and set the default input to mic-in 13363 */ 13364 /* port-A for surround (rear panel) 13365 * according to codec#0 this is the HP jack 13366 */ 13367 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */ 13368 /* route front PCM to HP */ 13369 { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 }, 13370 /* port-B for mic-in (rear panel) with vref */ 13371 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 13372 /* port-C for line-in (rear panel) */ 13373 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 13374 /* port-D for Front */ 13375 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13376 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13377 /* port-E for HP out (front panel) */ 13378 /* this has to be set to VREF80 */ 13379 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 13380 /* route front PCM to HP */ 13381 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13382 /* port-F for mic-in (front panel) with vref */ 13383 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 13384 /* port-G for CLFE (rear panel) */ 13385 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13386 /* port-H for side (rear panel) */ 13387 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13388 /* CD-in */ 13389 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 13390 /* route front mic to ADC1*/ 13391 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 13392 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13393 /* Unmute DAC0~3 & spdif out*/ 13394 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13395 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13396 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13397 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13398 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13399 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 13400 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13401 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13402 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13403 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13404 13405 /* Unmute Stereo Mixer 15 */ 13406 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13407 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13408 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13409 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */ 13410 13411 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13412 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13413 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13414 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13415 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13416 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13417 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13418 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13419 /* hp used DAC 3 (Front) */ 13420 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 13421 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13422 { } 13423}; 13424 13425/* additional init verbs for ASUS laptops */ 13426static struct hda_verb alc861_asus_laptop_init_verbs[] = { 13427 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */ 13428 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */ 13429 { } 13430}; 13431 13432/* 13433 * generic initialization of ADC, input mixers and output mixers 13434 */ 13435static struct hda_verb alc861_auto_init_verbs[] = { 13436 /* 13437 * Unmute ADC0 and set the default input to mic-in 13438 */ 13439 /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */ 13440 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13441 13442 /* Unmute DAC0~3 & spdif out*/ 13443 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13444 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13445 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13446 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13447 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13448 13449 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 13450 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13451 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13452 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13453 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13454 13455 /* Unmute Stereo Mixer 15 */ 13456 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13457 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13458 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13459 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, 13460 13461 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13462 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13463 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13464 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13465 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13466 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13467 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13468 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13469 13470 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 13471 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 13472 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13473 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 13474 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 13475 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 13476 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13477 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 13478 13479 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, /* set Mic 1 */ 13480 13481 { } 13482}; 13483 13484static struct hda_verb alc861_toshiba_init_verbs[] = { 13485 {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 13486 13487 { } 13488}; 13489 13490/* toggle speaker-output according to the hp-jack state */ 13491static void alc861_toshiba_automute(struct hda_codec *codec) 13492{ 13493 unsigned int present; 13494 13495 present = snd_hda_codec_read(codec, 0x0f, 0, 13496 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 13497 snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0, 13498 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 13499 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3, 13500 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE); 13501} 13502 13503static void alc861_toshiba_unsol_event(struct hda_codec *codec, 13504 unsigned int res) 13505{ 13506 if ((res >> 26) == ALC880_HP_EVENT) 13507 alc861_toshiba_automute(codec); 13508} 13509 13510/* pcm configuration: identiacal with ALC880 */ 13511#define alc861_pcm_analog_playback alc880_pcm_analog_playback 13512#define alc861_pcm_analog_capture alc880_pcm_analog_capture 13513#define alc861_pcm_digital_playback alc880_pcm_digital_playback 13514#define alc861_pcm_digital_capture alc880_pcm_digital_capture 13515 13516 13517#define ALC861_DIGOUT_NID 0x07 13518 13519static struct hda_channel_mode alc861_8ch_modes[1] = { 13520 { 8, NULL } 13521}; 13522 13523static hda_nid_t alc861_dac_nids[4] = { 13524 /* front, surround, clfe, side */ 13525 0x03, 0x06, 0x05, 0x04 13526}; 13527 13528static hda_nid_t alc660_dac_nids[3] = { 13529 /* front, clfe, surround */ 13530 0x03, 0x05, 0x06 13531}; 13532 13533static hda_nid_t alc861_adc_nids[1] = { 13534 /* ADC0-2 */ 13535 0x08, 13536}; 13537 13538static struct hda_input_mux alc861_capture_source = { 13539 .num_items = 5, 13540 .items = { 13541 { "Mic", 0x0 }, 13542 { "Front Mic", 0x3 }, 13543 { "Line", 0x1 }, 13544 { "CD", 0x4 }, 13545 { "Mixer", 0x5 }, 13546 }, 13547}; 13548 13549/* fill in the dac_nids table from the parsed pin configuration */ 13550static int alc861_auto_fill_dac_nids(struct alc_spec *spec, 13551 const struct auto_pin_cfg *cfg) 13552{ 13553 int i; 13554 hda_nid_t nid; 13555 13556 spec->multiout.dac_nids = spec->private_dac_nids; 13557 for (i = 0; i < cfg->line_outs; i++) { 13558 nid = cfg->line_out_pins[i]; 13559 if (nid) { 13560 if (i >= ARRAY_SIZE(alc861_dac_nids)) 13561 continue; 13562 spec->multiout.dac_nids[i] = alc861_dac_nids[i]; 13563 } 13564 } 13565 spec->multiout.num_dacs = cfg->line_outs; 13566 return 0; 13567} 13568 13569/* add playback controls from the parsed DAC table */ 13570static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec, 13571 const struct auto_pin_cfg *cfg) 13572{ 13573 char name[32]; 13574 static const char *chname[4] = { 13575 "Front", "Surround", NULL /*CLFE*/, "Side" 13576 }; 13577 hda_nid_t nid; 13578 int i, idx, err; 13579 13580 for (i = 0; i < cfg->line_outs; i++) { 13581 nid = spec->multiout.dac_nids[i]; 13582 if (!nid) 13583 continue; 13584 if (nid == 0x05) { 13585 /* Center/LFE */ 13586 err = add_control(spec, ALC_CTL_BIND_MUTE, 13587 "Center Playback Switch", 13588 HDA_COMPOSE_AMP_VAL(nid, 1, 0, 13589 HDA_OUTPUT)); 13590 if (err < 0) 13591 return err; 13592 err = add_control(spec, ALC_CTL_BIND_MUTE, 13593 "LFE Playback Switch", 13594 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 13595 HDA_OUTPUT)); 13596 if (err < 0) 13597 return err; 13598 } else { 13599 for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1; 13600 idx++) 13601 if (nid == alc861_dac_nids[idx]) 13602 break; 13603 sprintf(name, "%s Playback Switch", chname[idx]); 13604 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 13605 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 13606 HDA_OUTPUT)); 13607 if (err < 0) 13608 return err; 13609 } 13610 } 13611 return 0; 13612} 13613 13614static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin) 13615{ 13616 int err; 13617 hda_nid_t nid; 13618 13619 if (!pin) 13620 return 0; 13621 13622 if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) { 13623 nid = 0x03; 13624 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 13625 "Headphone Playback Switch", 13626 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 13627 if (err < 0) 13628 return err; 13629 spec->multiout.hp_nid = nid; 13630 } 13631 return 0; 13632} 13633 13634/* create playback/capture controls for input pins */ 13635static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec, 13636 const struct auto_pin_cfg *cfg) 13637{ 13638 struct hda_input_mux *imux = &spec->private_imux[0]; 13639 int i, err, idx, idx1; 13640 13641 for (i = 0; i < AUTO_PIN_LAST; i++) { 13642 switch (cfg->input_pins[i]) { 13643 case 0x0c: 13644 idx1 = 1; 13645 idx = 2; /* Line In */ 13646 break; 13647 case 0x0f: 13648 idx1 = 2; 13649 idx = 2; /* Line In */ 13650 break; 13651 case 0x0d: 13652 idx1 = 0; 13653 idx = 1; /* Mic In */ 13654 break; 13655 case 0x10: 13656 idx1 = 3; 13657 idx = 1; /* Mic In */ 13658 break; 13659 case 0x11: 13660 idx1 = 4; 13661 idx = 0; /* CD */ 13662 break; 13663 default: 13664 continue; 13665 } 13666 13667 err = new_analog_input(spec, cfg->input_pins[i], 13668 auto_pin_cfg_labels[i], idx, 0x15); 13669 if (err < 0) 13670 return err; 13671 13672 imux->items[imux->num_items].label = auto_pin_cfg_labels[i]; 13673 imux->items[imux->num_items].index = idx1; 13674 imux->num_items++; 13675 } 13676 return 0; 13677} 13678 13679static void alc861_auto_set_output_and_unmute(struct hda_codec *codec, 13680 hda_nid_t nid, 13681 int pin_type, int dac_idx) 13682{ 13683 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 13684 pin_type); 13685 snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE, 13686 AMP_OUT_UNMUTE); 13687} 13688 13689static void alc861_auto_init_multi_out(struct hda_codec *codec) 13690{ 13691 struct alc_spec *spec = codec->spec; 13692 int i; 13693 13694 alc_subsystem_id(codec, 0x0e, 0x0f, 0x0b); 13695 for (i = 0; i < spec->autocfg.line_outs; i++) { 13696 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 13697 int pin_type = get_pin_type(spec->autocfg.line_out_type); 13698 if (nid) 13699 alc861_auto_set_output_and_unmute(codec, nid, pin_type, 13700 spec->multiout.dac_nids[i]); 13701 } 13702} 13703 13704static void alc861_auto_init_hp_out(struct hda_codec *codec) 13705{ 13706 struct alc_spec *spec = codec->spec; 13707 hda_nid_t pin; 13708 13709 pin = spec->autocfg.hp_pins[0]; 13710 if (pin) /* connect to front */ 13711 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP, 13712 spec->multiout.dac_nids[0]); 13713 pin = spec->autocfg.speaker_pins[0]; 13714 if (pin) 13715 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 13716} 13717 13718static void alc861_auto_init_analog_input(struct hda_codec *codec) 13719{ 13720 struct alc_spec *spec = codec->spec; 13721 int i; 13722 13723 for (i = 0; i < AUTO_PIN_LAST; i++) { 13724 hda_nid_t nid = spec->autocfg.input_pins[i]; 13725 if (nid >= 0x0c && nid <= 0x11) { 13726 snd_hda_codec_write(codec, nid, 0, 13727 AC_VERB_SET_PIN_WIDGET_CONTROL, 13728 i <= AUTO_PIN_FRONT_MIC ? 13729 PIN_VREF80 : PIN_IN); 13730 } 13731 } 13732} 13733 13734/* parse the BIOS configuration and set up the alc_spec */ 13735/* return 1 if successful, 0 if the proper config is not found, 13736 * or a negative error code 13737 */ 13738static int alc861_parse_auto_config(struct hda_codec *codec) 13739{ 13740 struct alc_spec *spec = codec->spec; 13741 int err; 13742 static hda_nid_t alc861_ignore[] = { 0x1d, 0 }; 13743 13744 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 13745 alc861_ignore); 13746 if (err < 0) 13747 return err; 13748 if (!spec->autocfg.line_outs) 13749 return 0; /* can't find valid BIOS pin config */ 13750 13751 err = alc861_auto_fill_dac_nids(spec, &spec->autocfg); 13752 if (err < 0) 13753 return err; 13754 err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg); 13755 if (err < 0) 13756 return err; 13757 err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); 13758 if (err < 0) 13759 return err; 13760 err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg); 13761 if (err < 0) 13762 return err; 13763 13764 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 13765 13766 if (spec->autocfg.dig_out_pin) 13767 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID; 13768 13769 if (spec->kctls.list) 13770 add_mixer(spec, spec->kctls.list); 13771 13772 add_verb(spec, alc861_auto_init_verbs); 13773 13774 spec->num_mux_defs = 1; 13775 spec->input_mux = &spec->private_imux[0]; 13776 13777 spec->adc_nids = alc861_adc_nids; 13778 spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids); 13779 set_capture_mixer(spec); 13780 13781 store_pin_configs(codec); 13782 return 1; 13783} 13784 13785/* additional initialization for auto-configuration model */ 13786static void alc861_auto_init(struct hda_codec *codec) 13787{ 13788 struct alc_spec *spec = codec->spec; 13789 alc861_auto_init_multi_out(codec); 13790 alc861_auto_init_hp_out(codec); 13791 alc861_auto_init_analog_input(codec); 13792 if (spec->unsol_event) 13793 alc_inithook(codec); 13794} 13795 13796#ifdef CONFIG_SND_HDA_POWER_SAVE 13797static struct hda_amp_list alc861_loopbacks[] = { 13798 { 0x15, HDA_INPUT, 0 }, 13799 { 0x15, HDA_INPUT, 1 }, 13800 { 0x15, HDA_INPUT, 2 }, 13801 { 0x15, HDA_INPUT, 3 }, 13802 { } /* end */ 13803}; 13804#endif 13805 13806 13807/* 13808 * configuration and preset 13809 */ 13810static const char *alc861_models[ALC861_MODEL_LAST] = { 13811 [ALC861_3ST] = "3stack", 13812 [ALC660_3ST] = "3stack-660", 13813 [ALC861_3ST_DIG] = "3stack-dig", 13814 [ALC861_6ST_DIG] = "6stack-dig", 13815 [ALC861_UNIWILL_M31] = "uniwill-m31", 13816 [ALC861_TOSHIBA] = "toshiba", 13817 [ALC861_ASUS] = "asus", 13818 [ALC861_ASUS_LAPTOP] = "asus-laptop", 13819 [ALC861_AUTO] = "auto", 13820}; 13821 13822static struct snd_pci_quirk alc861_cfg_tbl[] = { 13823 SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST), 13824 SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP), 13825 SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP), 13826 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS), 13827 SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP), 13828 SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG), 13829 SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA), 13830 /* FIXME: the entry below breaks Toshiba A100 (model=auto works!) 13831 * Any other models that need this preset? 13832 */ 13833 /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */ 13834 SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST), 13835 SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST), 13836 SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31), 13837 SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31), 13838 SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP), 13839 /* FIXME: the below seems conflict */ 13840 /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */ 13841 SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST), 13842 SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST), 13843 {} 13844}; 13845 13846static struct alc_config_preset alc861_presets[] = { 13847 [ALC861_3ST] = { 13848 .mixers = { alc861_3ST_mixer }, 13849 .init_verbs = { alc861_threestack_init_verbs }, 13850 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 13851 .dac_nids = alc861_dac_nids, 13852 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes), 13853 .channel_mode = alc861_threestack_modes, 13854 .need_dac_fix = 1, 13855 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 13856 .adc_nids = alc861_adc_nids, 13857 .input_mux = &alc861_capture_source, 13858 }, 13859 [ALC861_3ST_DIG] = { 13860 .mixers = { alc861_base_mixer }, 13861 .init_verbs = { alc861_threestack_init_verbs }, 13862 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 13863 .dac_nids = alc861_dac_nids, 13864 .dig_out_nid = ALC861_DIGOUT_NID, 13865 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes), 13866 .channel_mode = alc861_threestack_modes, 13867 .need_dac_fix = 1, 13868 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 13869 .adc_nids = alc861_adc_nids, 13870 .input_mux = &alc861_capture_source, 13871 }, 13872 [ALC861_6ST_DIG] = { 13873 .mixers = { alc861_base_mixer }, 13874 .init_verbs = { alc861_base_init_verbs }, 13875 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 13876 .dac_nids = alc861_dac_nids, 13877 .dig_out_nid = ALC861_DIGOUT_NID, 13878 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes), 13879 .channel_mode = alc861_8ch_modes, 13880 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 13881 .adc_nids = alc861_adc_nids, 13882 .input_mux = &alc861_capture_source, 13883 }, 13884 [ALC660_3ST] = { 13885 .mixers = { alc861_3ST_mixer }, 13886 .init_verbs = { alc861_threestack_init_verbs }, 13887 .num_dacs = ARRAY_SIZE(alc660_dac_nids), 13888 .dac_nids = alc660_dac_nids, 13889 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes), 13890 .channel_mode = alc861_threestack_modes, 13891 .need_dac_fix = 1, 13892 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 13893 .adc_nids = alc861_adc_nids, 13894 .input_mux = &alc861_capture_source, 13895 }, 13896 [ALC861_UNIWILL_M31] = { 13897 .mixers = { alc861_uniwill_m31_mixer }, 13898 .init_verbs = { alc861_uniwill_m31_init_verbs }, 13899 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 13900 .dac_nids = alc861_dac_nids, 13901 .dig_out_nid = ALC861_DIGOUT_NID, 13902 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes), 13903 .channel_mode = alc861_uniwill_m31_modes, 13904 .need_dac_fix = 1, 13905 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 13906 .adc_nids = alc861_adc_nids, 13907 .input_mux = &alc861_capture_source, 13908 }, 13909 [ALC861_TOSHIBA] = { 13910 .mixers = { alc861_toshiba_mixer }, 13911 .init_verbs = { alc861_base_init_verbs, 13912 alc861_toshiba_init_verbs }, 13913 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 13914 .dac_nids = alc861_dac_nids, 13915 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 13916 .channel_mode = alc883_3ST_2ch_modes, 13917 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 13918 .adc_nids = alc861_adc_nids, 13919 .input_mux = &alc861_capture_source, 13920 .unsol_event = alc861_toshiba_unsol_event, 13921 .init_hook = alc861_toshiba_automute, 13922 }, 13923 [ALC861_ASUS] = { 13924 .mixers = { alc861_asus_mixer }, 13925 .init_verbs = { alc861_asus_init_verbs }, 13926 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 13927 .dac_nids = alc861_dac_nids, 13928 .dig_out_nid = ALC861_DIGOUT_NID, 13929 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes), 13930 .channel_mode = alc861_asus_modes, 13931 .need_dac_fix = 1, 13932 .hp_nid = 0x06, 13933 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 13934 .adc_nids = alc861_adc_nids, 13935 .input_mux = &alc861_capture_source, 13936 }, 13937 [ALC861_ASUS_LAPTOP] = { 13938 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer }, 13939 .init_verbs = { alc861_asus_init_verbs, 13940 alc861_asus_laptop_init_verbs }, 13941 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 13942 .dac_nids = alc861_dac_nids, 13943 .dig_out_nid = ALC861_DIGOUT_NID, 13944 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 13945 .channel_mode = alc883_3ST_2ch_modes, 13946 .need_dac_fix = 1, 13947 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 13948 .adc_nids = alc861_adc_nids, 13949 .input_mux = &alc861_capture_source, 13950 }, 13951}; 13952 13953 13954static int patch_alc861(struct hda_codec *codec) 13955{ 13956 struct alc_spec *spec; 13957 int board_config; 13958 int err; 13959 13960 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 13961 if (spec == NULL) 13962 return -ENOMEM; 13963 13964 codec->spec = spec; 13965 13966 board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST, 13967 alc861_models, 13968 alc861_cfg_tbl); 13969 13970 if (board_config < 0) { 13971 printk(KERN_INFO "hda_codec: Unknown model for ALC861, " 13972 "trying auto-probe from BIOS...\n"); 13973 board_config = ALC861_AUTO; 13974 } 13975 13976 if (board_config == ALC861_AUTO) { 13977 /* automatic parse from the BIOS config */ 13978 err = alc861_parse_auto_config(codec); 13979 if (err < 0) { 13980 alc_free(codec); 13981 return err; 13982 } else if (!err) { 13983 printk(KERN_INFO 13984 "hda_codec: Cannot set up configuration " 13985 "from BIOS. Using base mode...\n"); 13986 board_config = ALC861_3ST_DIG; 13987 } 13988 } 13989 13990 err = snd_hda_attach_beep_device(codec, 0x23); 13991 if (err < 0) { 13992 alc_free(codec); 13993 return err; 13994 } 13995 13996 if (board_config != ALC861_AUTO) 13997 setup_preset(spec, &alc861_presets[board_config]); 13998 13999 spec->stream_name_analog = "ALC861 Analog"; 14000 spec->stream_analog_playback = &alc861_pcm_analog_playback; 14001 spec->stream_analog_capture = &alc861_pcm_analog_capture; 14002 14003 spec->stream_name_digital = "ALC861 Digital"; 14004 spec->stream_digital_playback = &alc861_pcm_digital_playback; 14005 spec->stream_digital_capture = &alc861_pcm_digital_capture; 14006 14007 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT); 14008 14009 spec->vmaster_nid = 0x03; 14010 14011 codec->patch_ops = alc_patch_ops; 14012 if (board_config == ALC861_AUTO) 14013 spec->init_hook = alc861_auto_init; 14014#ifdef CONFIG_SND_HDA_POWER_SAVE 14015 if (!spec->loopback.amplist) 14016 spec->loopback.amplist = alc861_loopbacks; 14017#endif 14018 codec->proc_widget_hook = print_realtek_coef; 14019 14020 return 0; 14021} 14022 14023/* 14024 * ALC861-VD support 14025 * 14026 * Based on ALC882 14027 * 14028 * In addition, an independent DAC 14029 */ 14030#define ALC861VD_DIGOUT_NID 0x06 14031 14032static hda_nid_t alc861vd_dac_nids[4] = { 14033 /* front, surr, clfe, side surr */ 14034 0x02, 0x03, 0x04, 0x05 14035}; 14036 14037/* dac_nids for ALC660vd are in a different order - according to 14038 * Realtek's driver. 14039 * This should probably tesult in a different mixer for 6stack models 14040 * of ALC660vd codecs, but for now there is only 3stack mixer 14041 * - and it is the same as in 861vd. 14042 * adc_nids in ALC660vd are (is) the same as in 861vd 14043 */ 14044static hda_nid_t alc660vd_dac_nids[3] = { 14045 /* front, rear, clfe, rear_surr */ 14046 0x02, 0x04, 0x03 14047}; 14048 14049static hda_nid_t alc861vd_adc_nids[1] = { 14050 /* ADC0 */ 14051 0x09, 14052}; 14053 14054static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 }; 14055 14056/* input MUX */ 14057/* FIXME: should be a matrix-type input source selection */ 14058static struct hda_input_mux alc861vd_capture_source = { 14059 .num_items = 4, 14060 .items = { 14061 { "Mic", 0x0 }, 14062 { "Front Mic", 0x1 }, 14063 { "Line", 0x2 }, 14064 { "CD", 0x4 }, 14065 }, 14066}; 14067 14068static struct hda_input_mux alc861vd_dallas_capture_source = { 14069 .num_items = 2, 14070 .items = { 14071 { "Ext Mic", 0x0 }, 14072 { "Int Mic", 0x1 }, 14073 }, 14074}; 14075 14076static struct hda_input_mux alc861vd_hp_capture_source = { 14077 .num_items = 2, 14078 .items = { 14079 { "Front Mic", 0x0 }, 14080 { "ATAPI Mic", 0x1 }, 14081 }, 14082}; 14083 14084/* 14085 * 2ch mode 14086 */ 14087static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = { 14088 { 2, NULL } 14089}; 14090 14091/* 14092 * 6ch mode 14093 */ 14094static struct hda_verb alc861vd_6stack_ch6_init[] = { 14095 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 14096 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 14097 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 14098 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 14099 { } /* end */ 14100}; 14101 14102/* 14103 * 8ch mode 14104 */ 14105static struct hda_verb alc861vd_6stack_ch8_init[] = { 14106 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 14107 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 14108 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 14109 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 14110 { } /* end */ 14111}; 14112 14113static struct hda_channel_mode alc861vd_6stack_modes[2] = { 14114 { 6, alc861vd_6stack_ch6_init }, 14115 { 8, alc861vd_6stack_ch8_init }, 14116}; 14117 14118static struct snd_kcontrol_new alc861vd_chmode_mixer[] = { 14119 { 14120 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 14121 .name = "Channel Mode", 14122 .info = alc_ch_mode_info, 14123 .get = alc_ch_mode_get, 14124 .put = alc_ch_mode_put, 14125 }, 14126 { } /* end */ 14127}; 14128 14129/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17 14130 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b 14131 */ 14132static struct snd_kcontrol_new alc861vd_6st_mixer[] = { 14133 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 14134 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 14135 14136 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT), 14137 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 14138 14139 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, 14140 HDA_OUTPUT), 14141 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, 14142 HDA_OUTPUT), 14143 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 14144 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 14145 14146 HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT), 14147 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 14148 14149 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 14150 14151 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 14152 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 14153 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 14154 14155 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 14156 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 14157 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 14158 14159 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 14160 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 14161 14162 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 14163 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 14164 14165 { } /* end */ 14166}; 14167 14168static struct snd_kcontrol_new alc861vd_3st_mixer[] = { 14169 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 14170 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 14171 14172 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 14173 14174 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 14175 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 14176 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 14177 14178 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 14179 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 14180 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 14181 14182 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 14183 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 14184 14185 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 14186 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 14187 14188 { } /* end */ 14189}; 14190 14191static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = { 14192 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 14193 /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/ 14194 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 14195 14196 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 14197 14198 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 14199 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 14200 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 14201 14202 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 14203 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 14204 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 14205 14206 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 14207 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 14208 14209 { } /* end */ 14210}; 14211 14212/* Pin assignment: Speaker=0x14, HP = 0x15, 14213 * Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d 14214 */ 14215static struct snd_kcontrol_new alc861vd_dallas_mixer[] = { 14216 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 14217 HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT), 14218 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 14219 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT), 14220 HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT), 14221 HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 14222 HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 14223 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 14224 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 14225 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 14226 { } /* end */ 14227}; 14228 14229/* Pin assignment: Speaker=0x14, Line-out = 0x15, 14230 * Front Mic=0x18, ATAPI Mic = 0x19, 14231 */ 14232static struct snd_kcontrol_new alc861vd_hp_mixer[] = { 14233 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 14234 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 14235 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 14236 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT), 14237 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 14238 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 14239 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 14240 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 14241 14242 { } /* end */ 14243}; 14244 14245/* 14246 * generic initialization of ADC, input mixers and output mixers 14247 */ 14248static struct hda_verb alc861vd_volume_init_verbs[] = { 14249 /* 14250 * Unmute ADC0 and set the default input to mic-in 14251 */ 14252 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 14253 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14254 14255 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of 14256 * the analog-loopback mixer widget 14257 */ 14258 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 14259 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 14260 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 14261 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 14262 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 14263 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 14264 14265 /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */ 14266 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14267 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14268 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 14269 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 14270 14271 /* 14272 * Set up output mixers (0x02 - 0x05) 14273 */ 14274 /* set vol=0 to output mixers */ 14275 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14276 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14277 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14278 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14279 14280 /* set up input amps for analog loopback */ 14281 /* Amp Indices: DAC = 0, mixer = 1 */ 14282 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 14283 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 14284 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 14285 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 14286 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 14287 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 14288 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 14289 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 14290 14291 { } 14292}; 14293 14294/* 14295 * 3-stack pin configuration: 14296 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b 14297 */ 14298static struct hda_verb alc861vd_3stack_init_verbs[] = { 14299 /* 14300 * Set pin mode and muting 14301 */ 14302 /* set front pin widgets 0x14 for output */ 14303 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14304 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14305 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 14306 14307 /* Mic (rear) pin: input vref at 80% */ 14308 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 14309 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 14310 /* Front Mic pin: input vref at 80% */ 14311 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 14312 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 14313 /* Line In pin: input */ 14314 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14315 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 14316 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 14317 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 14318 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14319 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 14320 /* CD pin widget for input */ 14321 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14322 14323 { } 14324}; 14325 14326/* 14327 * 6-stack pin configuration: 14328 */ 14329static struct hda_verb alc861vd_6stack_init_verbs[] = { 14330 /* 14331 * Set pin mode and muting 14332 */ 14333 /* set front pin widgets 0x14 for output */ 14334 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14335 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14336 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 14337 14338 /* Rear Pin: output 1 (0x0d) */ 14339 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14340 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14341 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 14342 /* CLFE Pin: output 2 (0x0e) */ 14343 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14344 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14345 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02}, 14346 /* Side Pin: output 3 (0x0f) */ 14347 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14348 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14349 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 14350 14351 /* Mic (rear) pin: input vref at 80% */ 14352 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 14353 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 14354 /* Front Mic pin: input vref at 80% */ 14355 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 14356 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 14357 /* Line In pin: input */ 14358 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14359 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 14360 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 14361 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 14362 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14363 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 14364 /* CD pin widget for input */ 14365 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14366 14367 { } 14368}; 14369 14370static struct hda_verb alc861vd_eapd_verbs[] = { 14371 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 14372 { } 14373}; 14374 14375static struct hda_verb alc660vd_eapd_verbs[] = { 14376 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 14377 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 14378 { } 14379}; 14380 14381static struct hda_verb alc861vd_lenovo_unsol_verbs[] = { 14382 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14383 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14384 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 14385 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 14386 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 14387 {} 14388}; 14389 14390/* toggle speaker-output according to the hp-jack state */ 14391static void alc861vd_lenovo_hp_automute(struct hda_codec *codec) 14392{ 14393 unsigned int present; 14394 unsigned char bits; 14395 14396 present = snd_hda_codec_read(codec, 0x1b, 0, 14397 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 14398 bits = present ? HDA_AMP_MUTE : 0; 14399 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 14400 HDA_AMP_MUTE, bits); 14401} 14402 14403static void alc861vd_lenovo_mic_automute(struct hda_codec *codec) 14404{ 14405 unsigned int present; 14406 unsigned char bits; 14407 14408 present = snd_hda_codec_read(codec, 0x18, 0, 14409 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 14410 bits = present ? HDA_AMP_MUTE : 0; 14411 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, 14412 HDA_AMP_MUTE, bits); 14413} 14414 14415static void alc861vd_lenovo_automute(struct hda_codec *codec) 14416{ 14417 alc861vd_lenovo_hp_automute(codec); 14418 alc861vd_lenovo_mic_automute(codec); 14419} 14420 14421static void alc861vd_lenovo_unsol_event(struct hda_codec *codec, 14422 unsigned int res) 14423{ 14424 switch (res >> 26) { 14425 case ALC880_HP_EVENT: 14426 alc861vd_lenovo_hp_automute(codec); 14427 break; 14428 case ALC880_MIC_EVENT: 14429 alc861vd_lenovo_mic_automute(codec); 14430 break; 14431 } 14432} 14433 14434static struct hda_verb alc861vd_dallas_verbs[] = { 14435 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14436 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14437 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14438 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14439 14440 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14441 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14442 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 14443 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 14444 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 14445 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 14446 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 14447 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 14448 14449 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14450 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14451 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14452 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14453 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14454 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14455 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14456 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14457 14458 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50}, 14459 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 14460 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50}, 14461 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 14462 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14463 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14464 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14465 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14466 14467 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14468 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 14469 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 14470 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 14471 14472 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 14473 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 14474 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 14475 14476 { } /* end */ 14477}; 14478 14479/* toggle speaker-output according to the hp-jack state */ 14480static void alc861vd_dallas_automute(struct hda_codec *codec) 14481{ 14482 unsigned int present; 14483 14484 present = snd_hda_codec_read(codec, 0x15, 0, 14485 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 14486 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 14487 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 14488} 14489 14490static void alc861vd_dallas_unsol_event(struct hda_codec *codec, unsigned int res) 14491{ 14492 if ((res >> 26) == ALC880_HP_EVENT) 14493 alc861vd_dallas_automute(codec); 14494} 14495 14496#ifdef CONFIG_SND_HDA_POWER_SAVE 14497#define alc861vd_loopbacks alc880_loopbacks 14498#endif 14499 14500/* pcm configuration: identiacal with ALC880 */ 14501#define alc861vd_pcm_analog_playback alc880_pcm_analog_playback 14502#define alc861vd_pcm_analog_capture alc880_pcm_analog_capture 14503#define alc861vd_pcm_digital_playback alc880_pcm_digital_playback 14504#define alc861vd_pcm_digital_capture alc880_pcm_digital_capture 14505 14506/* 14507 * configuration and preset 14508 */ 14509static const char *alc861vd_models[ALC861VD_MODEL_LAST] = { 14510 [ALC660VD_3ST] = "3stack-660", 14511 [ALC660VD_3ST_DIG] = "3stack-660-digout", 14512 [ALC660VD_ASUS_V1S] = "asus-v1s", 14513 [ALC861VD_3ST] = "3stack", 14514 [ALC861VD_3ST_DIG] = "3stack-digout", 14515 [ALC861VD_6ST_DIG] = "6stack-digout", 14516 [ALC861VD_LENOVO] = "lenovo", 14517 [ALC861VD_DALLAS] = "dallas", 14518 [ALC861VD_HP] = "hp", 14519 [ALC861VD_AUTO] = "auto", 14520}; 14521 14522static struct snd_pci_quirk alc861vd_cfg_tbl[] = { 14523 SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST), 14524 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP), 14525 SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST), 14526 SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST), 14527 SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S), 14528 SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG), 14529 SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST), 14530 SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO), 14531 /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/ 14532 SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS), 14533 SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO), 14534 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS), 14535 SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG), 14536 SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo", ALC861VD_LENOVO), 14537 SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo 3000 C200", ALC861VD_LENOVO), 14538 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 N200", ALC861VD_LENOVO), 14539 SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG), 14540 {} 14541}; 14542 14543static struct alc_config_preset alc861vd_presets[] = { 14544 [ALC660VD_3ST] = { 14545 .mixers = { alc861vd_3st_mixer }, 14546 .init_verbs = { alc861vd_volume_init_verbs, 14547 alc861vd_3stack_init_verbs }, 14548 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids), 14549 .dac_nids = alc660vd_dac_nids, 14550 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 14551 .channel_mode = alc861vd_3stack_2ch_modes, 14552 .input_mux = &alc861vd_capture_source, 14553 }, 14554 [ALC660VD_3ST_DIG] = { 14555 .mixers = { alc861vd_3st_mixer }, 14556 .init_verbs = { alc861vd_volume_init_verbs, 14557 alc861vd_3stack_init_verbs }, 14558 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids), 14559 .dac_nids = alc660vd_dac_nids, 14560 .dig_out_nid = ALC861VD_DIGOUT_NID, 14561 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 14562 .channel_mode = alc861vd_3stack_2ch_modes, 14563 .input_mux = &alc861vd_capture_source, 14564 }, 14565 [ALC861VD_3ST] = { 14566 .mixers = { alc861vd_3st_mixer }, 14567 .init_verbs = { alc861vd_volume_init_verbs, 14568 alc861vd_3stack_init_verbs }, 14569 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 14570 .dac_nids = alc861vd_dac_nids, 14571 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 14572 .channel_mode = alc861vd_3stack_2ch_modes, 14573 .input_mux = &alc861vd_capture_source, 14574 }, 14575 [ALC861VD_3ST_DIG] = { 14576 .mixers = { alc861vd_3st_mixer }, 14577 .init_verbs = { alc861vd_volume_init_verbs, 14578 alc861vd_3stack_init_verbs }, 14579 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 14580 .dac_nids = alc861vd_dac_nids, 14581 .dig_out_nid = ALC861VD_DIGOUT_NID, 14582 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 14583 .channel_mode = alc861vd_3stack_2ch_modes, 14584 .input_mux = &alc861vd_capture_source, 14585 }, 14586 [ALC861VD_6ST_DIG] = { 14587 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer }, 14588 .init_verbs = { alc861vd_volume_init_verbs, 14589 alc861vd_6stack_init_verbs }, 14590 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 14591 .dac_nids = alc861vd_dac_nids, 14592 .dig_out_nid = ALC861VD_DIGOUT_NID, 14593 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes), 14594 .channel_mode = alc861vd_6stack_modes, 14595 .input_mux = &alc861vd_capture_source, 14596 }, 14597 [ALC861VD_LENOVO] = { 14598 .mixers = { alc861vd_lenovo_mixer }, 14599 .init_verbs = { alc861vd_volume_init_verbs, 14600 alc861vd_3stack_init_verbs, 14601 alc861vd_eapd_verbs, 14602 alc861vd_lenovo_unsol_verbs }, 14603 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids), 14604 .dac_nids = alc660vd_dac_nids, 14605 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 14606 .channel_mode = alc861vd_3stack_2ch_modes, 14607 .input_mux = &alc861vd_capture_source, 14608 .unsol_event = alc861vd_lenovo_unsol_event, 14609 .init_hook = alc861vd_lenovo_automute, 14610 }, 14611 [ALC861VD_DALLAS] = { 14612 .mixers = { alc861vd_dallas_mixer }, 14613 .init_verbs = { alc861vd_dallas_verbs }, 14614 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 14615 .dac_nids = alc861vd_dac_nids, 14616 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 14617 .channel_mode = alc861vd_3stack_2ch_modes, 14618 .input_mux = &alc861vd_dallas_capture_source, 14619 .unsol_event = alc861vd_dallas_unsol_event, 14620 .init_hook = alc861vd_dallas_automute, 14621 }, 14622 [ALC861VD_HP] = { 14623 .mixers = { alc861vd_hp_mixer }, 14624 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs }, 14625 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 14626 .dac_nids = alc861vd_dac_nids, 14627 .dig_out_nid = ALC861VD_DIGOUT_NID, 14628 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 14629 .channel_mode = alc861vd_3stack_2ch_modes, 14630 .input_mux = &alc861vd_hp_capture_source, 14631 .unsol_event = alc861vd_dallas_unsol_event, 14632 .init_hook = alc861vd_dallas_automute, 14633 }, 14634 [ALC660VD_ASUS_V1S] = { 14635 .mixers = { alc861vd_lenovo_mixer }, 14636 .init_verbs = { alc861vd_volume_init_verbs, 14637 alc861vd_3stack_init_verbs, 14638 alc861vd_eapd_verbs, 14639 alc861vd_lenovo_unsol_verbs }, 14640 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids), 14641 .dac_nids = alc660vd_dac_nids, 14642 .dig_out_nid = ALC861VD_DIGOUT_NID, 14643 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 14644 .channel_mode = alc861vd_3stack_2ch_modes, 14645 .input_mux = &alc861vd_capture_source, 14646 .unsol_event = alc861vd_lenovo_unsol_event, 14647 .init_hook = alc861vd_lenovo_automute, 14648 }, 14649}; 14650 14651/* 14652 * BIOS auto configuration 14653 */ 14654static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec, 14655 hda_nid_t nid, int pin_type, int dac_idx) 14656{ 14657 alc_set_pin_output(codec, nid, pin_type); 14658} 14659 14660static void alc861vd_auto_init_multi_out(struct hda_codec *codec) 14661{ 14662 struct alc_spec *spec = codec->spec; 14663 int i; 14664 14665 alc_subsystem_id(codec, 0x15, 0x1b, 0x14); 14666 for (i = 0; i <= HDA_SIDE; i++) { 14667 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 14668 int pin_type = get_pin_type(spec->autocfg.line_out_type); 14669 if (nid) 14670 alc861vd_auto_set_output_and_unmute(codec, nid, 14671 pin_type, i); 14672 } 14673} 14674 14675 14676static void alc861vd_auto_init_hp_out(struct hda_codec *codec) 14677{ 14678 struct alc_spec *spec = codec->spec; 14679 hda_nid_t pin; 14680 14681 pin = spec->autocfg.hp_pins[0]; 14682 if (pin) /* connect to front and use dac 0 */ 14683 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 14684 pin = spec->autocfg.speaker_pins[0]; 14685 if (pin) 14686 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 14687} 14688 14689#define alc861vd_is_input_pin(nid) alc880_is_input_pin(nid) 14690#define ALC861VD_PIN_CD_NID ALC880_PIN_CD_NID 14691 14692static void alc861vd_auto_init_analog_input(struct hda_codec *codec) 14693{ 14694 struct alc_spec *spec = codec->spec; 14695 int i; 14696 14697 for (i = 0; i < AUTO_PIN_LAST; i++) { 14698 hda_nid_t nid = spec->autocfg.input_pins[i]; 14699 if (alc861vd_is_input_pin(nid)) { 14700 snd_hda_codec_write(codec, nid, 0, 14701 AC_VERB_SET_PIN_WIDGET_CONTROL, 14702 i <= AUTO_PIN_FRONT_MIC ? 14703 PIN_VREF80 : PIN_IN); 14704 if (nid != ALC861VD_PIN_CD_NID) 14705 snd_hda_codec_write(codec, nid, 0, 14706 AC_VERB_SET_AMP_GAIN_MUTE, 14707 AMP_OUT_MUTE); 14708 } 14709 } 14710} 14711 14712#define alc861vd_auto_init_input_src alc882_auto_init_input_src 14713 14714#define alc861vd_idx_to_mixer_vol(nid) ((nid) + 0x02) 14715#define alc861vd_idx_to_mixer_switch(nid) ((nid) + 0x0c) 14716 14717/* add playback controls from the parsed DAC table */ 14718/* Based on ALC880 version. But ALC861VD has separate, 14719 * different NIDs for mute/unmute switch and volume control */ 14720static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec, 14721 const struct auto_pin_cfg *cfg) 14722{ 14723 char name[32]; 14724 static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"}; 14725 hda_nid_t nid_v, nid_s; 14726 int i, err; 14727 14728 for (i = 0; i < cfg->line_outs; i++) { 14729 if (!spec->multiout.dac_nids[i]) 14730 continue; 14731 nid_v = alc861vd_idx_to_mixer_vol( 14732 alc880_dac_to_idx( 14733 spec->multiout.dac_nids[i])); 14734 nid_s = alc861vd_idx_to_mixer_switch( 14735 alc880_dac_to_idx( 14736 spec->multiout.dac_nids[i])); 14737 14738 if (i == 2) { 14739 /* Center/LFE */ 14740 err = add_control(spec, ALC_CTL_WIDGET_VOL, 14741 "Center Playback Volume", 14742 HDA_COMPOSE_AMP_VAL(nid_v, 1, 0, 14743 HDA_OUTPUT)); 14744 if (err < 0) 14745 return err; 14746 err = add_control(spec, ALC_CTL_WIDGET_VOL, 14747 "LFE Playback Volume", 14748 HDA_COMPOSE_AMP_VAL(nid_v, 2, 0, 14749 HDA_OUTPUT)); 14750 if (err < 0) 14751 return err; 14752 err = add_control(spec, ALC_CTL_BIND_MUTE, 14753 "Center Playback Switch", 14754 HDA_COMPOSE_AMP_VAL(nid_s, 1, 2, 14755 HDA_INPUT)); 14756 if (err < 0) 14757 return err; 14758 err = add_control(spec, ALC_CTL_BIND_MUTE, 14759 "LFE Playback Switch", 14760 HDA_COMPOSE_AMP_VAL(nid_s, 2, 2, 14761 HDA_INPUT)); 14762 if (err < 0) 14763 return err; 14764 } else { 14765 sprintf(name, "%s Playback Volume", chname[i]); 14766 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 14767 HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, 14768 HDA_OUTPUT)); 14769 if (err < 0) 14770 return err; 14771 sprintf(name, "%s Playback Switch", chname[i]); 14772 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 14773 HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, 14774 HDA_INPUT)); 14775 if (err < 0) 14776 return err; 14777 } 14778 } 14779 return 0; 14780} 14781 14782/* add playback controls for speaker and HP outputs */ 14783/* Based on ALC880 version. But ALC861VD has separate, 14784 * different NIDs for mute/unmute switch and volume control */ 14785static int alc861vd_auto_create_extra_out(struct alc_spec *spec, 14786 hda_nid_t pin, const char *pfx) 14787{ 14788 hda_nid_t nid_v, nid_s; 14789 int err; 14790 char name[32]; 14791 14792 if (!pin) 14793 return 0; 14794 14795 if (alc880_is_fixed_pin(pin)) { 14796 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin)); 14797 /* specify the DAC as the extra output */ 14798 if (!spec->multiout.hp_nid) 14799 spec->multiout.hp_nid = nid_v; 14800 else 14801 spec->multiout.extra_out_nid[0] = nid_v; 14802 /* control HP volume/switch on the output mixer amp */ 14803 nid_v = alc861vd_idx_to_mixer_vol( 14804 alc880_fixed_pin_idx(pin)); 14805 nid_s = alc861vd_idx_to_mixer_switch( 14806 alc880_fixed_pin_idx(pin)); 14807 14808 sprintf(name, "%s Playback Volume", pfx); 14809 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 14810 HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT)); 14811 if (err < 0) 14812 return err; 14813 sprintf(name, "%s Playback Switch", pfx); 14814 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 14815 HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT)); 14816 if (err < 0) 14817 return err; 14818 } else if (alc880_is_multi_pin(pin)) { 14819 /* set manual connection */ 14820 /* we have only a switch on HP-out PIN */ 14821 sprintf(name, "%s Playback Switch", pfx); 14822 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 14823 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 14824 if (err < 0) 14825 return err; 14826 } 14827 return 0; 14828} 14829 14830/* parse the BIOS configuration and set up the alc_spec 14831 * return 1 if successful, 0 if the proper config is not found, 14832 * or a negative error code 14833 * Based on ALC880 version - had to change it to override 14834 * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */ 14835static int alc861vd_parse_auto_config(struct hda_codec *codec) 14836{ 14837 struct alc_spec *spec = codec->spec; 14838 int err; 14839 static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 }; 14840 14841 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 14842 alc861vd_ignore); 14843 if (err < 0) 14844 return err; 14845 if (!spec->autocfg.line_outs) 14846 return 0; /* can't find valid BIOS pin config */ 14847 14848 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg); 14849 if (err < 0) 14850 return err; 14851 err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg); 14852 if (err < 0) 14853 return err; 14854 err = alc861vd_auto_create_extra_out(spec, 14855 spec->autocfg.speaker_pins[0], 14856 "Speaker"); 14857 if (err < 0) 14858 return err; 14859 err = alc861vd_auto_create_extra_out(spec, 14860 spec->autocfg.hp_pins[0], 14861 "Headphone"); 14862 if (err < 0) 14863 return err; 14864 err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg); 14865 if (err < 0) 14866 return err; 14867 14868 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 14869 14870 if (spec->autocfg.dig_out_pin) 14871 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID; 14872 14873 if (spec->kctls.list) 14874 add_mixer(spec, spec->kctls.list); 14875 14876 add_verb(spec, alc861vd_volume_init_verbs); 14877 14878 spec->num_mux_defs = 1; 14879 spec->input_mux = &spec->private_imux[0]; 14880 14881 err = alc_auto_add_mic_boost(codec); 14882 if (err < 0) 14883 return err; 14884 14885 store_pin_configs(codec); 14886 return 1; 14887} 14888 14889/* additional initialization for auto-configuration model */ 14890static void alc861vd_auto_init(struct hda_codec *codec) 14891{ 14892 struct alc_spec *spec = codec->spec; 14893 alc861vd_auto_init_multi_out(codec); 14894 alc861vd_auto_init_hp_out(codec); 14895 alc861vd_auto_init_analog_input(codec); 14896 alc861vd_auto_init_input_src(codec); 14897 if (spec->unsol_event) 14898 alc_inithook(codec); 14899} 14900 14901static int patch_alc861vd(struct hda_codec *codec) 14902{ 14903 struct alc_spec *spec; 14904 int err, board_config; 14905 14906 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 14907 if (spec == NULL) 14908 return -ENOMEM; 14909 14910 codec->spec = spec; 14911 14912 board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST, 14913 alc861vd_models, 14914 alc861vd_cfg_tbl); 14915 14916 if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) { 14917 printk(KERN_INFO "hda_codec: Unknown model for ALC660VD/" 14918 "ALC861VD, trying auto-probe from BIOS...\n"); 14919 board_config = ALC861VD_AUTO; 14920 } 14921 14922 if (board_config == ALC861VD_AUTO) { 14923 /* automatic parse from the BIOS config */ 14924 err = alc861vd_parse_auto_config(codec); 14925 if (err < 0) { 14926 alc_free(codec); 14927 return err; 14928 } else if (!err) { 14929 printk(KERN_INFO 14930 "hda_codec: Cannot set up configuration " 14931 "from BIOS. Using base mode...\n"); 14932 board_config = ALC861VD_3ST; 14933 } 14934 } 14935 14936 err = snd_hda_attach_beep_device(codec, 0x23); 14937 if (err < 0) { 14938 alc_free(codec); 14939 return err; 14940 } 14941 14942 if (board_config != ALC861VD_AUTO) 14943 setup_preset(spec, &alc861vd_presets[board_config]); 14944 14945 if (codec->vendor_id == 0x10ec0660) { 14946 spec->stream_name_analog = "ALC660-VD Analog"; 14947 spec->stream_name_digital = "ALC660-VD Digital"; 14948 /* always turn on EAPD */ 14949 add_verb(spec, alc660vd_eapd_verbs); 14950 } else { 14951 spec->stream_name_analog = "ALC861VD Analog"; 14952 spec->stream_name_digital = "ALC861VD Digital"; 14953 } 14954 14955 spec->stream_analog_playback = &alc861vd_pcm_analog_playback; 14956 spec->stream_analog_capture = &alc861vd_pcm_analog_capture; 14957 14958 spec->stream_digital_playback = &alc861vd_pcm_digital_playback; 14959 spec->stream_digital_capture = &alc861vd_pcm_digital_capture; 14960 14961 spec->adc_nids = alc861vd_adc_nids; 14962 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids); 14963 spec->capsrc_nids = alc861vd_capsrc_nids; 14964 spec->capture_style = CAPT_MIX; 14965 14966 set_capture_mixer(spec); 14967 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 14968 14969 spec->vmaster_nid = 0x02; 14970 14971 codec->patch_ops = alc_patch_ops; 14972 14973 if (board_config == ALC861VD_AUTO) 14974 spec->init_hook = alc861vd_auto_init; 14975#ifdef CONFIG_SND_HDA_POWER_SAVE 14976 if (!spec->loopback.amplist) 14977 spec->loopback.amplist = alc861vd_loopbacks; 14978#endif 14979 codec->proc_widget_hook = print_realtek_coef; 14980 14981 return 0; 14982} 14983 14984/* 14985 * ALC662 support 14986 * 14987 * ALC662 is almost identical with ALC880 but has cleaner and more flexible 14988 * configuration. Each pin widget can choose any input DACs and a mixer. 14989 * Each ADC is connected from a mixer of all inputs. This makes possible 14990 * 6-channel independent captures. 14991 * 14992 * In addition, an independent DAC for the multi-playback (not used in this 14993 * driver yet). 14994 */ 14995#define ALC662_DIGOUT_NID 0x06 14996#define ALC662_DIGIN_NID 0x0a 14997 14998static hda_nid_t alc662_dac_nids[4] = { 14999 /* front, rear, clfe, rear_surr */ 15000 0x02, 0x03, 0x04 15001}; 15002 15003static hda_nid_t alc662_adc_nids[1] = { 15004 /* ADC1-2 */ 15005 0x09, 15006}; 15007 15008static hda_nid_t alc662_capsrc_nids[1] = { 0x22 }; 15009 15010/* input MUX */ 15011/* FIXME: should be a matrix-type input source selection */ 15012static struct hda_input_mux alc662_capture_source = { 15013 .num_items = 4, 15014 .items = { 15015 { "Mic", 0x0 }, 15016 { "Front Mic", 0x1 }, 15017 { "Line", 0x2 }, 15018 { "CD", 0x4 }, 15019 }, 15020}; 15021 15022static struct hda_input_mux alc662_lenovo_101e_capture_source = { 15023 .num_items = 2, 15024 .items = { 15025 { "Mic", 0x1 }, 15026 { "Line", 0x2 }, 15027 }, 15028}; 15029 15030static struct hda_input_mux alc662_eeepc_capture_source = { 15031 .num_items = 2, 15032 .items = { 15033 { "i-Mic", 0x1 }, 15034 { "e-Mic", 0x0 }, 15035 }, 15036}; 15037 15038static struct hda_input_mux alc663_capture_source = { 15039 .num_items = 3, 15040 .items = { 15041 { "Mic", 0x0 }, 15042 { "Front Mic", 0x1 }, 15043 { "Line", 0x2 }, 15044 }, 15045}; 15046 15047static struct hda_input_mux alc663_m51va_capture_source = { 15048 .num_items = 2, 15049 .items = { 15050 { "Ext-Mic", 0x0 }, 15051 { "D-Mic", 0x9 }, 15052 }, 15053}; 15054 15055/* 15056 * 2ch mode 15057 */ 15058static struct hda_channel_mode alc662_3ST_2ch_modes[1] = { 15059 { 2, NULL } 15060}; 15061 15062/* 15063 * 2ch mode 15064 */ 15065static struct hda_verb alc662_3ST_ch2_init[] = { 15066 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 15067 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 15068 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 15069 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 15070 { } /* end */ 15071}; 15072 15073/* 15074 * 6ch mode 15075 */ 15076static struct hda_verb alc662_3ST_ch6_init[] = { 15077 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 15078 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 15079 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 }, 15080 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 15081 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 15082 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 15083 { } /* end */ 15084}; 15085 15086static struct hda_channel_mode alc662_3ST_6ch_modes[2] = { 15087 { 2, alc662_3ST_ch2_init }, 15088 { 6, alc662_3ST_ch6_init }, 15089}; 15090 15091/* 15092 * 2ch mode 15093 */ 15094static struct hda_verb alc662_sixstack_ch6_init[] = { 15095 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 15096 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 15097 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 15098 { } /* end */ 15099}; 15100 15101/* 15102 * 6ch mode 15103 */ 15104static struct hda_verb alc662_sixstack_ch8_init[] = { 15105 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 15106 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 15107 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 15108 { } /* end */ 15109}; 15110 15111static struct hda_channel_mode alc662_5stack_modes[2] = { 15112 { 2, alc662_sixstack_ch6_init }, 15113 { 6, alc662_sixstack_ch8_init }, 15114}; 15115 15116/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17 15117 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b 15118 */ 15119 15120static struct snd_kcontrol_new alc662_base_mixer[] = { 15121 /* output mixer control */ 15122 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT), 15123 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT), 15124 HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT), 15125 HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT), 15126 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT), 15127 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT), 15128 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT), 15129 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT), 15130 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 15131 15132 /*Input mixer control */ 15133 HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT), 15134 HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT), 15135 HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT), 15136 HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT), 15137 HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT), 15138 HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT), 15139 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT), 15140 HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT), 15141 { } /* end */ 15142}; 15143 15144static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = { 15145 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 15146 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT), 15147 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 15148 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 15149 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 15150 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 15151 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 15152 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15153 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15154 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 15155 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 15156 { } /* end */ 15157}; 15158 15159static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = { 15160 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 15161 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT), 15162 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT), 15163 HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT), 15164 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT), 15165 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT), 15166 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT), 15167 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT), 15168 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 15169 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 15170 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 15171 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 15172 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 15173 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15174 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15175 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 15176 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 15177 { } /* end */ 15178}; 15179 15180static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = { 15181 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 15182 HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT), 15183 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT), 15184 HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT), 15185 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 15186 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 15187 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 15188 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 15189 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 15190 { } /* end */ 15191}; 15192 15193static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = { 15194 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 15195 15196 HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT), 15197 HDA_CODEC_MUTE("Line-Out Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 15198 15199 HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT), 15200 HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15201 HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15202 15203 HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT), 15204 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 15205 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 15206 { } /* end */ 15207}; 15208 15209static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = { 15210 HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT), 15211 HDA_CODEC_MUTE("Line-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT), 15212 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT), 15213 HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT), 15214 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT), 15215 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT), 15216 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT), 15217 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT), 15218 HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 15219 HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT), 15220 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 15221 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 15222 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15223 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15224 { } /* end */ 15225}; 15226 15227static struct hda_bind_ctls alc663_asus_bind_master_vol = { 15228 .ops = &snd_hda_bind_vol, 15229 .values = { 15230 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT), 15231 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT), 15232 0 15233 }, 15234}; 15235 15236static struct hda_bind_ctls alc663_asus_one_bind_switch = { 15237 .ops = &snd_hda_bind_sw, 15238 .values = { 15239 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 15240 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT), 15241 0 15242 }, 15243}; 15244 15245static struct snd_kcontrol_new alc663_m51va_mixer[] = { 15246 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol), 15247 HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch), 15248 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15249 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15250 { } /* end */ 15251}; 15252 15253static struct hda_bind_ctls alc663_asus_tree_bind_switch = { 15254 .ops = &snd_hda_bind_sw, 15255 .values = { 15256 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 15257 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT), 15258 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT), 15259 0 15260 }, 15261}; 15262 15263static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = { 15264 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol), 15265 HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch), 15266 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15267 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15268 HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 15269 HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 15270 15271 { } /* end */ 15272}; 15273 15274static struct hda_bind_ctls alc663_asus_four_bind_switch = { 15275 .ops = &snd_hda_bind_sw, 15276 .values = { 15277 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 15278 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT), 15279 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT), 15280 0 15281 }, 15282}; 15283 15284static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = { 15285 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol), 15286 HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch), 15287 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15288 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15289 HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 15290 HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 15291 { } /* end */ 15292}; 15293 15294static struct snd_kcontrol_new alc662_1bjd_mixer[] = { 15295 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 15296 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 15297 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 15298 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15299 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15300 HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 15301 HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 15302 { } /* end */ 15303}; 15304 15305static struct hda_bind_ctls alc663_asus_two_bind_master_vol = { 15306 .ops = &snd_hda_bind_vol, 15307 .values = { 15308 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT), 15309 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT), 15310 0 15311 }, 15312}; 15313 15314static struct hda_bind_ctls alc663_asus_two_bind_switch = { 15315 .ops = &snd_hda_bind_sw, 15316 .values = { 15317 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 15318 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT), 15319 0 15320 }, 15321}; 15322 15323static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = { 15324 HDA_BIND_VOL("Master Playback Volume", 15325 &alc663_asus_two_bind_master_vol), 15326 HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch), 15327 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 15328 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT), 15329 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15330 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15331 { } /* end */ 15332}; 15333 15334static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = { 15335 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol), 15336 HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch), 15337 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 15338 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 15339 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15340 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15341 { } /* end */ 15342}; 15343 15344static struct snd_kcontrol_new alc663_g71v_mixer[] = { 15345 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 15346 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 15347 HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT), 15348 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT), 15349 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT), 15350 15351 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15352 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15353 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 15354 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 15355 { } /* end */ 15356}; 15357 15358static struct snd_kcontrol_new alc663_g50v_mixer[] = { 15359 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 15360 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 15361 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT), 15362 15363 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15364 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15365 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 15366 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 15367 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 15368 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 15369 { } /* end */ 15370}; 15371 15372static struct snd_kcontrol_new alc662_chmode_mixer[] = { 15373 { 15374 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 15375 .name = "Channel Mode", 15376 .info = alc_ch_mode_info, 15377 .get = alc_ch_mode_get, 15378 .put = alc_ch_mode_put, 15379 }, 15380 { } /* end */ 15381}; 15382 15383static struct hda_verb alc662_init_verbs[] = { 15384 /* ADC: mute amp left and right */ 15385 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15386 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 15387 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 15388 15389 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15390 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 15391 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 15392 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 15393 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 15394 15395 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15396 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15397 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15398 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15399 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15400 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15401 15402 /* Front Pin: output 0 (0x0c) */ 15403 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 15404 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15405 15406 /* Rear Pin: output 1 (0x0d) */ 15407 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 15408 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15409 15410 /* CLFE Pin: output 2 (0x0e) */ 15411 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 15412 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15413 15414 /* Mic (rear) pin: input vref at 80% */ 15415 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 15416 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 15417 /* Front Mic pin: input vref at 80% */ 15418 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 15419 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 15420 /* Line In pin: input */ 15421 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 15422 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 15423 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 15424 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15425 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15426 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 15427 /* CD pin widget for input */ 15428 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 15429 15430 /* FIXME: use matrix-type input source selection */ 15431 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 15432 /* Input mixer */ 15433 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15434 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15435 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 15436 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 15437 15438 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15439 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15440 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 15441 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 15442 15443 /* always trun on EAPD */ 15444 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 15445 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 15446 15447 { } 15448}; 15449 15450static struct hda_verb alc662_sue_init_verbs[] = { 15451 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT}, 15452 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT}, 15453 {} 15454}; 15455 15456static struct hda_verb alc662_eeepc_sue_init_verbs[] = { 15457 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 15458 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15459 {} 15460}; 15461 15462/* Set Unsolicited Event*/ 15463static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = { 15464 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 15465 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15466 {} 15467}; 15468 15469/* 15470 * generic initialization of ADC, input mixers and output mixers 15471 */ 15472static struct hda_verb alc662_auto_init_verbs[] = { 15473 /* 15474 * Unmute ADC and set the default input to mic-in 15475 */ 15476 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 15477 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15478 15479 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 15480 * mixer widget 15481 * Note: PASD motherboards uses the Line In 2 as the input for front 15482 * panel mic (mic 2) 15483 */ 15484 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 15485 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15486 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 15487 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 15488 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 15489 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 15490 15491 /* 15492 * Set up output mixers (0x0c - 0x0f) 15493 */ 15494 /* set vol=0 to output mixers */ 15495 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 15496 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 15497 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 15498 15499 /* set up input amps for analog loopback */ 15500 /* Amp Indices: DAC = 0, mixer = 1 */ 15501 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15502 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15503 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15504 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15505 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15506 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15507 15508 15509 /* FIXME: use matrix-type input source selection */ 15510 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 15511 /* Input mixer */ 15512 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15513 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15514 { } 15515}; 15516 15517/* additional verbs for ALC663 */ 15518static struct hda_verb alc663_auto_init_verbs[] = { 15519 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15520 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15521 { } 15522}; 15523 15524static struct hda_verb alc663_m51va_init_verbs[] = { 15525 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 15526 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 15527 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15528 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15529 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */ 15530 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15531 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)}, 15532 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 15533 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15534 {} 15535}; 15536 15537static struct hda_verb alc663_21jd_amic_init_verbs[] = { 15538 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15539 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15540 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */ 15541 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15542 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15543 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 15544 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15545 {} 15546}; 15547 15548static struct hda_verb alc662_1bjd_amic_init_verbs[] = { 15549 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 15550 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15551 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15552 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */ 15553 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15554 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15555 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 15556 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15557 {} 15558}; 15559 15560static struct hda_verb alc663_15jd_amic_init_verbs[] = { 15561 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15562 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15563 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */ 15564 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15565 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15566 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 15567 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15568 {} 15569}; 15570 15571static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = { 15572 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 15573 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15574 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15575 {0x21, AC_VERB_SET_CONNECT_SEL, 0x0}, /* Headphone */ 15576 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15577 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15578 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0}, /* Headphone */ 15579 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15580 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15581 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 15582 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15583 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15584 {} 15585}; 15586 15587static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = { 15588 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 15589 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15590 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15591 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */ 15592 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15593 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15594 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */ 15595 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15596 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15597 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 15598 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15599 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15600 {} 15601}; 15602 15603static struct hda_verb alc663_g71v_init_verbs[] = { 15604 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15605 /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */ 15606 /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */ 15607 15608 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15609 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15610 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */ 15611 15612 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT}, 15613 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT}, 15614 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT}, 15615 {} 15616}; 15617 15618static struct hda_verb alc663_g50v_init_verbs[] = { 15619 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15620 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15621 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */ 15622 15623 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 15624 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15625 {} 15626}; 15627 15628static struct hda_verb alc662_ecs_init_verbs[] = { 15629 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f}, 15630 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15631 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 15632 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15633 {} 15634}; 15635 15636static struct snd_kcontrol_new alc662_auto_capture_mixer[] = { 15637 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT), 15638 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT), 15639 { } /* end */ 15640}; 15641 15642static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec) 15643{ 15644 unsigned int present; 15645 unsigned char bits; 15646 15647 present = snd_hda_codec_read(codec, 0x14, 0, 15648 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 15649 bits = present ? HDA_AMP_MUTE : 0; 15650 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 15651 HDA_AMP_MUTE, bits); 15652} 15653 15654static void alc662_lenovo_101e_all_automute(struct hda_codec *codec) 15655{ 15656 unsigned int present; 15657 unsigned char bits; 15658 15659 present = snd_hda_codec_read(codec, 0x1b, 0, 15660 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 15661 bits = present ? HDA_AMP_MUTE : 0; 15662 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 15663 HDA_AMP_MUTE, bits); 15664 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 15665 HDA_AMP_MUTE, bits); 15666} 15667 15668static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec, 15669 unsigned int res) 15670{ 15671 if ((res >> 26) == ALC880_HP_EVENT) 15672 alc662_lenovo_101e_all_automute(codec); 15673 if ((res >> 26) == ALC880_FRONT_EVENT) 15674 alc662_lenovo_101e_ispeaker_automute(codec); 15675} 15676 15677static void alc662_eeepc_mic_automute(struct hda_codec *codec) 15678{ 15679 unsigned int present; 15680 15681 present = snd_hda_codec_read(codec, 0x18, 0, 15682 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 15683 snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE, 15684 0x7000 | (0x00 << 8) | (present ? 0 : 0x80)); 15685 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE, 15686 0x7000 | (0x00 << 8) | (present ? 0 : 0x80)); 15687 snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE, 15688 0x7000 | (0x01 << 8) | (present ? 0x80 : 0)); 15689 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE, 15690 0x7000 | (0x01 << 8) | (present ? 0x80 : 0)); 15691} 15692 15693/* unsolicited event for HP jack sensing */ 15694static void alc662_eeepc_unsol_event(struct hda_codec *codec, 15695 unsigned int res) 15696{ 15697 if ((res >> 26) == ALC880_HP_EVENT) 15698 alc262_hippo1_automute( codec ); 15699 15700 if ((res >> 26) == ALC880_MIC_EVENT) 15701 alc662_eeepc_mic_automute(codec); 15702} 15703 15704static void alc662_eeepc_inithook(struct hda_codec *codec) 15705{ 15706 alc262_hippo1_automute( codec ); 15707 alc662_eeepc_mic_automute(codec); 15708} 15709 15710static void alc662_eeepc_ep20_automute(struct hda_codec *codec) 15711{ 15712 unsigned int mute; 15713 unsigned int present; 15714 15715 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0); 15716 present = snd_hda_codec_read(codec, 0x14, 0, 15717 AC_VERB_GET_PIN_SENSE, 0); 15718 present = (present & 0x80000000) != 0; 15719 if (present) { 15720 /* mute internal speaker */ 15721 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 15722 HDA_AMP_MUTE, HDA_AMP_MUTE); 15723 } else { 15724 /* unmute internal speaker if necessary */ 15725 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0); 15726 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 15727 HDA_AMP_MUTE, mute); 15728 } 15729} 15730 15731/* unsolicited event for HP jack sensing */ 15732static void alc662_eeepc_ep20_unsol_event(struct hda_codec *codec, 15733 unsigned int res) 15734{ 15735 if ((res >> 26) == ALC880_HP_EVENT) 15736 alc662_eeepc_ep20_automute(codec); 15737} 15738 15739static void alc662_eeepc_ep20_inithook(struct hda_codec *codec) 15740{ 15741 alc662_eeepc_ep20_automute(codec); 15742} 15743 15744static void alc663_m51va_speaker_automute(struct hda_codec *codec) 15745{ 15746 unsigned int present; 15747 unsigned char bits; 15748 15749 present = snd_hda_codec_read(codec, 0x21, 0, 15750 AC_VERB_GET_PIN_SENSE, 0) 15751 & AC_PINSENSE_PRESENCE; 15752 bits = present ? HDA_AMP_MUTE : 0; 15753 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 15754 AMP_IN_MUTE(0), bits); 15755 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 15756 AMP_IN_MUTE(0), bits); 15757} 15758 15759static void alc663_21jd_two_speaker_automute(struct hda_codec *codec) 15760{ 15761 unsigned int present; 15762 unsigned char bits; 15763 15764 present = snd_hda_codec_read(codec, 0x21, 0, 15765 AC_VERB_GET_PIN_SENSE, 0) 15766 & AC_PINSENSE_PRESENCE; 15767 bits = present ? HDA_AMP_MUTE : 0; 15768 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 15769 AMP_IN_MUTE(0), bits); 15770 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 15771 AMP_IN_MUTE(0), bits); 15772 snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0, 15773 AMP_IN_MUTE(0), bits); 15774 snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1, 15775 AMP_IN_MUTE(0), bits); 15776} 15777 15778static void alc663_15jd_two_speaker_automute(struct hda_codec *codec) 15779{ 15780 unsigned int present; 15781 unsigned char bits; 15782 15783 present = snd_hda_codec_read(codec, 0x15, 0, 15784 AC_VERB_GET_PIN_SENSE, 0) 15785 & AC_PINSENSE_PRESENCE; 15786 bits = present ? HDA_AMP_MUTE : 0; 15787 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 15788 AMP_IN_MUTE(0), bits); 15789 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 15790 AMP_IN_MUTE(0), bits); 15791 snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0, 15792 AMP_IN_MUTE(0), bits); 15793 snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1, 15794 AMP_IN_MUTE(0), bits); 15795} 15796 15797static void alc662_f5z_speaker_automute(struct hda_codec *codec) 15798{ 15799 unsigned int present; 15800 unsigned char bits; 15801 15802 present = snd_hda_codec_read(codec, 0x1b, 0, 15803 AC_VERB_GET_PIN_SENSE, 0) 15804 & AC_PINSENSE_PRESENCE; 15805 bits = present ? 0 : PIN_OUT; 15806 snd_hda_codec_write(codec, 0x14, 0, 15807 AC_VERB_SET_PIN_WIDGET_CONTROL, bits); 15808} 15809 15810static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec) 15811{ 15812 unsigned int present1, present2; 15813 15814 present1 = snd_hda_codec_read(codec, 0x21, 0, 15815 AC_VERB_GET_PIN_SENSE, 0) 15816 & AC_PINSENSE_PRESENCE; 15817 present2 = snd_hda_codec_read(codec, 0x15, 0, 15818 AC_VERB_GET_PIN_SENSE, 0) 15819 & AC_PINSENSE_PRESENCE; 15820 15821 if (present1 || present2) { 15822 snd_hda_codec_write_cache(codec, 0x14, 0, 15823 AC_VERB_SET_PIN_WIDGET_CONTROL, 0); 15824 } else { 15825 snd_hda_codec_write_cache(codec, 0x14, 0, 15826 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 15827 } 15828} 15829 15830static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec) 15831{ 15832 unsigned int present1, present2; 15833 15834 present1 = snd_hda_codec_read(codec, 0x1b, 0, 15835 AC_VERB_GET_PIN_SENSE, 0) 15836 & AC_PINSENSE_PRESENCE; 15837 present2 = snd_hda_codec_read(codec, 0x15, 0, 15838 AC_VERB_GET_PIN_SENSE, 0) 15839 & AC_PINSENSE_PRESENCE; 15840 15841 if (present1 || present2) { 15842 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 15843 AMP_IN_MUTE(0), AMP_IN_MUTE(0)); 15844 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 15845 AMP_IN_MUTE(0), AMP_IN_MUTE(0)); 15846 } else { 15847 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 15848 AMP_IN_MUTE(0), 0); 15849 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 15850 AMP_IN_MUTE(0), 0); 15851 } 15852} 15853 15854static void alc663_m51va_mic_automute(struct hda_codec *codec) 15855{ 15856 unsigned int present; 15857 15858 present = snd_hda_codec_read(codec, 0x18, 0, 15859 AC_VERB_GET_PIN_SENSE, 0) 15860 & AC_PINSENSE_PRESENCE; 15861 snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE, 15862 0x7000 | (0x00 << 8) | (present ? 0 : 0x80)); 15863 snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE, 15864 0x7000 | (0x00 << 8) | (present ? 0 : 0x80)); 15865 snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE, 15866 0x7000 | (0x09 << 8) | (present ? 0x80 : 0)); 15867 snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE, 15868 0x7000 | (0x09 << 8) | (present ? 0x80 : 0)); 15869} 15870 15871static void alc663_m51va_unsol_event(struct hda_codec *codec, 15872 unsigned int res) 15873{ 15874 switch (res >> 26) { 15875 case ALC880_HP_EVENT: 15876 alc663_m51va_speaker_automute(codec); 15877 break; 15878 case ALC880_MIC_EVENT: 15879 alc663_m51va_mic_automute(codec); 15880 break; 15881 } 15882} 15883 15884static void alc663_m51va_inithook(struct hda_codec *codec) 15885{ 15886 alc663_m51va_speaker_automute(codec); 15887 alc663_m51va_mic_automute(codec); 15888} 15889 15890/* ***************** Mode1 ******************************/ 15891static void alc663_mode1_unsol_event(struct hda_codec *codec, 15892 unsigned int res) 15893{ 15894 switch (res >> 26) { 15895 case ALC880_HP_EVENT: 15896 alc663_m51va_speaker_automute(codec); 15897 break; 15898 case ALC880_MIC_EVENT: 15899 alc662_eeepc_mic_automute(codec); 15900 break; 15901 } 15902} 15903 15904static void alc663_mode1_inithook(struct hda_codec *codec) 15905{ 15906 alc663_m51va_speaker_automute(codec); 15907 alc662_eeepc_mic_automute(codec); 15908} 15909/* ***************** Mode2 ******************************/ 15910static void alc662_mode2_unsol_event(struct hda_codec *codec, 15911 unsigned int res) 15912{ 15913 switch (res >> 26) { 15914 case ALC880_HP_EVENT: 15915 alc662_f5z_speaker_automute(codec); 15916 break; 15917 case ALC880_MIC_EVENT: 15918 alc662_eeepc_mic_automute(codec); 15919 break; 15920 } 15921} 15922 15923static void alc662_mode2_inithook(struct hda_codec *codec) 15924{ 15925 alc662_f5z_speaker_automute(codec); 15926 alc662_eeepc_mic_automute(codec); 15927} 15928/* ***************** Mode3 ******************************/ 15929static void alc663_mode3_unsol_event(struct hda_codec *codec, 15930 unsigned int res) 15931{ 15932 switch (res >> 26) { 15933 case ALC880_HP_EVENT: 15934 alc663_two_hp_m1_speaker_automute(codec); 15935 break; 15936 case ALC880_MIC_EVENT: 15937 alc662_eeepc_mic_automute(codec); 15938 break; 15939 } 15940} 15941 15942static void alc663_mode3_inithook(struct hda_codec *codec) 15943{ 15944 alc663_two_hp_m1_speaker_automute(codec); 15945 alc662_eeepc_mic_automute(codec); 15946} 15947/* ***************** Mode4 ******************************/ 15948static void alc663_mode4_unsol_event(struct hda_codec *codec, 15949 unsigned int res) 15950{ 15951 switch (res >> 26) { 15952 case ALC880_HP_EVENT: 15953 alc663_21jd_two_speaker_automute(codec); 15954 break; 15955 case ALC880_MIC_EVENT: 15956 alc662_eeepc_mic_automute(codec); 15957 break; 15958 } 15959} 15960 15961static void alc663_mode4_inithook(struct hda_codec *codec) 15962{ 15963 alc663_21jd_two_speaker_automute(codec); 15964 alc662_eeepc_mic_automute(codec); 15965} 15966/* ***************** Mode5 ******************************/ 15967static void alc663_mode5_unsol_event(struct hda_codec *codec, 15968 unsigned int res) 15969{ 15970 switch (res >> 26) { 15971 case ALC880_HP_EVENT: 15972 alc663_15jd_two_speaker_automute(codec); 15973 break; 15974 case ALC880_MIC_EVENT: 15975 alc662_eeepc_mic_automute(codec); 15976 break; 15977 } 15978} 15979 15980static void alc663_mode5_inithook(struct hda_codec *codec) 15981{ 15982 alc663_15jd_two_speaker_automute(codec); 15983 alc662_eeepc_mic_automute(codec); 15984} 15985/* ***************** Mode6 ******************************/ 15986static void alc663_mode6_unsol_event(struct hda_codec *codec, 15987 unsigned int res) 15988{ 15989 switch (res >> 26) { 15990 case ALC880_HP_EVENT: 15991 alc663_two_hp_m2_speaker_automute(codec); 15992 break; 15993 case ALC880_MIC_EVENT: 15994 alc662_eeepc_mic_automute(codec); 15995 break; 15996 } 15997} 15998 15999static void alc663_mode6_inithook(struct hda_codec *codec) 16000{ 16001 alc663_two_hp_m2_speaker_automute(codec); 16002 alc662_eeepc_mic_automute(codec); 16003} 16004 16005static void alc663_g71v_hp_automute(struct hda_codec *codec) 16006{ 16007 unsigned int present; 16008 unsigned char bits; 16009 16010 present = snd_hda_codec_read(codec, 0x21, 0, 16011 AC_VERB_GET_PIN_SENSE, 0) 16012 & AC_PINSENSE_PRESENCE; 16013 bits = present ? HDA_AMP_MUTE : 0; 16014 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 16015 HDA_AMP_MUTE, bits); 16016 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 16017 HDA_AMP_MUTE, bits); 16018} 16019 16020static void alc663_g71v_front_automute(struct hda_codec *codec) 16021{ 16022 unsigned int present; 16023 unsigned char bits; 16024 16025 present = snd_hda_codec_read(codec, 0x15, 0, 16026 AC_VERB_GET_PIN_SENSE, 0) 16027 & AC_PINSENSE_PRESENCE; 16028 bits = present ? HDA_AMP_MUTE : 0; 16029 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 16030 HDA_AMP_MUTE, bits); 16031} 16032 16033static void alc663_g71v_unsol_event(struct hda_codec *codec, 16034 unsigned int res) 16035{ 16036 switch (res >> 26) { 16037 case ALC880_HP_EVENT: 16038 alc663_g71v_hp_automute(codec); 16039 break; 16040 case ALC880_FRONT_EVENT: 16041 alc663_g71v_front_automute(codec); 16042 break; 16043 case ALC880_MIC_EVENT: 16044 alc662_eeepc_mic_automute(codec); 16045 break; 16046 } 16047} 16048 16049static void alc663_g71v_inithook(struct hda_codec *codec) 16050{ 16051 alc663_g71v_front_automute(codec); 16052 alc663_g71v_hp_automute(codec); 16053 alc662_eeepc_mic_automute(codec); 16054} 16055 16056static void alc663_g50v_unsol_event(struct hda_codec *codec, 16057 unsigned int res) 16058{ 16059 switch (res >> 26) { 16060 case ALC880_HP_EVENT: 16061 alc663_m51va_speaker_automute(codec); 16062 break; 16063 case ALC880_MIC_EVENT: 16064 alc662_eeepc_mic_automute(codec); 16065 break; 16066 } 16067} 16068 16069static void alc663_g50v_inithook(struct hda_codec *codec) 16070{ 16071 alc663_m51va_speaker_automute(codec); 16072 alc662_eeepc_mic_automute(codec); 16073} 16074 16075/* bind hp and internal speaker mute (with plug check) */ 16076static int alc662_ecs_master_sw_put(struct snd_kcontrol *kcontrol, 16077 struct snd_ctl_elem_value *ucontrol) 16078{ 16079 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 16080 long *valp = ucontrol->value.integer.value; 16081 int change; 16082 16083 change = snd_hda_codec_amp_update(codec, 0x1b, 0, HDA_OUTPUT, 0, 16084 HDA_AMP_MUTE, 16085 valp[0] ? 0 : HDA_AMP_MUTE); 16086 change |= snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0, 16087 HDA_AMP_MUTE, 16088 valp[1] ? 0 : HDA_AMP_MUTE); 16089 if (change) 16090 alc262_hippo1_automute(codec); 16091 return change; 16092} 16093 16094static struct snd_kcontrol_new alc662_ecs_mixer[] = { 16095 HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT), 16096 { 16097 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 16098 .name = "Master Playback Switch", 16099 .info = snd_hda_mixer_amp_switch_info, 16100 .get = snd_hda_mixer_amp_switch_get, 16101 .put = alc662_ecs_master_sw_put, 16102 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT), 16103 }, 16104 16105 HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT), 16106 HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT), 16107 HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT), 16108 16109 HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT), 16110 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 16111 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 16112 { } /* end */ 16113}; 16114 16115#ifdef CONFIG_SND_HDA_POWER_SAVE 16116#define alc662_loopbacks alc880_loopbacks 16117#endif 16118 16119 16120/* pcm configuration: identiacal with ALC880 */ 16121#define alc662_pcm_analog_playback alc880_pcm_analog_playback 16122#define alc662_pcm_analog_capture alc880_pcm_analog_capture 16123#define alc662_pcm_digital_playback alc880_pcm_digital_playback 16124#define alc662_pcm_digital_capture alc880_pcm_digital_capture 16125 16126/* 16127 * configuration and preset 16128 */ 16129static const char *alc662_models[ALC662_MODEL_LAST] = { 16130 [ALC662_3ST_2ch_DIG] = "3stack-dig", 16131 [ALC662_3ST_6ch_DIG] = "3stack-6ch-dig", 16132 [ALC662_3ST_6ch] = "3stack-6ch", 16133 [ALC662_5ST_DIG] = "6stack-dig", 16134 [ALC662_LENOVO_101E] = "lenovo-101e", 16135 [ALC662_ASUS_EEEPC_P701] = "eeepc-p701", 16136 [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20", 16137 [ALC662_ECS] = "ecs", 16138 [ALC663_ASUS_M51VA] = "m51va", 16139 [ALC663_ASUS_G71V] = "g71v", 16140 [ALC663_ASUS_H13] = "h13", 16141 [ALC663_ASUS_G50V] = "g50v", 16142 [ALC663_ASUS_MODE1] = "asus-mode1", 16143 [ALC662_ASUS_MODE2] = "asus-mode2", 16144 [ALC663_ASUS_MODE3] = "asus-mode3", 16145 [ALC663_ASUS_MODE4] = "asus-mode4", 16146 [ALC663_ASUS_MODE5] = "asus-mode5", 16147 [ALC663_ASUS_MODE6] = "asus-mode6", 16148 [ALC662_AUTO] = "auto", 16149}; 16150 16151static struct snd_pci_quirk alc662_cfg_tbl[] = { 16152 SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA), 16153 SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V), 16154 SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG), 16155 SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701), 16156 SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20), 16157 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1), 16158 SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1), 16159 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1), 16160 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1), 16161 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1), 16162 SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1), 16163 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1), 16164 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1), 16165 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1), 16166 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1), 16167 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2), 16168 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2), 16169 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2), 16170 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2), 16171 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2), 16172 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2), 16173 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2), 16174 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2), 16175 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2), 16176 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2), 16177 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2), 16178 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2), 16179 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3), 16180 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3), 16181 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3), 16182 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3), 16183 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3), 16184 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4), 16185 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5), 16186 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6), 16187 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6), 16188 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6), 16189 SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K", 16190 ALC662_3ST_6ch_DIG), 16191 SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E), 16192 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS), 16193 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS), 16194 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L", 16195 ALC662_3ST_6ch_DIG), 16196 SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG), 16197 SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0", 16198 ALC662_3ST_6ch_DIG), 16199 SND_PCI_QUIRK(0x1854, 0x2000, "ASUS H13-2000", ALC663_ASUS_H13), 16200 SND_PCI_QUIRK(0x1854, 0x2001, "ASUS H13-2001", ALC663_ASUS_H13), 16201 SND_PCI_QUIRK(0x1854, 0x2002, "ASUS H13-2002", ALC663_ASUS_H13), 16202 {} 16203}; 16204 16205static struct alc_config_preset alc662_presets[] = { 16206 [ALC662_3ST_2ch_DIG] = { 16207 .mixers = { alc662_3ST_2ch_mixer }, 16208 .init_verbs = { alc662_init_verbs }, 16209 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16210 .dac_nids = alc662_dac_nids, 16211 .dig_out_nid = ALC662_DIGOUT_NID, 16212 .dig_in_nid = ALC662_DIGIN_NID, 16213 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16214 .channel_mode = alc662_3ST_2ch_modes, 16215 .input_mux = &alc662_capture_source, 16216 }, 16217 [ALC662_3ST_6ch_DIG] = { 16218 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer }, 16219 .init_verbs = { alc662_init_verbs }, 16220 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16221 .dac_nids = alc662_dac_nids, 16222 .dig_out_nid = ALC662_DIGOUT_NID, 16223 .dig_in_nid = ALC662_DIGIN_NID, 16224 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes), 16225 .channel_mode = alc662_3ST_6ch_modes, 16226 .need_dac_fix = 1, 16227 .input_mux = &alc662_capture_source, 16228 }, 16229 [ALC662_3ST_6ch] = { 16230 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer }, 16231 .init_verbs = { alc662_init_verbs }, 16232 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16233 .dac_nids = alc662_dac_nids, 16234 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes), 16235 .channel_mode = alc662_3ST_6ch_modes, 16236 .need_dac_fix = 1, 16237 .input_mux = &alc662_capture_source, 16238 }, 16239 [ALC662_5ST_DIG] = { 16240 .mixers = { alc662_base_mixer, alc662_chmode_mixer }, 16241 .init_verbs = { alc662_init_verbs }, 16242 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16243 .dac_nids = alc662_dac_nids, 16244 .dig_out_nid = ALC662_DIGOUT_NID, 16245 .dig_in_nid = ALC662_DIGIN_NID, 16246 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes), 16247 .channel_mode = alc662_5stack_modes, 16248 .input_mux = &alc662_capture_source, 16249 }, 16250 [ALC662_LENOVO_101E] = { 16251 .mixers = { alc662_lenovo_101e_mixer }, 16252 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs }, 16253 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16254 .dac_nids = alc662_dac_nids, 16255 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16256 .channel_mode = alc662_3ST_2ch_modes, 16257 .input_mux = &alc662_lenovo_101e_capture_source, 16258 .unsol_event = alc662_lenovo_101e_unsol_event, 16259 .init_hook = alc662_lenovo_101e_all_automute, 16260 }, 16261 [ALC662_ASUS_EEEPC_P701] = { 16262 .mixers = { alc662_eeepc_p701_mixer }, 16263 .init_verbs = { alc662_init_verbs, 16264 alc662_eeepc_sue_init_verbs }, 16265 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16266 .dac_nids = alc662_dac_nids, 16267 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16268 .channel_mode = alc662_3ST_2ch_modes, 16269 .input_mux = &alc662_eeepc_capture_source, 16270 .unsol_event = alc662_eeepc_unsol_event, 16271 .init_hook = alc662_eeepc_inithook, 16272 }, 16273 [ALC662_ASUS_EEEPC_EP20] = { 16274 .mixers = { alc662_eeepc_ep20_mixer, 16275 alc662_chmode_mixer }, 16276 .init_verbs = { alc662_init_verbs, 16277 alc662_eeepc_ep20_sue_init_verbs }, 16278 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16279 .dac_nids = alc662_dac_nids, 16280 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes), 16281 .channel_mode = alc662_3ST_6ch_modes, 16282 .input_mux = &alc662_lenovo_101e_capture_source, 16283 .unsol_event = alc662_eeepc_ep20_unsol_event, 16284 .init_hook = alc662_eeepc_ep20_inithook, 16285 }, 16286 [ALC662_ECS] = { 16287 .mixers = { alc662_ecs_mixer }, 16288 .init_verbs = { alc662_init_verbs, 16289 alc662_ecs_init_verbs }, 16290 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16291 .dac_nids = alc662_dac_nids, 16292 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16293 .channel_mode = alc662_3ST_2ch_modes, 16294 .input_mux = &alc662_eeepc_capture_source, 16295 .unsol_event = alc662_eeepc_unsol_event, 16296 .init_hook = alc662_eeepc_inithook, 16297 }, 16298 [ALC663_ASUS_M51VA] = { 16299 .mixers = { alc663_m51va_mixer }, 16300 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs }, 16301 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16302 .dac_nids = alc662_dac_nids, 16303 .dig_out_nid = ALC662_DIGOUT_NID, 16304 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16305 .channel_mode = alc662_3ST_2ch_modes, 16306 .input_mux = &alc663_m51va_capture_source, 16307 .unsol_event = alc663_m51va_unsol_event, 16308 .init_hook = alc663_m51va_inithook, 16309 }, 16310 [ALC663_ASUS_G71V] = { 16311 .mixers = { alc663_g71v_mixer }, 16312 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs }, 16313 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16314 .dac_nids = alc662_dac_nids, 16315 .dig_out_nid = ALC662_DIGOUT_NID, 16316 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16317 .channel_mode = alc662_3ST_2ch_modes, 16318 .input_mux = &alc662_eeepc_capture_source, 16319 .unsol_event = alc663_g71v_unsol_event, 16320 .init_hook = alc663_g71v_inithook, 16321 }, 16322 [ALC663_ASUS_H13] = { 16323 .mixers = { alc663_m51va_mixer }, 16324 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs }, 16325 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16326 .dac_nids = alc662_dac_nids, 16327 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16328 .channel_mode = alc662_3ST_2ch_modes, 16329 .input_mux = &alc663_m51va_capture_source, 16330 .unsol_event = alc663_m51va_unsol_event, 16331 .init_hook = alc663_m51va_inithook, 16332 }, 16333 [ALC663_ASUS_G50V] = { 16334 .mixers = { alc663_g50v_mixer }, 16335 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs }, 16336 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16337 .dac_nids = alc662_dac_nids, 16338 .dig_out_nid = ALC662_DIGOUT_NID, 16339 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes), 16340 .channel_mode = alc662_3ST_6ch_modes, 16341 .input_mux = &alc663_capture_source, 16342 .unsol_event = alc663_g50v_unsol_event, 16343 .init_hook = alc663_g50v_inithook, 16344 }, 16345 [ALC663_ASUS_MODE1] = { 16346 .mixers = { alc663_m51va_mixer }, 16347 .cap_mixer = alc662_auto_capture_mixer, 16348 .init_verbs = { alc662_init_verbs, 16349 alc663_21jd_amic_init_verbs }, 16350 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16351 .hp_nid = 0x03, 16352 .dac_nids = alc662_dac_nids, 16353 .dig_out_nid = ALC662_DIGOUT_NID, 16354 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16355 .channel_mode = alc662_3ST_2ch_modes, 16356 .input_mux = &alc662_eeepc_capture_source, 16357 .unsol_event = alc663_mode1_unsol_event, 16358 .init_hook = alc663_mode1_inithook, 16359 }, 16360 [ALC662_ASUS_MODE2] = { 16361 .mixers = { alc662_1bjd_mixer }, 16362 .cap_mixer = alc662_auto_capture_mixer, 16363 .init_verbs = { alc662_init_verbs, 16364 alc662_1bjd_amic_init_verbs }, 16365 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16366 .dac_nids = alc662_dac_nids, 16367 .dig_out_nid = ALC662_DIGOUT_NID, 16368 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16369 .channel_mode = alc662_3ST_2ch_modes, 16370 .input_mux = &alc662_eeepc_capture_source, 16371 .unsol_event = alc662_mode2_unsol_event, 16372 .init_hook = alc662_mode2_inithook, 16373 }, 16374 [ALC663_ASUS_MODE3] = { 16375 .mixers = { alc663_two_hp_m1_mixer }, 16376 .cap_mixer = alc662_auto_capture_mixer, 16377 .init_verbs = { alc662_init_verbs, 16378 alc663_two_hp_amic_m1_init_verbs }, 16379 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16380 .hp_nid = 0x03, 16381 .dac_nids = alc662_dac_nids, 16382 .dig_out_nid = ALC662_DIGOUT_NID, 16383 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16384 .channel_mode = alc662_3ST_2ch_modes, 16385 .input_mux = &alc662_eeepc_capture_source, 16386 .unsol_event = alc663_mode3_unsol_event, 16387 .init_hook = alc663_mode3_inithook, 16388 }, 16389 [ALC663_ASUS_MODE4] = { 16390 .mixers = { alc663_asus_21jd_clfe_mixer }, 16391 .cap_mixer = alc662_auto_capture_mixer, 16392 .init_verbs = { alc662_init_verbs, 16393 alc663_21jd_amic_init_verbs}, 16394 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16395 .hp_nid = 0x03, 16396 .dac_nids = alc662_dac_nids, 16397 .dig_out_nid = ALC662_DIGOUT_NID, 16398 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16399 .channel_mode = alc662_3ST_2ch_modes, 16400 .input_mux = &alc662_eeepc_capture_source, 16401 .unsol_event = alc663_mode4_unsol_event, 16402 .init_hook = alc663_mode4_inithook, 16403 }, 16404 [ALC663_ASUS_MODE5] = { 16405 .mixers = { alc663_asus_15jd_clfe_mixer }, 16406 .cap_mixer = alc662_auto_capture_mixer, 16407 .init_verbs = { alc662_init_verbs, 16408 alc663_15jd_amic_init_verbs }, 16409 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16410 .hp_nid = 0x03, 16411 .dac_nids = alc662_dac_nids, 16412 .dig_out_nid = ALC662_DIGOUT_NID, 16413 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16414 .channel_mode = alc662_3ST_2ch_modes, 16415 .input_mux = &alc662_eeepc_capture_source, 16416 .unsol_event = alc663_mode5_unsol_event, 16417 .init_hook = alc663_mode5_inithook, 16418 }, 16419 [ALC663_ASUS_MODE6] = { 16420 .mixers = { alc663_two_hp_m2_mixer }, 16421 .cap_mixer = alc662_auto_capture_mixer, 16422 .init_verbs = { alc662_init_verbs, 16423 alc663_two_hp_amic_m2_init_verbs }, 16424 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16425 .hp_nid = 0x03, 16426 .dac_nids = alc662_dac_nids, 16427 .dig_out_nid = ALC662_DIGOUT_NID, 16428 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16429 .channel_mode = alc662_3ST_2ch_modes, 16430 .input_mux = &alc662_eeepc_capture_source, 16431 .unsol_event = alc663_mode6_unsol_event, 16432 .init_hook = alc663_mode6_inithook, 16433 }, 16434}; 16435 16436 16437/* 16438 * BIOS auto configuration 16439 */ 16440 16441/* add playback controls from the parsed DAC table */ 16442static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec, 16443 const struct auto_pin_cfg *cfg) 16444{ 16445 char name[32]; 16446 static const char *chname[4] = { 16447 "Front", "Surround", NULL /*CLFE*/, "Side" 16448 }; 16449 hda_nid_t nid; 16450 int i, err; 16451 16452 for (i = 0; i < cfg->line_outs; i++) { 16453 if (!spec->multiout.dac_nids[i]) 16454 continue; 16455 nid = alc880_idx_to_dac(i); 16456 if (i == 2) { 16457 /* Center/LFE */ 16458 err = add_control(spec, ALC_CTL_WIDGET_VOL, 16459 "Center Playback Volume", 16460 HDA_COMPOSE_AMP_VAL(nid, 1, 0, 16461 HDA_OUTPUT)); 16462 if (err < 0) 16463 return err; 16464 err = add_control(spec, ALC_CTL_WIDGET_VOL, 16465 "LFE Playback Volume", 16466 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 16467 HDA_OUTPUT)); 16468 if (err < 0) 16469 return err; 16470 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 16471 "Center Playback Switch", 16472 HDA_COMPOSE_AMP_VAL(0x0e, 1, 0, 16473 HDA_INPUT)); 16474 if (err < 0) 16475 return err; 16476 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 16477 "LFE Playback Switch", 16478 HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, 16479 HDA_INPUT)); 16480 if (err < 0) 16481 return err; 16482 } else { 16483 sprintf(name, "%s Playback Volume", chname[i]); 16484 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 16485 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 16486 HDA_OUTPUT)); 16487 if (err < 0) 16488 return err; 16489 sprintf(name, "%s Playback Switch", chname[i]); 16490 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 16491 HDA_COMPOSE_AMP_VAL(alc880_idx_to_mixer(i), 16492 3, 0, HDA_INPUT)); 16493 if (err < 0) 16494 return err; 16495 } 16496 } 16497 return 0; 16498} 16499 16500/* add playback controls for speaker and HP outputs */ 16501static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin, 16502 const char *pfx) 16503{ 16504 hda_nid_t nid; 16505 int err; 16506 char name[32]; 16507 16508 if (!pin) 16509 return 0; 16510 16511 if (pin == 0x17) { 16512 /* ALC663 has a mono output pin on 0x17 */ 16513 sprintf(name, "%s Playback Switch", pfx); 16514 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 16515 HDA_COMPOSE_AMP_VAL(pin, 2, 0, HDA_OUTPUT)); 16516 return err; 16517 } 16518 16519 if (alc880_is_fixed_pin(pin)) { 16520 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin)); 16521 /* printk(KERN_DEBUG "DAC nid=%x\n",nid); */ 16522 /* specify the DAC as the extra output */ 16523 if (!spec->multiout.hp_nid) 16524 spec->multiout.hp_nid = nid; 16525 else 16526 spec->multiout.extra_out_nid[0] = nid; 16527 /* control HP volume/switch on the output mixer amp */ 16528 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin)); 16529 sprintf(name, "%s Playback Volume", pfx); 16530 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 16531 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 16532 if (err < 0) 16533 return err; 16534 sprintf(name, "%s Playback Switch", pfx); 16535 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 16536 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT)); 16537 if (err < 0) 16538 return err; 16539 } else if (alc880_is_multi_pin(pin)) { 16540 /* set manual connection */ 16541 /* we have only a switch on HP-out PIN */ 16542 sprintf(name, "%s Playback Switch", pfx); 16543 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 16544 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 16545 if (err < 0) 16546 return err; 16547 } 16548 return 0; 16549} 16550 16551/* create playback/capture controls for input pins */ 16552static int alc662_auto_create_analog_input_ctls(struct alc_spec *spec, 16553 const struct auto_pin_cfg *cfg) 16554{ 16555 struct hda_input_mux *imux = &spec->private_imux[0]; 16556 int i, err, idx; 16557 16558 for (i = 0; i < AUTO_PIN_LAST; i++) { 16559 if (alc880_is_input_pin(cfg->input_pins[i])) { 16560 idx = alc880_input_pin_idx(cfg->input_pins[i]); 16561 err = new_analog_input(spec, cfg->input_pins[i], 16562 auto_pin_cfg_labels[i], 16563 idx, 0x0b); 16564 if (err < 0) 16565 return err; 16566 imux->items[imux->num_items].label = 16567 auto_pin_cfg_labels[i]; 16568 imux->items[imux->num_items].index = 16569 alc880_input_pin_idx(cfg->input_pins[i]); 16570 imux->num_items++; 16571 } 16572 } 16573 return 0; 16574} 16575 16576static void alc662_auto_set_output_and_unmute(struct hda_codec *codec, 16577 hda_nid_t nid, int pin_type, 16578 int dac_idx) 16579{ 16580 alc_set_pin_output(codec, nid, pin_type); 16581 /* need the manual connection? */ 16582 if (alc880_is_multi_pin(nid)) { 16583 struct alc_spec *spec = codec->spec; 16584 int idx = alc880_multi_pin_idx(nid); 16585 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0, 16586 AC_VERB_SET_CONNECT_SEL, 16587 alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx])); 16588 } 16589} 16590 16591static void alc662_auto_init_multi_out(struct hda_codec *codec) 16592{ 16593 struct alc_spec *spec = codec->spec; 16594 int i; 16595 16596 alc_subsystem_id(codec, 0x15, 0x1b, 0x14); 16597 for (i = 0; i <= HDA_SIDE; i++) { 16598 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 16599 int pin_type = get_pin_type(spec->autocfg.line_out_type); 16600 if (nid) 16601 alc662_auto_set_output_and_unmute(codec, nid, pin_type, 16602 i); 16603 } 16604} 16605 16606static void alc662_auto_init_hp_out(struct hda_codec *codec) 16607{ 16608 struct alc_spec *spec = codec->spec; 16609 hda_nid_t pin; 16610 16611 pin = spec->autocfg.hp_pins[0]; 16612 if (pin) /* connect to front */ 16613 /* use dac 0 */ 16614 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 16615 pin = spec->autocfg.speaker_pins[0]; 16616 if (pin) 16617 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 16618} 16619 16620#define alc662_is_input_pin(nid) alc880_is_input_pin(nid) 16621#define ALC662_PIN_CD_NID ALC880_PIN_CD_NID 16622 16623static void alc662_auto_init_analog_input(struct hda_codec *codec) 16624{ 16625 struct alc_spec *spec = codec->spec; 16626 int i; 16627 16628 for (i = 0; i < AUTO_PIN_LAST; i++) { 16629 hda_nid_t nid = spec->autocfg.input_pins[i]; 16630 if (alc662_is_input_pin(nid)) { 16631 snd_hda_codec_write(codec, nid, 0, 16632 AC_VERB_SET_PIN_WIDGET_CONTROL, 16633 (i <= AUTO_PIN_FRONT_MIC ? 16634 PIN_VREF80 : PIN_IN)); 16635 if (nid != ALC662_PIN_CD_NID) 16636 snd_hda_codec_write(codec, nid, 0, 16637 AC_VERB_SET_AMP_GAIN_MUTE, 16638 AMP_OUT_MUTE); 16639 } 16640 } 16641} 16642 16643#define alc662_auto_init_input_src alc882_auto_init_input_src 16644 16645static int alc662_parse_auto_config(struct hda_codec *codec) 16646{ 16647 struct alc_spec *spec = codec->spec; 16648 int err; 16649 static hda_nid_t alc662_ignore[] = { 0x1d, 0 }; 16650 16651 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 16652 alc662_ignore); 16653 if (err < 0) 16654 return err; 16655 if (!spec->autocfg.line_outs) 16656 return 0; /* can't find valid BIOS pin config */ 16657 16658 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg); 16659 if (err < 0) 16660 return err; 16661 err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg); 16662 if (err < 0) 16663 return err; 16664 err = alc662_auto_create_extra_out(spec, 16665 spec->autocfg.speaker_pins[0], 16666 "Speaker"); 16667 if (err < 0) 16668 return err; 16669 err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0], 16670 "Headphone"); 16671 if (err < 0) 16672 return err; 16673 err = alc662_auto_create_analog_input_ctls(spec, &spec->autocfg); 16674 if (err < 0) 16675 return err; 16676 16677 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 16678 16679 if (spec->autocfg.dig_out_pin) 16680 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID; 16681 16682 if (spec->kctls.list) 16683 add_mixer(spec, spec->kctls.list); 16684 16685 spec->num_mux_defs = 1; 16686 spec->input_mux = &spec->private_imux[0]; 16687 16688 add_verb(spec, alc662_auto_init_verbs); 16689 if (codec->vendor_id == 0x10ec0663) 16690 add_verb(spec, alc663_auto_init_verbs); 16691 16692 err = alc_auto_add_mic_boost(codec); 16693 if (err < 0) 16694 return err; 16695 16696 store_pin_configs(codec); 16697 return 1; 16698} 16699 16700/* additional initialization for auto-configuration model */ 16701static void alc662_auto_init(struct hda_codec *codec) 16702{ 16703 struct alc_spec *spec = codec->spec; 16704 alc662_auto_init_multi_out(codec); 16705 alc662_auto_init_hp_out(codec); 16706 alc662_auto_init_analog_input(codec); 16707 alc662_auto_init_input_src(codec); 16708 if (spec->unsol_event) 16709 alc_inithook(codec); 16710} 16711 16712static int patch_alc662(struct hda_codec *codec) 16713{ 16714 struct alc_spec *spec; 16715 int err, board_config; 16716 16717 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 16718 if (!spec) 16719 return -ENOMEM; 16720 16721 codec->spec = spec; 16722 16723 alc_fix_pll_init(codec, 0x20, 0x04, 15); 16724 16725 board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST, 16726 alc662_models, 16727 alc662_cfg_tbl); 16728 if (board_config < 0) { 16729 printk(KERN_INFO "hda_codec: Unknown model for ALC662, " 16730 "trying auto-probe from BIOS...\n"); 16731 board_config = ALC662_AUTO; 16732 } 16733 16734 if (board_config == ALC662_AUTO) { 16735 /* automatic parse from the BIOS config */ 16736 err = alc662_parse_auto_config(codec); 16737 if (err < 0) { 16738 alc_free(codec); 16739 return err; 16740 } else if (!err) { 16741 printk(KERN_INFO 16742 "hda_codec: Cannot set up configuration " 16743 "from BIOS. Using base mode...\n"); 16744 board_config = ALC662_3ST_2ch_DIG; 16745 } 16746 } 16747 16748 err = snd_hda_attach_beep_device(codec, 0x1); 16749 if (err < 0) { 16750 alc_free(codec); 16751 return err; 16752 } 16753 16754 if (board_config != ALC662_AUTO) 16755 setup_preset(spec, &alc662_presets[board_config]); 16756 16757 if (codec->vendor_id == 0x10ec0663) { 16758 spec->stream_name_analog = "ALC663 Analog"; 16759 spec->stream_name_digital = "ALC663 Digital"; 16760 } else if (codec->vendor_id == 0x10ec0272) { 16761 spec->stream_name_analog = "ALC272 Analog"; 16762 spec->stream_name_digital = "ALC272 Digital"; 16763 } else { 16764 spec->stream_name_analog = "ALC662 Analog"; 16765 spec->stream_name_digital = "ALC662 Digital"; 16766 } 16767 16768 spec->stream_analog_playback = &alc662_pcm_analog_playback; 16769 spec->stream_analog_capture = &alc662_pcm_analog_capture; 16770 16771 spec->stream_digital_playback = &alc662_pcm_digital_playback; 16772 spec->stream_digital_capture = &alc662_pcm_digital_capture; 16773 16774 spec->adc_nids = alc662_adc_nids; 16775 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids); 16776 spec->capsrc_nids = alc662_capsrc_nids; 16777 spec->capture_style = CAPT_MIX; 16778 16779 if (!spec->cap_mixer) 16780 set_capture_mixer(spec); 16781 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 16782 16783 spec->vmaster_nid = 0x02; 16784 16785 codec->patch_ops = alc_patch_ops; 16786 if (board_config == ALC662_AUTO) 16787 spec->init_hook = alc662_auto_init; 16788#ifdef CONFIG_SND_HDA_POWER_SAVE 16789 if (!spec->loopback.amplist) 16790 spec->loopback.amplist = alc662_loopbacks; 16791#endif 16792 codec->proc_widget_hook = print_realtek_coef; 16793 16794 return 0; 16795} 16796 16797/* 16798 * patch entries 16799 */ 16800static struct hda_codec_preset snd_hda_preset_realtek[] = { 16801 { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 }, 16802 { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 }, 16803 { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 }, 16804 { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 }, 16805 { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 }, 16806 { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 }, 16807 { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660", 16808 .patch = patch_alc861 }, 16809 { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd }, 16810 { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 }, 16811 { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd }, 16812 { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2", 16813 .patch = patch_alc883 }, 16814 { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1", 16815 .patch = patch_alc662 }, 16816 { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 }, 16817 { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 }, 16818 { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 }, 16819 { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 }, 16820 { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A", 16821 .patch = patch_alc882 }, /* should be patch_alc883() in future */ 16822 { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A", 16823 .patch = patch_alc882 }, /* should be patch_alc883() in future */ 16824 { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 }, 16825 { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc883 }, 16826 { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200", 16827 .patch = patch_alc883 }, 16828 { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 }, 16829 { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 }, 16830 {} /* terminator */ 16831}; 16832 16833MODULE_ALIAS("snd-hda-codec-id:10ec*"); 16834 16835MODULE_LICENSE("GPL"); 16836MODULE_DESCRIPTION("Realtek HD-audio codec"); 16837 16838static struct hda_codec_preset_list realtek_list = { 16839 .preset = snd_hda_preset_realtek, 16840 .owner = THIS_MODULE, 16841}; 16842 16843static int __init patch_realtek_init(void) 16844{ 16845 return snd_hda_add_codec_preset(&realtek_list); 16846} 16847 16848static void __exit patch_realtek_exit(void) 16849{ 16850 snd_hda_delete_codec_preset(&realtek_list); 16851} 16852 16853module_init(patch_realtek_init) 16854module_exit(patch_realtek_exit) 16855