patch_realtek.c revision 946835074e026f4bbe9f3c2b091dca6346bd1474
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 0x10ec0272: 1058 case 0x10ec0660: 1059 case 0x10ec0662: 1060 case 0x10ec0663: 1061 case 0x10ec0862: 1062 case 0x10ec0889: 1063 snd_hda_codec_write(codec, 0x14, 0, 1064 AC_VERB_SET_EAPD_BTLENABLE, 2); 1065 snd_hda_codec_write(codec, 0x15, 0, 1066 AC_VERB_SET_EAPD_BTLENABLE, 2); 1067 break; 1068 } 1069 switch (codec->vendor_id) { 1070 case 0x10ec0260: 1071 snd_hda_codec_write(codec, 0x1a, 0, 1072 AC_VERB_SET_COEF_INDEX, 7); 1073 tmp = snd_hda_codec_read(codec, 0x1a, 0, 1074 AC_VERB_GET_PROC_COEF, 0); 1075 snd_hda_codec_write(codec, 0x1a, 0, 1076 AC_VERB_SET_COEF_INDEX, 7); 1077 snd_hda_codec_write(codec, 0x1a, 0, 1078 AC_VERB_SET_PROC_COEF, 1079 tmp | 0x2010); 1080 break; 1081 case 0x10ec0262: 1082 case 0x10ec0880: 1083 case 0x10ec0882: 1084 case 0x10ec0883: 1085 case 0x10ec0885: 1086 case 0x10ec0887: 1087 case 0x10ec0889: 1088 snd_hda_codec_write(codec, 0x20, 0, 1089 AC_VERB_SET_COEF_INDEX, 7); 1090 tmp = snd_hda_codec_read(codec, 0x20, 0, 1091 AC_VERB_GET_PROC_COEF, 0); 1092 snd_hda_codec_write(codec, 0x20, 0, 1093 AC_VERB_SET_COEF_INDEX, 7); 1094 snd_hda_codec_write(codec, 0x20, 0, 1095 AC_VERB_SET_PROC_COEF, 1096 tmp | 0x2010); 1097 break; 1098 case 0x10ec0888: 1099 /*alc888_coef_init(codec);*/ /* called in alc_init() */ 1100 break; 1101 case 0x10ec0267: 1102 case 0x10ec0268: 1103 snd_hda_codec_write(codec, 0x20, 0, 1104 AC_VERB_SET_COEF_INDEX, 7); 1105 tmp = snd_hda_codec_read(codec, 0x20, 0, 1106 AC_VERB_GET_PROC_COEF, 0); 1107 snd_hda_codec_write(codec, 0x20, 0, 1108 AC_VERB_SET_COEF_INDEX, 7); 1109 snd_hda_codec_write(codec, 0x20, 0, 1110 AC_VERB_SET_PROC_COEF, 1111 tmp | 0x3000); 1112 break; 1113 } 1114 default: 1115 break; 1116 } 1117 1118 /* is laptop or Desktop and enable the function "Mute internal speaker 1119 * when the external headphone out jack is plugged" 1120 */ 1121 if (!(ass & 0x8000)) 1122 return; 1123 /* 1124 * 10~8 : Jack location 1125 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered 1126 * 14~13: Resvered 1127 * 15 : 1 --> enable the function "Mute internal speaker 1128 * when the external headphone out jack is plugged" 1129 */ 1130 if (!spec->autocfg.speaker_pins[0]) { 1131 if (spec->autocfg.line_out_pins[0]) 1132 spec->autocfg.speaker_pins[0] = 1133 spec->autocfg.line_out_pins[0]; 1134 else 1135 return; 1136 } 1137 1138 if (!spec->autocfg.hp_pins[0]) { 1139 tmp = (ass >> 11) & 0x3; /* HP to chassis */ 1140 if (tmp == 0) 1141 spec->autocfg.hp_pins[0] = porta; 1142 else if (tmp == 1) 1143 spec->autocfg.hp_pins[0] = porte; 1144 else if (tmp == 2) 1145 spec->autocfg.hp_pins[0] = portd; 1146 else 1147 return; 1148 } 1149 if (spec->autocfg.hp_pins[0]) 1150 snd_hda_codec_write(codec, spec->autocfg.hp_pins[0], 0, 1151 AC_VERB_SET_UNSOLICITED_ENABLE, 1152 AC_USRSP_EN | ALC880_HP_EVENT); 1153 1154#if 0 /* it's broken in some acses -- temporarily disabled */ 1155 if (spec->autocfg.input_pins[AUTO_PIN_MIC] && 1156 spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC]) 1157 snd_hda_codec_write(codec, 1158 spec->autocfg.input_pins[AUTO_PIN_MIC], 0, 1159 AC_VERB_SET_UNSOLICITED_ENABLE, 1160 AC_USRSP_EN | ALC880_MIC_EVENT); 1161#endif /* disabled */ 1162 1163 spec->unsol_event = alc_sku_unsol_event; 1164} 1165 1166/* 1167 * Fix-up pin default configurations 1168 */ 1169 1170struct alc_pincfg { 1171 hda_nid_t nid; 1172 u32 val; 1173}; 1174 1175static void alc_fix_pincfg(struct hda_codec *codec, 1176 const struct snd_pci_quirk *quirk, 1177 const struct alc_pincfg **pinfix) 1178{ 1179 const struct alc_pincfg *cfg; 1180 1181 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk); 1182 if (!quirk) 1183 return; 1184 1185 cfg = pinfix[quirk->value]; 1186 for (; cfg->nid; cfg++) { 1187 int i; 1188 u32 val = cfg->val; 1189 for (i = 0; i < 4; i++) { 1190 snd_hda_codec_write(codec, cfg->nid, 0, 1191 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i, 1192 val & 0xff); 1193 val >>= 8; 1194 } 1195 } 1196} 1197 1198/* 1199 * ALC888 1200 */ 1201 1202/* 1203 * 2ch mode 1204 */ 1205static struct hda_verb alc888_4ST_ch2_intel_init[] = { 1206/* Mic-in jack as mic in */ 1207 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 1208 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 1209/* Line-in jack as Line in */ 1210 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 1211 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 1212/* Line-Out as Front */ 1213 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00}, 1214 { } /* end */ 1215}; 1216 1217/* 1218 * 4ch mode 1219 */ 1220static struct hda_verb alc888_4ST_ch4_intel_init[] = { 1221/* Mic-in jack as mic in */ 1222 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 1223 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 1224/* Line-in jack as Surround */ 1225 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1226 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1227/* Line-Out as Front */ 1228 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00}, 1229 { } /* end */ 1230}; 1231 1232/* 1233 * 6ch mode 1234 */ 1235static struct hda_verb alc888_4ST_ch6_intel_init[] = { 1236/* Mic-in jack as CLFE */ 1237 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1238 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1239/* Line-in jack as Surround */ 1240 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1241 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1242/* Line-Out as CLFE (workaround because Mic-in is not loud enough) */ 1243 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 1244 { } /* end */ 1245}; 1246 1247/* 1248 * 8ch mode 1249 */ 1250static struct hda_verb alc888_4ST_ch8_intel_init[] = { 1251/* Mic-in jack as CLFE */ 1252 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1253 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1254/* Line-in jack as Surround */ 1255 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1256 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1257/* Line-Out as Side */ 1258 { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 1259 { } /* end */ 1260}; 1261 1262static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = { 1263 { 2, alc888_4ST_ch2_intel_init }, 1264 { 4, alc888_4ST_ch4_intel_init }, 1265 { 6, alc888_4ST_ch6_intel_init }, 1266 { 8, alc888_4ST_ch8_intel_init }, 1267}; 1268 1269/* 1270 * ALC888 Fujitsu Siemens Amillo xa3530 1271 */ 1272 1273static struct hda_verb alc888_fujitsu_xa3530_verbs[] = { 1274/* Front Mic: set to PIN_IN (empty by default) */ 1275 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1276/* Connect Internal HP to Front */ 1277 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1278 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1279 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 1280/* Connect Bass HP to Front */ 1281 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1282 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1283 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 1284/* Connect Line-Out side jack (SPDIF) to Side */ 1285 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1286 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1287 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 1288/* Connect Mic jack to CLFE */ 1289 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1290 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1291 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, 1292/* Connect Line-in jack to Surround */ 1293 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1294 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1295 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, 1296/* Connect HP out jack to Front */ 1297 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1298 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1299 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 1300/* Enable unsolicited event for HP jack and Line-out jack */ 1301 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 1302 {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 1303 {} 1304}; 1305 1306static void alc888_fujitsu_xa3530_automute(struct hda_codec *codec) 1307{ 1308 unsigned int present; 1309 unsigned int bits; 1310 /* Line out presence */ 1311 present = snd_hda_codec_read(codec, 0x17, 0, 1312 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 1313 /* HP out presence */ 1314 present = present || snd_hda_codec_read(codec, 0x1b, 0, 1315 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 1316 bits = present ? HDA_AMP_MUTE : 0; 1317 /* Toggle internal speakers muting */ 1318 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 1319 HDA_AMP_MUTE, bits); 1320 /* Toggle internal bass muting */ 1321 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 1322 HDA_AMP_MUTE, bits); 1323} 1324 1325static void alc888_fujitsu_xa3530_unsol_event(struct hda_codec *codec, 1326 unsigned int res) 1327{ 1328 if (res >> 26 == ALC880_HP_EVENT) 1329 alc888_fujitsu_xa3530_automute(codec); 1330} 1331 1332 1333/* 1334 * ALC888 Acer Aspire 4930G model 1335 */ 1336 1337static struct hda_verb alc888_acer_aspire_4930g_verbs[] = { 1338/* Front Mic: set to PIN_IN (empty by default) */ 1339 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1340/* Unselect Front Mic by default in input mixer 3 */ 1341 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)}, 1342/* Enable unsolicited event for HP jack */ 1343 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 1344/* Connect Internal HP to front */ 1345 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1346 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1347 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 1348/* Connect HP out to front */ 1349 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1350 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1351 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 1352 { } 1353}; 1354 1355static struct hda_input_mux alc888_2_capture_sources[2] = { 1356 /* Front mic only available on one ADC */ 1357 { 1358 .num_items = 4, 1359 .items = { 1360 { "Mic", 0x0 }, 1361 { "Line", 0x2 }, 1362 { "CD", 0x4 }, 1363 { "Front Mic", 0xb }, 1364 }, 1365 }, 1366 { 1367 .num_items = 3, 1368 .items = { 1369 { "Mic", 0x0 }, 1370 { "Line", 0x2 }, 1371 { "CD", 0x4 }, 1372 }, 1373 } 1374}; 1375 1376static struct snd_kcontrol_new alc888_base_mixer[] = { 1377 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1378 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 1379 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1380 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 1381 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, 1382 HDA_OUTPUT), 1383 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 1384 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 1385 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 1386 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 1387 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 1388 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1389 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1390 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 1391 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 1392 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1393 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 1394 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1395 { } /* end */ 1396}; 1397 1398static void alc888_acer_aspire_4930g_automute(struct hda_codec *codec) 1399{ 1400 unsigned int present; 1401 unsigned int bits; 1402 present = snd_hda_codec_read(codec, 0x15, 0, 1403 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 1404 bits = present ? HDA_AMP_MUTE : 0; 1405 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 1406 HDA_AMP_MUTE, bits); 1407} 1408 1409static void alc888_acer_aspire_4930g_unsol_event(struct hda_codec *codec, 1410 unsigned int res) 1411{ 1412 if (res >> 26 == ALC880_HP_EVENT) 1413 alc888_acer_aspire_4930g_automute(codec); 1414} 1415 1416/* 1417 * ALC880 3-stack model 1418 * 1419 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e) 1420 * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18, 1421 * F-Mic = 0x1b, HP = 0x19 1422 */ 1423 1424static hda_nid_t alc880_dac_nids[4] = { 1425 /* front, rear, clfe, rear_surr */ 1426 0x02, 0x05, 0x04, 0x03 1427}; 1428 1429static hda_nid_t alc880_adc_nids[3] = { 1430 /* ADC0-2 */ 1431 0x07, 0x08, 0x09, 1432}; 1433 1434/* The datasheet says the node 0x07 is connected from inputs, 1435 * but it shows zero connection in the real implementation on some devices. 1436 * Note: this is a 915GAV bug, fixed on 915GLV 1437 */ 1438static hda_nid_t alc880_adc_nids_alt[2] = { 1439 /* ADC1-2 */ 1440 0x08, 0x09, 1441}; 1442 1443#define ALC880_DIGOUT_NID 0x06 1444#define ALC880_DIGIN_NID 0x0a 1445 1446static struct hda_input_mux alc880_capture_source = { 1447 .num_items = 4, 1448 .items = { 1449 { "Mic", 0x0 }, 1450 { "Front Mic", 0x3 }, 1451 { "Line", 0x2 }, 1452 { "CD", 0x4 }, 1453 }, 1454}; 1455 1456/* channel source setting (2/6 channel selection for 3-stack) */ 1457/* 2ch mode */ 1458static struct hda_verb alc880_threestack_ch2_init[] = { 1459 /* set line-in to input, mute it */ 1460 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 1461 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 1462 /* set mic-in to input vref 80%, mute it */ 1463 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 1464 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 1465 { } /* end */ 1466}; 1467 1468/* 6ch mode */ 1469static struct hda_verb alc880_threestack_ch6_init[] = { 1470 /* set line-in to output, unmute it */ 1471 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1472 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1473 /* set mic-in to output, unmute it */ 1474 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1475 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1476 { } /* end */ 1477}; 1478 1479static struct hda_channel_mode alc880_threestack_modes[2] = { 1480 { 2, alc880_threestack_ch2_init }, 1481 { 6, alc880_threestack_ch6_init }, 1482}; 1483 1484static struct snd_kcontrol_new alc880_three_stack_mixer[] = { 1485 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1486 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 1487 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 1488 HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT), 1489 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 1490 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 1491 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 1492 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 1493 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1494 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1495 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 1496 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 1497 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1498 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1499 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT), 1500 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT), 1501 HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT), 1502 { 1503 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1504 .name = "Channel Mode", 1505 .info = alc_ch_mode_info, 1506 .get = alc_ch_mode_get, 1507 .put = alc_ch_mode_put, 1508 }, 1509 { } /* end */ 1510}; 1511 1512/* capture mixer elements */ 1513static int alc_cap_vol_info(struct snd_kcontrol *kcontrol, 1514 struct snd_ctl_elem_info *uinfo) 1515{ 1516 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1517 struct alc_spec *spec = codec->spec; 1518 int err; 1519 1520 mutex_lock(&codec->control_mutex); 1521 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, 1522 HDA_INPUT); 1523 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo); 1524 mutex_unlock(&codec->control_mutex); 1525 return err; 1526} 1527 1528static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag, 1529 unsigned int size, unsigned int __user *tlv) 1530{ 1531 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1532 struct alc_spec *spec = codec->spec; 1533 int err; 1534 1535 mutex_lock(&codec->control_mutex); 1536 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, 1537 HDA_INPUT); 1538 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv); 1539 mutex_unlock(&codec->control_mutex); 1540 return err; 1541} 1542 1543typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol, 1544 struct snd_ctl_elem_value *ucontrol); 1545 1546static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol, 1547 struct snd_ctl_elem_value *ucontrol, 1548 getput_call_t func) 1549{ 1550 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1551 struct alc_spec *spec = codec->spec; 1552 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 1553 int err; 1554 1555 mutex_lock(&codec->control_mutex); 1556 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx], 1557 3, 0, HDA_INPUT); 1558 err = func(kcontrol, ucontrol); 1559 mutex_unlock(&codec->control_mutex); 1560 return err; 1561} 1562 1563static int alc_cap_vol_get(struct snd_kcontrol *kcontrol, 1564 struct snd_ctl_elem_value *ucontrol) 1565{ 1566 return alc_cap_getput_caller(kcontrol, ucontrol, 1567 snd_hda_mixer_amp_volume_get); 1568} 1569 1570static int alc_cap_vol_put(struct snd_kcontrol *kcontrol, 1571 struct snd_ctl_elem_value *ucontrol) 1572{ 1573 return alc_cap_getput_caller(kcontrol, ucontrol, 1574 snd_hda_mixer_amp_volume_put); 1575} 1576 1577/* capture mixer elements */ 1578#define alc_cap_sw_info snd_ctl_boolean_stereo_info 1579 1580static int alc_cap_sw_get(struct snd_kcontrol *kcontrol, 1581 struct snd_ctl_elem_value *ucontrol) 1582{ 1583 return alc_cap_getput_caller(kcontrol, ucontrol, 1584 snd_hda_mixer_amp_switch_get); 1585} 1586 1587static int alc_cap_sw_put(struct snd_kcontrol *kcontrol, 1588 struct snd_ctl_elem_value *ucontrol) 1589{ 1590 return alc_cap_getput_caller(kcontrol, ucontrol, 1591 snd_hda_mixer_amp_switch_put); 1592} 1593 1594#define DEFINE_CAPMIX(num) \ 1595static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \ 1596 { \ 1597 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 1598 .name = "Capture Switch", \ 1599 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \ 1600 .count = num, \ 1601 .info = alc_cap_sw_info, \ 1602 .get = alc_cap_sw_get, \ 1603 .put = alc_cap_sw_put, \ 1604 }, \ 1605 { \ 1606 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 1607 .name = "Capture Volume", \ 1608 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \ 1609 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \ 1610 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \ 1611 .count = num, \ 1612 .info = alc_cap_vol_info, \ 1613 .get = alc_cap_vol_get, \ 1614 .put = alc_cap_vol_put, \ 1615 .tlv = { .c = alc_cap_vol_tlv }, \ 1616 }, \ 1617 { \ 1618 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 1619 /* .name = "Capture Source", */ \ 1620 .name = "Input Source", \ 1621 .count = num, \ 1622 .info = alc_mux_enum_info, \ 1623 .get = alc_mux_enum_get, \ 1624 .put = alc_mux_enum_put, \ 1625 }, \ 1626 { } /* end */ \ 1627} 1628 1629/* up to three ADCs */ 1630DEFINE_CAPMIX(1); 1631DEFINE_CAPMIX(2); 1632DEFINE_CAPMIX(3); 1633 1634 1635/* 1636 * ALC880 5-stack model 1637 * 1638 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d), 1639 * Side = 0x02 (0xd) 1640 * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16 1641 * Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19 1642 */ 1643 1644/* additional mixers to alc880_three_stack_mixer */ 1645static struct snd_kcontrol_new alc880_five_stack_mixer[] = { 1646 HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1647 HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT), 1648 { } /* end */ 1649}; 1650 1651/* channel source setting (6/8 channel selection for 5-stack) */ 1652/* 6ch mode */ 1653static struct hda_verb alc880_fivestack_ch6_init[] = { 1654 /* set line-in to input, mute it */ 1655 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 1656 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 1657 { } /* end */ 1658}; 1659 1660/* 8ch mode */ 1661static struct hda_verb alc880_fivestack_ch8_init[] = { 1662 /* set line-in to output, unmute it */ 1663 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1664 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1665 { } /* end */ 1666}; 1667 1668static struct hda_channel_mode alc880_fivestack_modes[2] = { 1669 { 6, alc880_fivestack_ch6_init }, 1670 { 8, alc880_fivestack_ch8_init }, 1671}; 1672 1673 1674/* 1675 * ALC880 6-stack model 1676 * 1677 * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e), 1678 * Side = 0x05 (0x0f) 1679 * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17, 1680 * Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b 1681 */ 1682 1683static hda_nid_t alc880_6st_dac_nids[4] = { 1684 /* front, rear, clfe, rear_surr */ 1685 0x02, 0x03, 0x04, 0x05 1686}; 1687 1688static struct hda_input_mux alc880_6stack_capture_source = { 1689 .num_items = 4, 1690 .items = { 1691 { "Mic", 0x0 }, 1692 { "Front Mic", 0x1 }, 1693 { "Line", 0x2 }, 1694 { "CD", 0x4 }, 1695 }, 1696}; 1697 1698/* fixed 8-channels */ 1699static struct hda_channel_mode alc880_sixstack_modes[1] = { 1700 { 8, NULL }, 1701}; 1702 1703static struct snd_kcontrol_new alc880_six_stack_mixer[] = { 1704 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1705 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 1706 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1707 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 1708 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 1709 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 1710 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 1711 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 1712 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 1713 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 1714 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1715 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1716 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 1717 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 1718 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1719 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1720 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 1721 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 1722 { 1723 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1724 .name = "Channel Mode", 1725 .info = alc_ch_mode_info, 1726 .get = alc_ch_mode_get, 1727 .put = alc_ch_mode_put, 1728 }, 1729 { } /* end */ 1730}; 1731 1732 1733/* 1734 * ALC880 W810 model 1735 * 1736 * W810 has rear IO for: 1737 * Front (DAC 02) 1738 * Surround (DAC 03) 1739 * Center/LFE (DAC 04) 1740 * Digital out (06) 1741 * 1742 * The system also has a pair of internal speakers, and a headphone jack. 1743 * These are both connected to Line2 on the codec, hence to DAC 02. 1744 * 1745 * There is a variable resistor to control the speaker or headphone 1746 * volume. This is a hardware-only device without a software API. 1747 * 1748 * Plugging headphones in will disable the internal speakers. This is 1749 * implemented in hardware, not via the driver using jack sense. In 1750 * a similar fashion, plugging into the rear socket marked "front" will 1751 * disable both the speakers and headphones. 1752 * 1753 * For input, there's a microphone jack, and an "audio in" jack. 1754 * These may not do anything useful with this driver yet, because I 1755 * haven't setup any initialization verbs for these yet... 1756 */ 1757 1758static hda_nid_t alc880_w810_dac_nids[3] = { 1759 /* front, rear/surround, clfe */ 1760 0x02, 0x03, 0x04 1761}; 1762 1763/* fixed 6 channels */ 1764static struct hda_channel_mode alc880_w810_modes[1] = { 1765 { 6, NULL } 1766}; 1767 1768/* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */ 1769static struct snd_kcontrol_new alc880_w810_base_mixer[] = { 1770 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1771 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 1772 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1773 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 1774 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 1775 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 1776 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 1777 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 1778 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 1779 { } /* end */ 1780}; 1781 1782 1783/* 1784 * Z710V model 1785 * 1786 * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d) 1787 * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?), 1788 * Line = 0x1a 1789 */ 1790 1791static hda_nid_t alc880_z71v_dac_nids[1] = { 1792 0x02 1793}; 1794#define ALC880_Z71V_HP_DAC 0x03 1795 1796/* fixed 2 channels */ 1797static struct hda_channel_mode alc880_2_jack_modes[1] = { 1798 { 2, NULL } 1799}; 1800 1801static struct snd_kcontrol_new alc880_z71v_mixer[] = { 1802 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1803 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 1804 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1805 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT), 1806 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1807 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1808 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1809 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1810 { } /* end */ 1811}; 1812 1813 1814/* 1815 * ALC880 F1734 model 1816 * 1817 * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d) 1818 * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18 1819 */ 1820 1821static hda_nid_t alc880_f1734_dac_nids[1] = { 1822 0x03 1823}; 1824#define ALC880_F1734_HP_DAC 0x02 1825 1826static struct snd_kcontrol_new alc880_f1734_mixer[] = { 1827 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1828 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 1829 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1830 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 1831 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1832 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1833 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 1834 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 1835 { } /* end */ 1836}; 1837 1838static struct hda_input_mux alc880_f1734_capture_source = { 1839 .num_items = 2, 1840 .items = { 1841 { "Mic", 0x1 }, 1842 { "CD", 0x4 }, 1843 }, 1844}; 1845 1846 1847/* 1848 * ALC880 ASUS model 1849 * 1850 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e) 1851 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16, 1852 * Mic = 0x18, Line = 0x1a 1853 */ 1854 1855#define alc880_asus_dac_nids alc880_w810_dac_nids /* identical with w810 */ 1856#define alc880_asus_modes alc880_threestack_modes /* 2/6 channel mode */ 1857 1858static struct snd_kcontrol_new alc880_asus_mixer[] = { 1859 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1860 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 1861 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1862 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 1863 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 1864 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 1865 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 1866 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 1867 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1868 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1869 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 1870 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 1871 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1872 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1873 { 1874 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1875 .name = "Channel Mode", 1876 .info = alc_ch_mode_info, 1877 .get = alc_ch_mode_get, 1878 .put = alc_ch_mode_put, 1879 }, 1880 { } /* end */ 1881}; 1882 1883/* 1884 * ALC880 ASUS W1V model 1885 * 1886 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e) 1887 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16, 1888 * Mic = 0x18, Line = 0x1a, Line2 = 0x1b 1889 */ 1890 1891/* additional mixers to alc880_asus_mixer */ 1892static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = { 1893 HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT), 1894 HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT), 1895 { } /* end */ 1896}; 1897 1898/* TCL S700 */ 1899static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = { 1900 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1901 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 1902 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 1903 HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT), 1904 HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT), 1905 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT), 1906 HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT), 1907 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 1908 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 1909 { } /* end */ 1910}; 1911 1912/* Uniwill */ 1913static struct snd_kcontrol_new alc880_uniwill_mixer[] = { 1914 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1915 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 1916 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1917 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 1918 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 1919 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 1920 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 1921 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 1922 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1923 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1924 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 1925 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 1926 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1927 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1928 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 1929 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 1930 { 1931 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1932 .name = "Channel Mode", 1933 .info = alc_ch_mode_info, 1934 .get = alc_ch_mode_get, 1935 .put = alc_ch_mode_put, 1936 }, 1937 { } /* end */ 1938}; 1939 1940static struct snd_kcontrol_new alc880_fujitsu_mixer[] = { 1941 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1942 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 1943 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1944 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 1945 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1946 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1947 HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1948 HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1949 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 1950 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 1951 { } /* end */ 1952}; 1953 1954static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = { 1955 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1956 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 1957 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1958 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 1959 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1960 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1961 { } /* end */ 1962}; 1963 1964/* 1965 * virtual master controls 1966 */ 1967 1968/* 1969 * slave controls for virtual master 1970 */ 1971static const char *alc_slave_vols[] = { 1972 "Front Playback Volume", 1973 "Surround Playback Volume", 1974 "Center Playback Volume", 1975 "LFE Playback Volume", 1976 "Side Playback Volume", 1977 "Headphone Playback Volume", 1978 "Speaker Playback Volume", 1979 "Mono Playback Volume", 1980 "Line-Out Playback Volume", 1981 "PCM Playback Volume", 1982 NULL, 1983}; 1984 1985static const char *alc_slave_sws[] = { 1986 "Front Playback Switch", 1987 "Surround Playback Switch", 1988 "Center Playback Switch", 1989 "LFE Playback Switch", 1990 "Side Playback Switch", 1991 "Headphone Playback Switch", 1992 "Speaker Playback Switch", 1993 "Mono Playback Switch", 1994 "IEC958 Playback Switch", 1995 NULL, 1996}; 1997 1998/* 1999 * build control elements 2000 */ 2001 2002static void alc_free_kctls(struct hda_codec *codec); 2003 2004/* additional beep mixers; the actual parameters are overwritten at build */ 2005static struct snd_kcontrol_new alc_beep_mixer[] = { 2006 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT), 2007 HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_INPUT), 2008 { } /* end */ 2009}; 2010 2011static int alc_build_controls(struct hda_codec *codec) 2012{ 2013 struct alc_spec *spec = codec->spec; 2014 int err; 2015 int i; 2016 2017 for (i = 0; i < spec->num_mixers; i++) { 2018 err = snd_hda_add_new_ctls(codec, spec->mixers[i]); 2019 if (err < 0) 2020 return err; 2021 } 2022 if (spec->cap_mixer) { 2023 err = snd_hda_add_new_ctls(codec, spec->cap_mixer); 2024 if (err < 0) 2025 return err; 2026 } 2027 if (spec->multiout.dig_out_nid) { 2028 err = snd_hda_create_spdif_out_ctls(codec, 2029 spec->multiout.dig_out_nid); 2030 if (err < 0) 2031 return err; 2032 if (!spec->no_analog) { 2033 err = snd_hda_create_spdif_share_sw(codec, 2034 &spec->multiout); 2035 if (err < 0) 2036 return err; 2037 spec->multiout.share_spdif = 1; 2038 } 2039 } 2040 if (spec->dig_in_nid) { 2041 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid); 2042 if (err < 0) 2043 return err; 2044 } 2045 2046 /* create beep controls if needed */ 2047 if (spec->beep_amp) { 2048 struct snd_kcontrol_new *knew; 2049 for (knew = alc_beep_mixer; knew->name; knew++) { 2050 struct snd_kcontrol *kctl; 2051 kctl = snd_ctl_new1(knew, codec); 2052 if (!kctl) 2053 return -ENOMEM; 2054 kctl->private_value = spec->beep_amp; 2055 err = snd_hda_ctl_add(codec, kctl); 2056 if (err < 0) 2057 return err; 2058 } 2059 } 2060 2061 /* if we have no master control, let's create it */ 2062 if (!spec->no_analog && 2063 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) { 2064 unsigned int vmaster_tlv[4]; 2065 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid, 2066 HDA_OUTPUT, vmaster_tlv); 2067 err = snd_hda_add_vmaster(codec, "Master Playback Volume", 2068 vmaster_tlv, alc_slave_vols); 2069 if (err < 0) 2070 return err; 2071 } 2072 if (!spec->no_analog && 2073 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) { 2074 err = snd_hda_add_vmaster(codec, "Master Playback Switch", 2075 NULL, alc_slave_sws); 2076 if (err < 0) 2077 return err; 2078 } 2079 2080 alc_free_kctls(codec); /* no longer needed */ 2081 return 0; 2082} 2083 2084 2085/* 2086 * initialize the codec volumes, etc 2087 */ 2088 2089/* 2090 * generic initialization of ADC, input mixers and output mixers 2091 */ 2092static struct hda_verb alc880_volume_init_verbs[] = { 2093 /* 2094 * Unmute ADC0-2 and set the default input to mic-in 2095 */ 2096 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 2097 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2098 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 2099 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2100 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 2101 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2102 2103 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 2104 * mixer widget 2105 * Note: PASD motherboards uses the Line In 2 as the input for front 2106 * panel mic (mic 2) 2107 */ 2108 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 2109 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2110 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2111 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 2112 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 2113 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 2114 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 2115 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 2116 2117 /* 2118 * Set up output mixers (0x0c - 0x0f) 2119 */ 2120 /* set vol=0 to output mixers */ 2121 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2122 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2123 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2124 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2125 /* set up input amps for analog loopback */ 2126 /* Amp Indices: DAC = 0, mixer = 1 */ 2127 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2128 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2129 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2130 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2131 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2132 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2133 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2134 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2135 2136 { } 2137}; 2138 2139/* 2140 * 3-stack pin configuration: 2141 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b 2142 */ 2143static struct hda_verb alc880_pin_3stack_init_verbs[] = { 2144 /* 2145 * preset connection lists of input pins 2146 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround 2147 */ 2148 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 2149 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 2150 {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */ 2151 2152 /* 2153 * Set pin mode and muting 2154 */ 2155 /* set front pin widgets 0x14 for output */ 2156 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2157 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2158 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 2159 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2160 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2161 /* Mic2 (as headphone out) for HP output */ 2162 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2163 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2164 /* Line In pin widget for input */ 2165 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2166 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2167 /* Line2 (as front mic) pin widget for input and vref at 80% */ 2168 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2169 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2170 /* CD pin widget for input */ 2171 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2172 2173 { } 2174}; 2175 2176/* 2177 * 5-stack pin configuration: 2178 * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19, 2179 * line-in/side = 0x1a, f-mic = 0x1b 2180 */ 2181static struct hda_verb alc880_pin_5stack_init_verbs[] = { 2182 /* 2183 * preset connection lists of input pins 2184 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround 2185 */ 2186 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 2187 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */ 2188 2189 /* 2190 * Set pin mode and muting 2191 */ 2192 /* set pin widgets 0x14-0x17 for output */ 2193 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2194 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2195 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2196 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2197 /* unmute pins for output (no gain on this amp) */ 2198 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2199 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2200 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2201 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2202 2203 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 2204 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2205 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2206 /* Mic2 (as headphone out) for HP output */ 2207 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2208 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2209 /* Line In pin widget for input */ 2210 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2211 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2212 /* Line2 (as front mic) pin widget for input and vref at 80% */ 2213 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2214 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2215 /* CD pin widget for input */ 2216 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2217 2218 { } 2219}; 2220 2221/* 2222 * W810 pin configuration: 2223 * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b 2224 */ 2225static struct hda_verb alc880_pin_w810_init_verbs[] = { 2226 /* hphone/speaker input selector: front DAC */ 2227 {0x13, AC_VERB_SET_CONNECT_SEL, 0x0}, 2228 2229 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2230 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2231 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2232 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2233 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2234 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2235 2236 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2237 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2238 2239 { } 2240}; 2241 2242/* 2243 * Z71V pin configuration: 2244 * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?) 2245 */ 2246static struct hda_verb alc880_pin_z71v_init_verbs[] = { 2247 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2248 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2249 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2250 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2251 2252 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2253 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2254 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2255 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2256 2257 { } 2258}; 2259 2260/* 2261 * 6-stack pin configuration: 2262 * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18, 2263 * f-mic = 0x19, line = 0x1a, HP = 0x1b 2264 */ 2265static struct hda_verb alc880_pin_6stack_init_verbs[] = { 2266 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 2267 2268 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2269 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2270 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2271 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2272 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2273 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2274 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2275 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2276 2277 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2278 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2279 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2280 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2281 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2282 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2283 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2284 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2285 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2286 2287 { } 2288}; 2289 2290/* 2291 * Uniwill pin configuration: 2292 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19, 2293 * line = 0x1a 2294 */ 2295static struct hda_verb alc880_uniwill_init_verbs[] = { 2296 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 2297 2298 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2299 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2300 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2301 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2302 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2303 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2304 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2305 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2306 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 2307 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 2308 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 2309 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 2310 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 2311 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 2312 2313 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2314 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2315 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2316 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2317 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2318 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2319 /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */ 2320 /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */ 2321 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2322 2323 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 2324 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 2325 2326 { } 2327}; 2328 2329/* 2330* Uniwill P53 2331* HP = 0x14, InternalSpeaker = 0x15, mic = 0x19, 2332 */ 2333static struct hda_verb alc880_uniwill_p53_init_verbs[] = { 2334 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 2335 2336 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2337 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2338 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2339 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2340 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2341 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2342 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 2343 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 2344 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 2345 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 2346 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 2347 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 2348 2349 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2350 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2351 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2352 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2353 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2354 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2355 2356 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 2357 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT}, 2358 2359 { } 2360}; 2361 2362static struct hda_verb alc880_beep_init_verbs[] = { 2363 { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) }, 2364 { } 2365}; 2366 2367/* toggle speaker-output according to the hp-jack state */ 2368static void alc880_uniwill_hp_automute(struct hda_codec *codec) 2369{ 2370 unsigned int present; 2371 unsigned char bits; 2372 2373 present = snd_hda_codec_read(codec, 0x14, 0, 2374 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 2375 bits = present ? HDA_AMP_MUTE : 0; 2376 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 2377 HDA_AMP_MUTE, bits); 2378 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 2379 HDA_AMP_MUTE, bits); 2380} 2381 2382/* auto-toggle front mic */ 2383static void alc880_uniwill_mic_automute(struct hda_codec *codec) 2384{ 2385 unsigned int present; 2386 unsigned char bits; 2387 2388 present = snd_hda_codec_read(codec, 0x18, 0, 2389 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 2390 bits = present ? HDA_AMP_MUTE : 0; 2391 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits); 2392} 2393 2394static void alc880_uniwill_automute(struct hda_codec *codec) 2395{ 2396 alc880_uniwill_hp_automute(codec); 2397 alc880_uniwill_mic_automute(codec); 2398} 2399 2400static void alc880_uniwill_unsol_event(struct hda_codec *codec, 2401 unsigned int res) 2402{ 2403 /* Looks like the unsol event is incompatible with the standard 2404 * definition. 4bit tag is placed at 28 bit! 2405 */ 2406 switch (res >> 28) { 2407 case ALC880_HP_EVENT: 2408 alc880_uniwill_hp_automute(codec); 2409 break; 2410 case ALC880_MIC_EVENT: 2411 alc880_uniwill_mic_automute(codec); 2412 break; 2413 } 2414} 2415 2416static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec) 2417{ 2418 unsigned int present; 2419 unsigned char bits; 2420 2421 present = snd_hda_codec_read(codec, 0x14, 0, 2422 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 2423 bits = present ? HDA_AMP_MUTE : 0; 2424 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, HDA_AMP_MUTE, bits); 2425} 2426 2427static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec) 2428{ 2429 unsigned int present; 2430 2431 present = snd_hda_codec_read(codec, 0x21, 0, 2432 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0); 2433 present &= HDA_AMP_VOLMASK; 2434 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, 2435 HDA_AMP_VOLMASK, present); 2436 snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0, 2437 HDA_AMP_VOLMASK, present); 2438} 2439 2440static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec, 2441 unsigned int res) 2442{ 2443 /* Looks like the unsol event is incompatible with the standard 2444 * definition. 4bit tag is placed at 28 bit! 2445 */ 2446 if ((res >> 28) == ALC880_HP_EVENT) 2447 alc880_uniwill_p53_hp_automute(codec); 2448 if ((res >> 28) == ALC880_DCVOL_EVENT) 2449 alc880_uniwill_p53_dcvol_automute(codec); 2450} 2451 2452/* 2453 * F1734 pin configuration: 2454 * HP = 0x14, speaker-out = 0x15, mic = 0x18 2455 */ 2456static struct hda_verb alc880_pin_f1734_init_verbs[] = { 2457 {0x07, AC_VERB_SET_CONNECT_SEL, 0x01}, 2458 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, 2459 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, 2460 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, 2461 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, 2462 2463 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2464 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2465 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2466 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2467 2468 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2469 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2470 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50}, 2471 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2472 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2473 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2474 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2475 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2476 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2477 2478 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT}, 2479 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT}, 2480 2481 { } 2482}; 2483 2484/* 2485 * ASUS pin configuration: 2486 * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a 2487 */ 2488static struct hda_verb alc880_pin_asus_init_verbs[] = { 2489 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, 2490 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, 2491 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, 2492 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, 2493 2494 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2495 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2496 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2497 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2498 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2499 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2500 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2501 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2502 2503 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2504 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2505 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2506 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2507 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2508 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2509 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2510 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2511 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2512 2513 { } 2514}; 2515 2516/* Enable GPIO mask and set output */ 2517#define alc880_gpio1_init_verbs alc_gpio1_init_verbs 2518#define alc880_gpio2_init_verbs alc_gpio2_init_verbs 2519 2520/* Clevo m520g init */ 2521static struct hda_verb alc880_pin_clevo_init_verbs[] = { 2522 /* headphone output */ 2523 {0x11, AC_VERB_SET_CONNECT_SEL, 0x01}, 2524 /* line-out */ 2525 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2526 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2527 /* Line-in */ 2528 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2529 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2530 /* CD */ 2531 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2532 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2533 /* Mic1 (rear panel) */ 2534 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2535 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2536 /* Mic2 (front panel) */ 2537 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2538 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2539 /* headphone */ 2540 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2541 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2542 /* change to EAPD mode */ 2543 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 2544 {0x20, AC_VERB_SET_PROC_COEF, 0x3060}, 2545 2546 { } 2547}; 2548 2549static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = { 2550 /* change to EAPD mode */ 2551 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 2552 {0x20, AC_VERB_SET_PROC_COEF, 0x3060}, 2553 2554 /* Headphone output */ 2555 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2556 /* Front output*/ 2557 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2558 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 2559 2560 /* Line In pin widget for input */ 2561 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2562 /* CD pin widget for input */ 2563 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2564 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 2565 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2566 2567 /* change to EAPD mode */ 2568 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 2569 {0x20, AC_VERB_SET_PROC_COEF, 0x3070}, 2570 2571 { } 2572}; 2573 2574/* 2575 * LG m1 express dual 2576 * 2577 * Pin assignment: 2578 * Rear Line-In/Out (blue): 0x14 2579 * Build-in Mic-In: 0x15 2580 * Speaker-out: 0x17 2581 * HP-Out (green): 0x1b 2582 * Mic-In/Out (red): 0x19 2583 * SPDIF-Out: 0x1e 2584 */ 2585 2586/* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */ 2587static hda_nid_t alc880_lg_dac_nids[3] = { 2588 0x05, 0x02, 0x03 2589}; 2590 2591/* seems analog CD is not working */ 2592static struct hda_input_mux alc880_lg_capture_source = { 2593 .num_items = 3, 2594 .items = { 2595 { "Mic", 0x1 }, 2596 { "Line", 0x5 }, 2597 { "Internal Mic", 0x6 }, 2598 }, 2599}; 2600 2601/* 2,4,6 channel modes */ 2602static struct hda_verb alc880_lg_ch2_init[] = { 2603 /* set line-in and mic-in to input */ 2604 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 2605 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 2606 { } 2607}; 2608 2609static struct hda_verb alc880_lg_ch4_init[] = { 2610 /* set line-in to out and mic-in to input */ 2611 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, 2612 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 2613 { } 2614}; 2615 2616static struct hda_verb alc880_lg_ch6_init[] = { 2617 /* set line-in and mic-in to output */ 2618 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, 2619 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, 2620 { } 2621}; 2622 2623static struct hda_channel_mode alc880_lg_ch_modes[3] = { 2624 { 2, alc880_lg_ch2_init }, 2625 { 4, alc880_lg_ch4_init }, 2626 { 6, alc880_lg_ch6_init }, 2627}; 2628 2629static struct snd_kcontrol_new alc880_lg_mixer[] = { 2630 HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 2631 HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT), 2632 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2633 HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT), 2634 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT), 2635 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT), 2636 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT), 2637 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT), 2638 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 2639 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 2640 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT), 2641 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT), 2642 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT), 2643 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT), 2644 { 2645 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2646 .name = "Channel Mode", 2647 .info = alc_ch_mode_info, 2648 .get = alc_ch_mode_get, 2649 .put = alc_ch_mode_put, 2650 }, 2651 { } /* end */ 2652}; 2653 2654static struct hda_verb alc880_lg_init_verbs[] = { 2655 /* set capture source to mic-in */ 2656 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2657 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2658 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2659 /* mute all amp mixer inputs */ 2660 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)}, 2661 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 2662 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 2663 /* line-in to input */ 2664 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2665 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2666 /* built-in mic */ 2667 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2668 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2669 /* speaker-out */ 2670 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2671 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2672 /* mic-in to input */ 2673 {0x11, AC_VERB_SET_CONNECT_SEL, 0x01}, 2674 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2675 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2676 /* HP-out */ 2677 {0x13, AC_VERB_SET_CONNECT_SEL, 0x03}, 2678 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2679 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2680 /* jack sense */ 2681 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1}, 2682 { } 2683}; 2684 2685/* toggle speaker-output according to the hp-jack state */ 2686static void alc880_lg_automute(struct hda_codec *codec) 2687{ 2688 unsigned int present; 2689 unsigned char bits; 2690 2691 present = snd_hda_codec_read(codec, 0x1b, 0, 2692 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 2693 bits = present ? HDA_AMP_MUTE : 0; 2694 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0, 2695 HDA_AMP_MUTE, bits); 2696} 2697 2698static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res) 2699{ 2700 /* Looks like the unsol event is incompatible with the standard 2701 * definition. 4bit tag is placed at 28 bit! 2702 */ 2703 if ((res >> 28) == 0x01) 2704 alc880_lg_automute(codec); 2705} 2706 2707/* 2708 * LG LW20 2709 * 2710 * Pin assignment: 2711 * Speaker-out: 0x14 2712 * Mic-In: 0x18 2713 * Built-in Mic-In: 0x19 2714 * Line-In: 0x1b 2715 * HP-Out: 0x1a 2716 * SPDIF-Out: 0x1e 2717 */ 2718 2719static struct hda_input_mux alc880_lg_lw_capture_source = { 2720 .num_items = 3, 2721 .items = { 2722 { "Mic", 0x0 }, 2723 { "Internal Mic", 0x1 }, 2724 { "Line In", 0x2 }, 2725 }, 2726}; 2727 2728#define alc880_lg_lw_modes alc880_threestack_modes 2729 2730static struct snd_kcontrol_new alc880_lg_lw_mixer[] = { 2731 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2732 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 2733 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 2734 HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT), 2735 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 2736 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 2737 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 2738 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 2739 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 2740 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 2741 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 2742 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 2743 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 2744 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 2745 { 2746 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2747 .name = "Channel Mode", 2748 .info = alc_ch_mode_info, 2749 .get = alc_ch_mode_get, 2750 .put = alc_ch_mode_put, 2751 }, 2752 { } /* end */ 2753}; 2754 2755static struct hda_verb alc880_lg_lw_init_verbs[] = { 2756 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 2757 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 2758 {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */ 2759 2760 /* set capture source to mic-in */ 2761 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2762 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2763 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2764 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 2765 /* speaker-out */ 2766 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2767 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2768 /* HP-out */ 2769 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2770 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2771 /* mic-in to input */ 2772 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2773 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2774 /* built-in mic */ 2775 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2776 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2777 /* jack sense */ 2778 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1}, 2779 { } 2780}; 2781 2782/* toggle speaker-output according to the hp-jack state */ 2783static void alc880_lg_lw_automute(struct hda_codec *codec) 2784{ 2785 unsigned int present; 2786 unsigned char bits; 2787 2788 present = snd_hda_codec_read(codec, 0x1b, 0, 2789 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 2790 bits = present ? HDA_AMP_MUTE : 0; 2791 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 2792 HDA_AMP_MUTE, bits); 2793} 2794 2795static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res) 2796{ 2797 /* Looks like the unsol event is incompatible with the standard 2798 * definition. 4bit tag is placed at 28 bit! 2799 */ 2800 if ((res >> 28) == 0x01) 2801 alc880_lg_lw_automute(codec); 2802} 2803 2804static struct snd_kcontrol_new alc880_medion_rim_mixer[] = { 2805 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2806 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT), 2807 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 2808 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 2809 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 2810 HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT), 2811 { } /* end */ 2812}; 2813 2814static struct hda_input_mux alc880_medion_rim_capture_source = { 2815 .num_items = 2, 2816 .items = { 2817 { "Mic", 0x0 }, 2818 { "Internal Mic", 0x1 }, 2819 }, 2820}; 2821 2822static struct hda_verb alc880_medion_rim_init_verbs[] = { 2823 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 2824 2825 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2826 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2827 2828 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 2829 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2830 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2831 /* Mic2 (as headphone out) for HP output */ 2832 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2833 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2834 /* Internal Speaker */ 2835 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2836 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2837 2838 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 2839 {0x20, AC_VERB_SET_PROC_COEF, 0x3060}, 2840 2841 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 2842 { } 2843}; 2844 2845/* toggle speaker-output according to the hp-jack state */ 2846static void alc880_medion_rim_automute(struct hda_codec *codec) 2847{ 2848 unsigned int present; 2849 unsigned char bits; 2850 2851 present = snd_hda_codec_read(codec, 0x14, 0, 2852 AC_VERB_GET_PIN_SENSE, 0) 2853 & AC_PINSENSE_PRESENCE; 2854 bits = present ? HDA_AMP_MUTE : 0; 2855 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 2856 HDA_AMP_MUTE, bits); 2857 if (present) 2858 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0); 2859 else 2860 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2); 2861} 2862 2863static void alc880_medion_rim_unsol_event(struct hda_codec *codec, 2864 unsigned int res) 2865{ 2866 /* Looks like the unsol event is incompatible with the standard 2867 * definition. 4bit tag is placed at 28 bit! 2868 */ 2869 if ((res >> 28) == ALC880_HP_EVENT) 2870 alc880_medion_rim_automute(codec); 2871} 2872 2873#ifdef CONFIG_SND_HDA_POWER_SAVE 2874static struct hda_amp_list alc880_loopbacks[] = { 2875 { 0x0b, HDA_INPUT, 0 }, 2876 { 0x0b, HDA_INPUT, 1 }, 2877 { 0x0b, HDA_INPUT, 2 }, 2878 { 0x0b, HDA_INPUT, 3 }, 2879 { 0x0b, HDA_INPUT, 4 }, 2880 { } /* end */ 2881}; 2882 2883static struct hda_amp_list alc880_lg_loopbacks[] = { 2884 { 0x0b, HDA_INPUT, 1 }, 2885 { 0x0b, HDA_INPUT, 6 }, 2886 { 0x0b, HDA_INPUT, 7 }, 2887 { } /* end */ 2888}; 2889#endif 2890 2891/* 2892 * Common callbacks 2893 */ 2894 2895static int alc_init(struct hda_codec *codec) 2896{ 2897 struct alc_spec *spec = codec->spec; 2898 unsigned int i; 2899 2900 alc_fix_pll(codec); 2901 if (codec->vendor_id == 0x10ec0888) 2902 alc888_coef_init(codec); 2903 2904 for (i = 0; i < spec->num_init_verbs; i++) 2905 snd_hda_sequence_write(codec, spec->init_verbs[i]); 2906 2907 if (spec->init_hook) 2908 spec->init_hook(codec); 2909 2910 return 0; 2911} 2912 2913static void alc_unsol_event(struct hda_codec *codec, unsigned int res) 2914{ 2915 struct alc_spec *spec = codec->spec; 2916 2917 if (spec->unsol_event) 2918 spec->unsol_event(codec, res); 2919} 2920 2921#ifdef CONFIG_SND_HDA_POWER_SAVE 2922static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid) 2923{ 2924 struct alc_spec *spec = codec->spec; 2925 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid); 2926} 2927#endif 2928 2929/* 2930 * Analog playback callbacks 2931 */ 2932static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo, 2933 struct hda_codec *codec, 2934 struct snd_pcm_substream *substream) 2935{ 2936 struct alc_spec *spec = codec->spec; 2937 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, 2938 hinfo); 2939} 2940 2941static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 2942 struct hda_codec *codec, 2943 unsigned int stream_tag, 2944 unsigned int format, 2945 struct snd_pcm_substream *substream) 2946{ 2947 struct alc_spec *spec = codec->spec; 2948 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, 2949 stream_tag, format, substream); 2950} 2951 2952static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 2953 struct hda_codec *codec, 2954 struct snd_pcm_substream *substream) 2955{ 2956 struct alc_spec *spec = codec->spec; 2957 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); 2958} 2959 2960/* 2961 * Digital out 2962 */ 2963static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, 2964 struct hda_codec *codec, 2965 struct snd_pcm_substream *substream) 2966{ 2967 struct alc_spec *spec = codec->spec; 2968 return snd_hda_multi_out_dig_open(codec, &spec->multiout); 2969} 2970 2971static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 2972 struct hda_codec *codec, 2973 unsigned int stream_tag, 2974 unsigned int format, 2975 struct snd_pcm_substream *substream) 2976{ 2977 struct alc_spec *spec = codec->spec; 2978 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, 2979 stream_tag, format, substream); 2980} 2981 2982static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, 2983 struct hda_codec *codec, 2984 struct snd_pcm_substream *substream) 2985{ 2986 struct alc_spec *spec = codec->spec; 2987 return snd_hda_multi_out_dig_close(codec, &spec->multiout); 2988} 2989 2990/* 2991 * Analog capture 2992 */ 2993static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 2994 struct hda_codec *codec, 2995 unsigned int stream_tag, 2996 unsigned int format, 2997 struct snd_pcm_substream *substream) 2998{ 2999 struct alc_spec *spec = codec->spec; 3000 3001 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1], 3002 stream_tag, 0, format); 3003 return 0; 3004} 3005 3006static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 3007 struct hda_codec *codec, 3008 struct snd_pcm_substream *substream) 3009{ 3010 struct alc_spec *spec = codec->spec; 3011 3012 snd_hda_codec_cleanup_stream(codec, 3013 spec->adc_nids[substream->number + 1]); 3014 return 0; 3015} 3016 3017 3018/* 3019 */ 3020static struct hda_pcm_stream alc880_pcm_analog_playback = { 3021 .substreams = 1, 3022 .channels_min = 2, 3023 .channels_max = 8, 3024 /* NID is set in alc_build_pcms */ 3025 .ops = { 3026 .open = alc880_playback_pcm_open, 3027 .prepare = alc880_playback_pcm_prepare, 3028 .cleanup = alc880_playback_pcm_cleanup 3029 }, 3030}; 3031 3032static struct hda_pcm_stream alc880_pcm_analog_capture = { 3033 .substreams = 1, 3034 .channels_min = 2, 3035 .channels_max = 2, 3036 /* NID is set in alc_build_pcms */ 3037}; 3038 3039static struct hda_pcm_stream alc880_pcm_analog_alt_playback = { 3040 .substreams = 1, 3041 .channels_min = 2, 3042 .channels_max = 2, 3043 /* NID is set in alc_build_pcms */ 3044}; 3045 3046static struct hda_pcm_stream alc880_pcm_analog_alt_capture = { 3047 .substreams = 2, /* can be overridden */ 3048 .channels_min = 2, 3049 .channels_max = 2, 3050 /* NID is set in alc_build_pcms */ 3051 .ops = { 3052 .prepare = alc880_alt_capture_pcm_prepare, 3053 .cleanup = alc880_alt_capture_pcm_cleanup 3054 }, 3055}; 3056 3057static struct hda_pcm_stream alc880_pcm_digital_playback = { 3058 .substreams = 1, 3059 .channels_min = 2, 3060 .channels_max = 2, 3061 /* NID is set in alc_build_pcms */ 3062 .ops = { 3063 .open = alc880_dig_playback_pcm_open, 3064 .close = alc880_dig_playback_pcm_close, 3065 .prepare = alc880_dig_playback_pcm_prepare 3066 }, 3067}; 3068 3069static struct hda_pcm_stream alc880_pcm_digital_capture = { 3070 .substreams = 1, 3071 .channels_min = 2, 3072 .channels_max = 2, 3073 /* NID is set in alc_build_pcms */ 3074}; 3075 3076/* Used by alc_build_pcms to flag that a PCM has no playback stream */ 3077static struct hda_pcm_stream alc_pcm_null_stream = { 3078 .substreams = 0, 3079 .channels_min = 0, 3080 .channels_max = 0, 3081}; 3082 3083static int alc_build_pcms(struct hda_codec *codec) 3084{ 3085 struct alc_spec *spec = codec->spec; 3086 struct hda_pcm *info = spec->pcm_rec; 3087 int i; 3088 3089 codec->num_pcms = 1; 3090 codec->pcm_info = info; 3091 3092 if (spec->no_analog) 3093 goto skip_analog; 3094 3095 info->name = spec->stream_name_analog; 3096 if (spec->stream_analog_playback) { 3097 if (snd_BUG_ON(!spec->multiout.dac_nids)) 3098 return -EINVAL; 3099 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback); 3100 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0]; 3101 } 3102 if (spec->stream_analog_capture) { 3103 if (snd_BUG_ON(!spec->adc_nids)) 3104 return -EINVAL; 3105 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture); 3106 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; 3107 } 3108 3109 if (spec->channel_mode) { 3110 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0; 3111 for (i = 0; i < spec->num_channel_mode; i++) { 3112 if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) { 3113 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels; 3114 } 3115 } 3116 } 3117 3118 skip_analog: 3119 /* SPDIF for stream index #1 */ 3120 if (spec->multiout.dig_out_nid || spec->dig_in_nid) { 3121 codec->num_pcms = 2; 3122 codec->slave_dig_outs = spec->multiout.slave_dig_outs; 3123 info = spec->pcm_rec + 1; 3124 info->name = spec->stream_name_digital; 3125 if (spec->dig_out_type) 3126 info->pcm_type = spec->dig_out_type; 3127 else 3128 info->pcm_type = HDA_PCM_TYPE_SPDIF; 3129 if (spec->multiout.dig_out_nid && 3130 spec->stream_digital_playback) { 3131 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback); 3132 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid; 3133 } 3134 if (spec->dig_in_nid && 3135 spec->stream_digital_capture) { 3136 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture); 3137 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid; 3138 } 3139 /* FIXME: do we need this for all Realtek codec models? */ 3140 codec->spdif_status_reset = 1; 3141 } 3142 3143 if (spec->no_analog) 3144 return 0; 3145 3146 /* If the use of more than one ADC is requested for the current 3147 * model, configure a second analog capture-only PCM. 3148 */ 3149 /* Additional Analaog capture for index #2 */ 3150 if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) || 3151 (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) { 3152 codec->num_pcms = 3; 3153 info = spec->pcm_rec + 2; 3154 info->name = spec->stream_name_analog; 3155 if (spec->alt_dac_nid) { 3156 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 3157 *spec->stream_analog_alt_playback; 3158 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 3159 spec->alt_dac_nid; 3160 } else { 3161 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 3162 alc_pcm_null_stream; 3163 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0; 3164 } 3165 if (spec->num_adc_nids > 1) { 3166 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 3167 *spec->stream_analog_alt_capture; 3168 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 3169 spec->adc_nids[1]; 3170 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 3171 spec->num_adc_nids - 1; 3172 } else { 3173 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 3174 alc_pcm_null_stream; 3175 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0; 3176 } 3177 } 3178 3179 return 0; 3180} 3181 3182static void alc_free_kctls(struct hda_codec *codec) 3183{ 3184 struct alc_spec *spec = codec->spec; 3185 3186 if (spec->kctls.list) { 3187 struct snd_kcontrol_new *kctl = spec->kctls.list; 3188 int i; 3189 for (i = 0; i < spec->kctls.used; i++) 3190 kfree(kctl[i].name); 3191 } 3192 snd_array_free(&spec->kctls); 3193} 3194 3195static void alc_free(struct hda_codec *codec) 3196{ 3197 struct alc_spec *spec = codec->spec; 3198 3199 if (!spec) 3200 return; 3201 3202 alc_free_kctls(codec); 3203 kfree(spec); 3204 snd_hda_detach_beep_device(codec); 3205} 3206 3207#ifdef SND_HDA_NEEDS_RESUME 3208static void store_pin_configs(struct hda_codec *codec) 3209{ 3210 struct alc_spec *spec = codec->spec; 3211 hda_nid_t nid, end_nid; 3212 3213 end_nid = codec->start_nid + codec->num_nodes; 3214 for (nid = codec->start_nid; nid < end_nid; nid++) { 3215 unsigned int wid_caps = get_wcaps(codec, nid); 3216 unsigned int wid_type = 3217 (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 3218 if (wid_type != AC_WID_PIN) 3219 continue; 3220 if (spec->num_pins >= ARRAY_SIZE(spec->pin_nids)) 3221 break; 3222 spec->pin_nids[spec->num_pins] = nid; 3223 spec->pin_cfgs[spec->num_pins] = 3224 snd_hda_codec_read(codec, nid, 0, 3225 AC_VERB_GET_CONFIG_DEFAULT, 0); 3226 spec->num_pins++; 3227 } 3228} 3229 3230static void resume_pin_configs(struct hda_codec *codec) 3231{ 3232 struct alc_spec *spec = codec->spec; 3233 int i; 3234 3235 for (i = 0; i < spec->num_pins; i++) { 3236 hda_nid_t pin_nid = spec->pin_nids[i]; 3237 unsigned int pin_config = spec->pin_cfgs[i]; 3238 snd_hda_codec_write(codec, pin_nid, 0, 3239 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0, 3240 pin_config & 0x000000ff); 3241 snd_hda_codec_write(codec, pin_nid, 0, 3242 AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 3243 (pin_config & 0x0000ff00) >> 8); 3244 snd_hda_codec_write(codec, pin_nid, 0, 3245 AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 3246 (pin_config & 0x00ff0000) >> 16); 3247 snd_hda_codec_write(codec, pin_nid, 0, 3248 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 3249 pin_config >> 24); 3250 } 3251} 3252 3253static int alc_resume(struct hda_codec *codec) 3254{ 3255 resume_pin_configs(codec); 3256 codec->patch_ops.init(codec); 3257 snd_hda_codec_resume_amp(codec); 3258 snd_hda_codec_resume_cache(codec); 3259 return 0; 3260} 3261#else 3262#define store_pin_configs(codec) 3263#endif 3264 3265/* 3266 */ 3267static struct hda_codec_ops alc_patch_ops = { 3268 .build_controls = alc_build_controls, 3269 .build_pcms = alc_build_pcms, 3270 .init = alc_init, 3271 .free = alc_free, 3272 .unsol_event = alc_unsol_event, 3273#ifdef SND_HDA_NEEDS_RESUME 3274 .resume = alc_resume, 3275#endif 3276#ifdef CONFIG_SND_HDA_POWER_SAVE 3277 .check_power_status = alc_check_power_status, 3278#endif 3279}; 3280 3281 3282/* 3283 * Test configuration for debugging 3284 * 3285 * Almost all inputs/outputs are enabled. I/O pins can be configured via 3286 * enum controls. 3287 */ 3288#ifdef CONFIG_SND_DEBUG 3289static hda_nid_t alc880_test_dac_nids[4] = { 3290 0x02, 0x03, 0x04, 0x05 3291}; 3292 3293static struct hda_input_mux alc880_test_capture_source = { 3294 .num_items = 7, 3295 .items = { 3296 { "In-1", 0x0 }, 3297 { "In-2", 0x1 }, 3298 { "In-3", 0x2 }, 3299 { "In-4", 0x3 }, 3300 { "CD", 0x4 }, 3301 { "Front", 0x5 }, 3302 { "Surround", 0x6 }, 3303 }, 3304}; 3305 3306static struct hda_channel_mode alc880_test_modes[4] = { 3307 { 2, NULL }, 3308 { 4, NULL }, 3309 { 6, NULL }, 3310 { 8, NULL }, 3311}; 3312 3313static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol, 3314 struct snd_ctl_elem_info *uinfo) 3315{ 3316 static char *texts[] = { 3317 "N/A", "Line Out", "HP Out", 3318 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%" 3319 }; 3320 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 3321 uinfo->count = 1; 3322 uinfo->value.enumerated.items = 8; 3323 if (uinfo->value.enumerated.item >= 8) 3324 uinfo->value.enumerated.item = 7; 3325 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 3326 return 0; 3327} 3328 3329static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol, 3330 struct snd_ctl_elem_value *ucontrol) 3331{ 3332 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3333 hda_nid_t nid = (hda_nid_t)kcontrol->private_value; 3334 unsigned int pin_ctl, item = 0; 3335 3336 pin_ctl = snd_hda_codec_read(codec, nid, 0, 3337 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 3338 if (pin_ctl & AC_PINCTL_OUT_EN) { 3339 if (pin_ctl & AC_PINCTL_HP_EN) 3340 item = 2; 3341 else 3342 item = 1; 3343 } else if (pin_ctl & AC_PINCTL_IN_EN) { 3344 switch (pin_ctl & AC_PINCTL_VREFEN) { 3345 case AC_PINCTL_VREF_HIZ: item = 3; break; 3346 case AC_PINCTL_VREF_50: item = 4; break; 3347 case AC_PINCTL_VREF_GRD: item = 5; break; 3348 case AC_PINCTL_VREF_80: item = 6; break; 3349 case AC_PINCTL_VREF_100: item = 7; break; 3350 } 3351 } 3352 ucontrol->value.enumerated.item[0] = item; 3353 return 0; 3354} 3355 3356static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol, 3357 struct snd_ctl_elem_value *ucontrol) 3358{ 3359 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3360 hda_nid_t nid = (hda_nid_t)kcontrol->private_value; 3361 static unsigned int ctls[] = { 3362 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN, 3363 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ, 3364 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50, 3365 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD, 3366 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80, 3367 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100, 3368 }; 3369 unsigned int old_ctl, new_ctl; 3370 3371 old_ctl = snd_hda_codec_read(codec, nid, 0, 3372 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 3373 new_ctl = ctls[ucontrol->value.enumerated.item[0]]; 3374 if (old_ctl != new_ctl) { 3375 int val; 3376 snd_hda_codec_write_cache(codec, nid, 0, 3377 AC_VERB_SET_PIN_WIDGET_CONTROL, 3378 new_ctl); 3379 val = ucontrol->value.enumerated.item[0] >= 3 ? 3380 HDA_AMP_MUTE : 0; 3381 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 3382 HDA_AMP_MUTE, val); 3383 return 1; 3384 } 3385 return 0; 3386} 3387 3388static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol, 3389 struct snd_ctl_elem_info *uinfo) 3390{ 3391 static char *texts[] = { 3392 "Front", "Surround", "CLFE", "Side" 3393 }; 3394 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 3395 uinfo->count = 1; 3396 uinfo->value.enumerated.items = 4; 3397 if (uinfo->value.enumerated.item >= 4) 3398 uinfo->value.enumerated.item = 3; 3399 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 3400 return 0; 3401} 3402 3403static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol, 3404 struct snd_ctl_elem_value *ucontrol) 3405{ 3406 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3407 hda_nid_t nid = (hda_nid_t)kcontrol->private_value; 3408 unsigned int sel; 3409 3410 sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0); 3411 ucontrol->value.enumerated.item[0] = sel & 3; 3412 return 0; 3413} 3414 3415static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol, 3416 struct snd_ctl_elem_value *ucontrol) 3417{ 3418 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3419 hda_nid_t nid = (hda_nid_t)kcontrol->private_value; 3420 unsigned int sel; 3421 3422 sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3; 3423 if (ucontrol->value.enumerated.item[0] != sel) { 3424 sel = ucontrol->value.enumerated.item[0] & 3; 3425 snd_hda_codec_write_cache(codec, nid, 0, 3426 AC_VERB_SET_CONNECT_SEL, sel); 3427 return 1; 3428 } 3429 return 0; 3430} 3431 3432#define PIN_CTL_TEST(xname,nid) { \ 3433 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 3434 .name = xname, \ 3435 .info = alc_test_pin_ctl_info, \ 3436 .get = alc_test_pin_ctl_get, \ 3437 .put = alc_test_pin_ctl_put, \ 3438 .private_value = nid \ 3439 } 3440 3441#define PIN_SRC_TEST(xname,nid) { \ 3442 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 3443 .name = xname, \ 3444 .info = alc_test_pin_src_info, \ 3445 .get = alc_test_pin_src_get, \ 3446 .put = alc_test_pin_src_put, \ 3447 .private_value = nid \ 3448 } 3449 3450static struct snd_kcontrol_new alc880_test_mixer[] = { 3451 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 3452 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 3453 HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT), 3454 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 3455 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 3456 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 3457 HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT), 3458 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 3459 PIN_CTL_TEST("Front Pin Mode", 0x14), 3460 PIN_CTL_TEST("Surround Pin Mode", 0x15), 3461 PIN_CTL_TEST("CLFE Pin Mode", 0x16), 3462 PIN_CTL_TEST("Side Pin Mode", 0x17), 3463 PIN_CTL_TEST("In-1 Pin Mode", 0x18), 3464 PIN_CTL_TEST("In-2 Pin Mode", 0x19), 3465 PIN_CTL_TEST("In-3 Pin Mode", 0x1a), 3466 PIN_CTL_TEST("In-4 Pin Mode", 0x1b), 3467 PIN_SRC_TEST("In-1 Pin Source", 0x18), 3468 PIN_SRC_TEST("In-2 Pin Source", 0x19), 3469 PIN_SRC_TEST("In-3 Pin Source", 0x1a), 3470 PIN_SRC_TEST("In-4 Pin Source", 0x1b), 3471 HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT), 3472 HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT), 3473 HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT), 3474 HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT), 3475 HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT), 3476 HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT), 3477 HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT), 3478 HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT), 3479 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT), 3480 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT), 3481 { 3482 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3483 .name = "Channel Mode", 3484 .info = alc_ch_mode_info, 3485 .get = alc_ch_mode_get, 3486 .put = alc_ch_mode_put, 3487 }, 3488 { } /* end */ 3489}; 3490 3491static struct hda_verb alc880_test_init_verbs[] = { 3492 /* Unmute inputs of 0x0c - 0x0f */ 3493 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3494 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3495 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3496 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3497 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3498 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3499 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3500 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3501 /* Vol output for 0x0c-0x0f */ 3502 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 3503 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 3504 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 3505 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 3506 /* Set output pins 0x14-0x17 */ 3507 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3508 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3509 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3510 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3511 /* Unmute output pins 0x14-0x17 */ 3512 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3513 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3514 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3515 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3516 /* Set input pins 0x18-0x1c */ 3517 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3518 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3519 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3520 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3521 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3522 /* Mute input pins 0x18-0x1b */ 3523 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3524 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3525 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3526 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3527 /* ADC set up */ 3528 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3529 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 3530 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3531 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 3532 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3533 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 3534 /* Analog input/passthru */ 3535 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3536 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 3537 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 3538 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 3539 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 3540 { } 3541}; 3542#endif 3543 3544/* 3545 */ 3546 3547static const char *alc880_models[ALC880_MODEL_LAST] = { 3548 [ALC880_3ST] = "3stack", 3549 [ALC880_TCL_S700] = "tcl", 3550 [ALC880_3ST_DIG] = "3stack-digout", 3551 [ALC880_CLEVO] = "clevo", 3552 [ALC880_5ST] = "5stack", 3553 [ALC880_5ST_DIG] = "5stack-digout", 3554 [ALC880_W810] = "w810", 3555 [ALC880_Z71V] = "z71v", 3556 [ALC880_6ST] = "6stack", 3557 [ALC880_6ST_DIG] = "6stack-digout", 3558 [ALC880_ASUS] = "asus", 3559 [ALC880_ASUS_W1V] = "asus-w1v", 3560 [ALC880_ASUS_DIG] = "asus-dig", 3561 [ALC880_ASUS_DIG2] = "asus-dig2", 3562 [ALC880_UNIWILL_DIG] = "uniwill", 3563 [ALC880_UNIWILL_P53] = "uniwill-p53", 3564 [ALC880_FUJITSU] = "fujitsu", 3565 [ALC880_F1734] = "F1734", 3566 [ALC880_LG] = "lg", 3567 [ALC880_LG_LW] = "lg-lw", 3568 [ALC880_MEDION_RIM] = "medion", 3569#ifdef CONFIG_SND_DEBUG 3570 [ALC880_TEST] = "test", 3571#endif 3572 [ALC880_AUTO] = "auto", 3573}; 3574 3575static struct snd_pci_quirk alc880_cfg_tbl[] = { 3576 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810), 3577 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG), 3578 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST), 3579 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG), 3580 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG), 3581 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG), 3582 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG), 3583 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG), 3584 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST), 3585 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG), 3586 SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST), 3587 SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V), 3588 SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG), 3589 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG), 3590 SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG), 3591 SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG), 3592 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG), 3593 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V), 3594 /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */ 3595 SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG), 3596 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG), 3597 SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG), 3598 SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG), 3599 SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST), 3600 SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST), 3601 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */ 3602 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST), 3603 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST), 3604 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST), 3605 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST), 3606 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST), 3607 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG), 3608 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG), 3609 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG), 3610 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG), 3611 SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO), 3612 SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO), 3613 SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2), 3614 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG), 3615 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG), 3616 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734), 3617 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL), 3618 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53), 3619 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810), 3620 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM), 3621 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG), 3622 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG), 3623 SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734), 3624 SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU), 3625 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL), 3626 SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU), 3627 SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW), 3628 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG), 3629 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG), 3630 SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW), 3631 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700), 3632 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */ 3633 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG), 3634 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG), 3635 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG), 3636 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG), 3637 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG), 3638 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG), 3639 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG), 3640 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG), 3641 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG), 3642 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG), 3643 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG), 3644 /* default Intel */ 3645 SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST), 3646 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG), 3647 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG), 3648 {} 3649}; 3650 3651/* 3652 * ALC880 codec presets 3653 */ 3654static struct alc_config_preset alc880_presets[] = { 3655 [ALC880_3ST] = { 3656 .mixers = { alc880_three_stack_mixer }, 3657 .init_verbs = { alc880_volume_init_verbs, 3658 alc880_pin_3stack_init_verbs }, 3659 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3660 .dac_nids = alc880_dac_nids, 3661 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 3662 .channel_mode = alc880_threestack_modes, 3663 .need_dac_fix = 1, 3664 .input_mux = &alc880_capture_source, 3665 }, 3666 [ALC880_3ST_DIG] = { 3667 .mixers = { alc880_three_stack_mixer }, 3668 .init_verbs = { alc880_volume_init_verbs, 3669 alc880_pin_3stack_init_verbs }, 3670 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3671 .dac_nids = alc880_dac_nids, 3672 .dig_out_nid = ALC880_DIGOUT_NID, 3673 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 3674 .channel_mode = alc880_threestack_modes, 3675 .need_dac_fix = 1, 3676 .input_mux = &alc880_capture_source, 3677 }, 3678 [ALC880_TCL_S700] = { 3679 .mixers = { alc880_tcl_s700_mixer }, 3680 .init_verbs = { alc880_volume_init_verbs, 3681 alc880_pin_tcl_S700_init_verbs, 3682 alc880_gpio2_init_verbs }, 3683 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3684 .dac_nids = alc880_dac_nids, 3685 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */ 3686 .num_adc_nids = 1, /* single ADC */ 3687 .hp_nid = 0x03, 3688 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 3689 .channel_mode = alc880_2_jack_modes, 3690 .input_mux = &alc880_capture_source, 3691 }, 3692 [ALC880_5ST] = { 3693 .mixers = { alc880_three_stack_mixer, 3694 alc880_five_stack_mixer}, 3695 .init_verbs = { alc880_volume_init_verbs, 3696 alc880_pin_5stack_init_verbs }, 3697 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3698 .dac_nids = alc880_dac_nids, 3699 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes), 3700 .channel_mode = alc880_fivestack_modes, 3701 .input_mux = &alc880_capture_source, 3702 }, 3703 [ALC880_5ST_DIG] = { 3704 .mixers = { alc880_three_stack_mixer, 3705 alc880_five_stack_mixer }, 3706 .init_verbs = { alc880_volume_init_verbs, 3707 alc880_pin_5stack_init_verbs }, 3708 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3709 .dac_nids = alc880_dac_nids, 3710 .dig_out_nid = ALC880_DIGOUT_NID, 3711 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes), 3712 .channel_mode = alc880_fivestack_modes, 3713 .input_mux = &alc880_capture_source, 3714 }, 3715 [ALC880_6ST] = { 3716 .mixers = { alc880_six_stack_mixer }, 3717 .init_verbs = { alc880_volume_init_verbs, 3718 alc880_pin_6stack_init_verbs }, 3719 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids), 3720 .dac_nids = alc880_6st_dac_nids, 3721 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes), 3722 .channel_mode = alc880_sixstack_modes, 3723 .input_mux = &alc880_6stack_capture_source, 3724 }, 3725 [ALC880_6ST_DIG] = { 3726 .mixers = { alc880_six_stack_mixer }, 3727 .init_verbs = { alc880_volume_init_verbs, 3728 alc880_pin_6stack_init_verbs }, 3729 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids), 3730 .dac_nids = alc880_6st_dac_nids, 3731 .dig_out_nid = ALC880_DIGOUT_NID, 3732 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes), 3733 .channel_mode = alc880_sixstack_modes, 3734 .input_mux = &alc880_6stack_capture_source, 3735 }, 3736 [ALC880_W810] = { 3737 .mixers = { alc880_w810_base_mixer }, 3738 .init_verbs = { alc880_volume_init_verbs, 3739 alc880_pin_w810_init_verbs, 3740 alc880_gpio2_init_verbs }, 3741 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids), 3742 .dac_nids = alc880_w810_dac_nids, 3743 .dig_out_nid = ALC880_DIGOUT_NID, 3744 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes), 3745 .channel_mode = alc880_w810_modes, 3746 .input_mux = &alc880_capture_source, 3747 }, 3748 [ALC880_Z71V] = { 3749 .mixers = { alc880_z71v_mixer }, 3750 .init_verbs = { alc880_volume_init_verbs, 3751 alc880_pin_z71v_init_verbs }, 3752 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids), 3753 .dac_nids = alc880_z71v_dac_nids, 3754 .dig_out_nid = ALC880_DIGOUT_NID, 3755 .hp_nid = 0x03, 3756 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 3757 .channel_mode = alc880_2_jack_modes, 3758 .input_mux = &alc880_capture_source, 3759 }, 3760 [ALC880_F1734] = { 3761 .mixers = { alc880_f1734_mixer }, 3762 .init_verbs = { alc880_volume_init_verbs, 3763 alc880_pin_f1734_init_verbs }, 3764 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids), 3765 .dac_nids = alc880_f1734_dac_nids, 3766 .hp_nid = 0x02, 3767 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 3768 .channel_mode = alc880_2_jack_modes, 3769 .input_mux = &alc880_f1734_capture_source, 3770 .unsol_event = alc880_uniwill_p53_unsol_event, 3771 .init_hook = alc880_uniwill_p53_hp_automute, 3772 }, 3773 [ALC880_ASUS] = { 3774 .mixers = { alc880_asus_mixer }, 3775 .init_verbs = { alc880_volume_init_verbs, 3776 alc880_pin_asus_init_verbs, 3777 alc880_gpio1_init_verbs }, 3778 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3779 .dac_nids = alc880_asus_dac_nids, 3780 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 3781 .channel_mode = alc880_asus_modes, 3782 .need_dac_fix = 1, 3783 .input_mux = &alc880_capture_source, 3784 }, 3785 [ALC880_ASUS_DIG] = { 3786 .mixers = { alc880_asus_mixer }, 3787 .init_verbs = { alc880_volume_init_verbs, 3788 alc880_pin_asus_init_verbs, 3789 alc880_gpio1_init_verbs }, 3790 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3791 .dac_nids = alc880_asus_dac_nids, 3792 .dig_out_nid = ALC880_DIGOUT_NID, 3793 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 3794 .channel_mode = alc880_asus_modes, 3795 .need_dac_fix = 1, 3796 .input_mux = &alc880_capture_source, 3797 }, 3798 [ALC880_ASUS_DIG2] = { 3799 .mixers = { alc880_asus_mixer }, 3800 .init_verbs = { alc880_volume_init_verbs, 3801 alc880_pin_asus_init_verbs, 3802 alc880_gpio2_init_verbs }, /* use GPIO2 */ 3803 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3804 .dac_nids = alc880_asus_dac_nids, 3805 .dig_out_nid = ALC880_DIGOUT_NID, 3806 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 3807 .channel_mode = alc880_asus_modes, 3808 .need_dac_fix = 1, 3809 .input_mux = &alc880_capture_source, 3810 }, 3811 [ALC880_ASUS_W1V] = { 3812 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer }, 3813 .init_verbs = { alc880_volume_init_verbs, 3814 alc880_pin_asus_init_verbs, 3815 alc880_gpio1_init_verbs }, 3816 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3817 .dac_nids = alc880_asus_dac_nids, 3818 .dig_out_nid = ALC880_DIGOUT_NID, 3819 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 3820 .channel_mode = alc880_asus_modes, 3821 .need_dac_fix = 1, 3822 .input_mux = &alc880_capture_source, 3823 }, 3824 [ALC880_UNIWILL_DIG] = { 3825 .mixers = { alc880_asus_mixer }, 3826 .init_verbs = { alc880_volume_init_verbs, 3827 alc880_pin_asus_init_verbs }, 3828 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3829 .dac_nids = alc880_asus_dac_nids, 3830 .dig_out_nid = ALC880_DIGOUT_NID, 3831 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 3832 .channel_mode = alc880_asus_modes, 3833 .need_dac_fix = 1, 3834 .input_mux = &alc880_capture_source, 3835 }, 3836 [ALC880_UNIWILL] = { 3837 .mixers = { alc880_uniwill_mixer }, 3838 .init_verbs = { alc880_volume_init_verbs, 3839 alc880_uniwill_init_verbs }, 3840 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3841 .dac_nids = alc880_asus_dac_nids, 3842 .dig_out_nid = ALC880_DIGOUT_NID, 3843 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 3844 .channel_mode = alc880_threestack_modes, 3845 .need_dac_fix = 1, 3846 .input_mux = &alc880_capture_source, 3847 .unsol_event = alc880_uniwill_unsol_event, 3848 .init_hook = alc880_uniwill_automute, 3849 }, 3850 [ALC880_UNIWILL_P53] = { 3851 .mixers = { alc880_uniwill_p53_mixer }, 3852 .init_verbs = { alc880_volume_init_verbs, 3853 alc880_uniwill_p53_init_verbs }, 3854 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3855 .dac_nids = alc880_asus_dac_nids, 3856 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes), 3857 .channel_mode = alc880_threestack_modes, 3858 .input_mux = &alc880_capture_source, 3859 .unsol_event = alc880_uniwill_p53_unsol_event, 3860 .init_hook = alc880_uniwill_p53_hp_automute, 3861 }, 3862 [ALC880_FUJITSU] = { 3863 .mixers = { alc880_fujitsu_mixer }, 3864 .init_verbs = { alc880_volume_init_verbs, 3865 alc880_uniwill_p53_init_verbs, 3866 alc880_beep_init_verbs }, 3867 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3868 .dac_nids = alc880_dac_nids, 3869 .dig_out_nid = ALC880_DIGOUT_NID, 3870 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 3871 .channel_mode = alc880_2_jack_modes, 3872 .input_mux = &alc880_capture_source, 3873 .unsol_event = alc880_uniwill_p53_unsol_event, 3874 .init_hook = alc880_uniwill_p53_hp_automute, 3875 }, 3876 [ALC880_CLEVO] = { 3877 .mixers = { alc880_three_stack_mixer }, 3878 .init_verbs = { alc880_volume_init_verbs, 3879 alc880_pin_clevo_init_verbs }, 3880 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3881 .dac_nids = alc880_dac_nids, 3882 .hp_nid = 0x03, 3883 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 3884 .channel_mode = alc880_threestack_modes, 3885 .need_dac_fix = 1, 3886 .input_mux = &alc880_capture_source, 3887 }, 3888 [ALC880_LG] = { 3889 .mixers = { alc880_lg_mixer }, 3890 .init_verbs = { alc880_volume_init_verbs, 3891 alc880_lg_init_verbs }, 3892 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids), 3893 .dac_nids = alc880_lg_dac_nids, 3894 .dig_out_nid = ALC880_DIGOUT_NID, 3895 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes), 3896 .channel_mode = alc880_lg_ch_modes, 3897 .need_dac_fix = 1, 3898 .input_mux = &alc880_lg_capture_source, 3899 .unsol_event = alc880_lg_unsol_event, 3900 .init_hook = alc880_lg_automute, 3901#ifdef CONFIG_SND_HDA_POWER_SAVE 3902 .loopbacks = alc880_lg_loopbacks, 3903#endif 3904 }, 3905 [ALC880_LG_LW] = { 3906 .mixers = { alc880_lg_lw_mixer }, 3907 .init_verbs = { alc880_volume_init_verbs, 3908 alc880_lg_lw_init_verbs }, 3909 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3910 .dac_nids = alc880_dac_nids, 3911 .dig_out_nid = ALC880_DIGOUT_NID, 3912 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes), 3913 .channel_mode = alc880_lg_lw_modes, 3914 .input_mux = &alc880_lg_lw_capture_source, 3915 .unsol_event = alc880_lg_lw_unsol_event, 3916 .init_hook = alc880_lg_lw_automute, 3917 }, 3918 [ALC880_MEDION_RIM] = { 3919 .mixers = { alc880_medion_rim_mixer }, 3920 .init_verbs = { alc880_volume_init_verbs, 3921 alc880_medion_rim_init_verbs, 3922 alc_gpio2_init_verbs }, 3923 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3924 .dac_nids = alc880_dac_nids, 3925 .dig_out_nid = ALC880_DIGOUT_NID, 3926 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 3927 .channel_mode = alc880_2_jack_modes, 3928 .input_mux = &alc880_medion_rim_capture_source, 3929 .unsol_event = alc880_medion_rim_unsol_event, 3930 .init_hook = alc880_medion_rim_automute, 3931 }, 3932#ifdef CONFIG_SND_DEBUG 3933 [ALC880_TEST] = { 3934 .mixers = { alc880_test_mixer }, 3935 .init_verbs = { alc880_test_init_verbs }, 3936 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids), 3937 .dac_nids = alc880_test_dac_nids, 3938 .dig_out_nid = ALC880_DIGOUT_NID, 3939 .num_channel_mode = ARRAY_SIZE(alc880_test_modes), 3940 .channel_mode = alc880_test_modes, 3941 .input_mux = &alc880_test_capture_source, 3942 }, 3943#endif 3944}; 3945 3946/* 3947 * Automatic parse of I/O pins from the BIOS configuration 3948 */ 3949 3950enum { 3951 ALC_CTL_WIDGET_VOL, 3952 ALC_CTL_WIDGET_MUTE, 3953 ALC_CTL_BIND_MUTE, 3954}; 3955static struct snd_kcontrol_new alc880_control_templates[] = { 3956 HDA_CODEC_VOLUME(NULL, 0, 0, 0), 3957 HDA_CODEC_MUTE(NULL, 0, 0, 0), 3958 HDA_BIND_MUTE(NULL, 0, 0, 0), 3959}; 3960 3961/* add dynamic controls */ 3962static int add_control(struct alc_spec *spec, int type, const char *name, 3963 unsigned long val) 3964{ 3965 struct snd_kcontrol_new *knew; 3966 3967 snd_array_init(&spec->kctls, sizeof(*knew), 32); 3968 knew = snd_array_new(&spec->kctls); 3969 if (!knew) 3970 return -ENOMEM; 3971 *knew = alc880_control_templates[type]; 3972 knew->name = kstrdup(name, GFP_KERNEL); 3973 if (!knew->name) 3974 return -ENOMEM; 3975 knew->private_value = val; 3976 return 0; 3977} 3978 3979#define alc880_is_fixed_pin(nid) ((nid) >= 0x14 && (nid) <= 0x17) 3980#define alc880_fixed_pin_idx(nid) ((nid) - 0x14) 3981#define alc880_is_multi_pin(nid) ((nid) >= 0x18) 3982#define alc880_multi_pin_idx(nid) ((nid) - 0x18) 3983#define alc880_is_input_pin(nid) ((nid) >= 0x18) 3984#define alc880_input_pin_idx(nid) ((nid) - 0x18) 3985#define alc880_idx_to_dac(nid) ((nid) + 0x02) 3986#define alc880_dac_to_idx(nid) ((nid) - 0x02) 3987#define alc880_idx_to_mixer(nid) ((nid) + 0x0c) 3988#define alc880_idx_to_selector(nid) ((nid) + 0x10) 3989#define ALC880_PIN_CD_NID 0x1c 3990 3991/* fill in the dac_nids table from the parsed pin configuration */ 3992static int alc880_auto_fill_dac_nids(struct alc_spec *spec, 3993 const struct auto_pin_cfg *cfg) 3994{ 3995 hda_nid_t nid; 3996 int assigned[4]; 3997 int i, j; 3998 3999 memset(assigned, 0, sizeof(assigned)); 4000 spec->multiout.dac_nids = spec->private_dac_nids; 4001 4002 /* check the pins hardwired to audio widget */ 4003 for (i = 0; i < cfg->line_outs; i++) { 4004 nid = cfg->line_out_pins[i]; 4005 if (alc880_is_fixed_pin(nid)) { 4006 int idx = alc880_fixed_pin_idx(nid); 4007 spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx); 4008 assigned[idx] = 1; 4009 } 4010 } 4011 /* left pins can be connect to any audio widget */ 4012 for (i = 0; i < cfg->line_outs; i++) { 4013 nid = cfg->line_out_pins[i]; 4014 if (alc880_is_fixed_pin(nid)) 4015 continue; 4016 /* search for an empty channel */ 4017 for (j = 0; j < cfg->line_outs; j++) { 4018 if (!assigned[j]) { 4019 spec->multiout.dac_nids[i] = 4020 alc880_idx_to_dac(j); 4021 assigned[j] = 1; 4022 break; 4023 } 4024 } 4025 } 4026 spec->multiout.num_dacs = cfg->line_outs; 4027 return 0; 4028} 4029 4030/* add playback controls from the parsed DAC table */ 4031static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec, 4032 const struct auto_pin_cfg *cfg) 4033{ 4034 char name[32]; 4035 static const char *chname[4] = { 4036 "Front", "Surround", NULL /*CLFE*/, "Side" 4037 }; 4038 hda_nid_t nid; 4039 int i, err; 4040 4041 for (i = 0; i < cfg->line_outs; i++) { 4042 if (!spec->multiout.dac_nids[i]) 4043 continue; 4044 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i])); 4045 if (i == 2) { 4046 /* Center/LFE */ 4047 err = add_control(spec, ALC_CTL_WIDGET_VOL, 4048 "Center Playback Volume", 4049 HDA_COMPOSE_AMP_VAL(nid, 1, 0, 4050 HDA_OUTPUT)); 4051 if (err < 0) 4052 return err; 4053 err = add_control(spec, ALC_CTL_WIDGET_VOL, 4054 "LFE Playback Volume", 4055 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 4056 HDA_OUTPUT)); 4057 if (err < 0) 4058 return err; 4059 err = add_control(spec, ALC_CTL_BIND_MUTE, 4060 "Center Playback Switch", 4061 HDA_COMPOSE_AMP_VAL(nid, 1, 2, 4062 HDA_INPUT)); 4063 if (err < 0) 4064 return err; 4065 err = add_control(spec, ALC_CTL_BIND_MUTE, 4066 "LFE Playback Switch", 4067 HDA_COMPOSE_AMP_VAL(nid, 2, 2, 4068 HDA_INPUT)); 4069 if (err < 0) 4070 return err; 4071 } else { 4072 sprintf(name, "%s Playback Volume", chname[i]); 4073 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 4074 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 4075 HDA_OUTPUT)); 4076 if (err < 0) 4077 return err; 4078 sprintf(name, "%s Playback Switch", chname[i]); 4079 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 4080 HDA_COMPOSE_AMP_VAL(nid, 3, 2, 4081 HDA_INPUT)); 4082 if (err < 0) 4083 return err; 4084 } 4085 } 4086 return 0; 4087} 4088 4089/* add playback controls for speaker and HP outputs */ 4090static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin, 4091 const char *pfx) 4092{ 4093 hda_nid_t nid; 4094 int err; 4095 char name[32]; 4096 4097 if (!pin) 4098 return 0; 4099 4100 if (alc880_is_fixed_pin(pin)) { 4101 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin)); 4102 /* specify the DAC as the extra output */ 4103 if (!spec->multiout.hp_nid) 4104 spec->multiout.hp_nid = nid; 4105 else 4106 spec->multiout.extra_out_nid[0] = nid; 4107 /* control HP volume/switch on the output mixer amp */ 4108 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin)); 4109 sprintf(name, "%s Playback Volume", pfx); 4110 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 4111 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 4112 if (err < 0) 4113 return err; 4114 sprintf(name, "%s Playback Switch", pfx); 4115 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 4116 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT)); 4117 if (err < 0) 4118 return err; 4119 } else if (alc880_is_multi_pin(pin)) { 4120 /* set manual connection */ 4121 /* we have only a switch on HP-out PIN */ 4122 sprintf(name, "%s Playback Switch", pfx); 4123 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 4124 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 4125 if (err < 0) 4126 return err; 4127 } 4128 return 0; 4129} 4130 4131/* create input playback/capture controls for the given pin */ 4132static int new_analog_input(struct alc_spec *spec, hda_nid_t pin, 4133 const char *ctlname, 4134 int idx, hda_nid_t mix_nid) 4135{ 4136 char name[32]; 4137 int err; 4138 4139 sprintf(name, "%s Playback Volume", ctlname); 4140 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 4141 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); 4142 if (err < 0) 4143 return err; 4144 sprintf(name, "%s Playback Switch", ctlname); 4145 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 4146 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); 4147 if (err < 0) 4148 return err; 4149 return 0; 4150} 4151 4152/* create playback/capture controls for input pins */ 4153static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec, 4154 const struct auto_pin_cfg *cfg) 4155{ 4156 struct hda_input_mux *imux = &spec->private_imux[0]; 4157 int i, err, idx; 4158 4159 for (i = 0; i < AUTO_PIN_LAST; i++) { 4160 if (alc880_is_input_pin(cfg->input_pins[i])) { 4161 idx = alc880_input_pin_idx(cfg->input_pins[i]); 4162 err = new_analog_input(spec, cfg->input_pins[i], 4163 auto_pin_cfg_labels[i], 4164 idx, 0x0b); 4165 if (err < 0) 4166 return err; 4167 imux->items[imux->num_items].label = 4168 auto_pin_cfg_labels[i]; 4169 imux->items[imux->num_items].index = 4170 alc880_input_pin_idx(cfg->input_pins[i]); 4171 imux->num_items++; 4172 } 4173 } 4174 return 0; 4175} 4176 4177static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid, 4178 unsigned int pin_type) 4179{ 4180 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4181 pin_type); 4182 /* unmute pin */ 4183 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, 4184 AMP_OUT_UNMUTE); 4185} 4186 4187static void alc880_auto_set_output_and_unmute(struct hda_codec *codec, 4188 hda_nid_t nid, int pin_type, 4189 int dac_idx) 4190{ 4191 alc_set_pin_output(codec, nid, pin_type); 4192 /* need the manual connection? */ 4193 if (alc880_is_multi_pin(nid)) { 4194 struct alc_spec *spec = codec->spec; 4195 int idx = alc880_multi_pin_idx(nid); 4196 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0, 4197 AC_VERB_SET_CONNECT_SEL, 4198 alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx])); 4199 } 4200} 4201 4202static int get_pin_type(int line_out_type) 4203{ 4204 if (line_out_type == AUTO_PIN_HP_OUT) 4205 return PIN_HP; 4206 else 4207 return PIN_OUT; 4208} 4209 4210static void alc880_auto_init_multi_out(struct hda_codec *codec) 4211{ 4212 struct alc_spec *spec = codec->spec; 4213 int i; 4214 4215 alc_subsystem_id(codec, 0x15, 0x1b, 0x14); 4216 for (i = 0; i < spec->autocfg.line_outs; i++) { 4217 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 4218 int pin_type = get_pin_type(spec->autocfg.line_out_type); 4219 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i); 4220 } 4221} 4222 4223static void alc880_auto_init_extra_out(struct hda_codec *codec) 4224{ 4225 struct alc_spec *spec = codec->spec; 4226 hda_nid_t pin; 4227 4228 pin = spec->autocfg.speaker_pins[0]; 4229 if (pin) /* connect to front */ 4230 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 4231 pin = spec->autocfg.hp_pins[0]; 4232 if (pin) /* connect to front */ 4233 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 4234} 4235 4236static void alc880_auto_init_analog_input(struct hda_codec *codec) 4237{ 4238 struct alc_spec *spec = codec->spec; 4239 int i; 4240 4241 for (i = 0; i < AUTO_PIN_LAST; i++) { 4242 hda_nid_t nid = spec->autocfg.input_pins[i]; 4243 if (alc880_is_input_pin(nid)) { 4244 snd_hda_codec_write(codec, nid, 0, 4245 AC_VERB_SET_PIN_WIDGET_CONTROL, 4246 i <= AUTO_PIN_FRONT_MIC ? 4247 PIN_VREF80 : PIN_IN); 4248 if (nid != ALC880_PIN_CD_NID) 4249 snd_hda_codec_write(codec, nid, 0, 4250 AC_VERB_SET_AMP_GAIN_MUTE, 4251 AMP_OUT_MUTE); 4252 } 4253 } 4254} 4255 4256/* parse the BIOS configuration and set up the alc_spec */ 4257/* return 1 if successful, 0 if the proper config is not found, 4258 * or a negative error code 4259 */ 4260static int alc880_parse_auto_config(struct hda_codec *codec) 4261{ 4262 struct alc_spec *spec = codec->spec; 4263 int err; 4264 static hda_nid_t alc880_ignore[] = { 0x1d, 0 }; 4265 4266 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 4267 alc880_ignore); 4268 if (err < 0) 4269 return err; 4270 if (!spec->autocfg.line_outs) 4271 return 0; /* can't find valid BIOS pin config */ 4272 4273 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg); 4274 if (err < 0) 4275 return err; 4276 err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg); 4277 if (err < 0) 4278 return err; 4279 err = alc880_auto_create_extra_out(spec, 4280 spec->autocfg.speaker_pins[0], 4281 "Speaker"); 4282 if (err < 0) 4283 return err; 4284 err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0], 4285 "Headphone"); 4286 if (err < 0) 4287 return err; 4288 err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg); 4289 if (err < 0) 4290 return err; 4291 4292 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 4293 4294 if (spec->autocfg.dig_outs) 4295 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID; 4296 if (spec->autocfg.dig_in_pin) 4297 spec->dig_in_nid = ALC880_DIGIN_NID; 4298 4299 if (spec->kctls.list) 4300 add_mixer(spec, spec->kctls.list); 4301 4302 add_verb(spec, alc880_volume_init_verbs); 4303 4304 spec->num_mux_defs = 1; 4305 spec->input_mux = &spec->private_imux[0]; 4306 4307 store_pin_configs(codec); 4308 return 1; 4309} 4310 4311/* additional initialization for auto-configuration model */ 4312static void alc880_auto_init(struct hda_codec *codec) 4313{ 4314 struct alc_spec *spec = codec->spec; 4315 alc880_auto_init_multi_out(codec); 4316 alc880_auto_init_extra_out(codec); 4317 alc880_auto_init_analog_input(codec); 4318 if (spec->unsol_event) 4319 alc_inithook(codec); 4320} 4321 4322static void set_capture_mixer(struct alc_spec *spec) 4323{ 4324 static struct snd_kcontrol_new *caps[3] = { 4325 alc_capture_mixer1, 4326 alc_capture_mixer2, 4327 alc_capture_mixer3, 4328 }; 4329 if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) 4330 spec->cap_mixer = caps[spec->num_adc_nids - 1]; 4331} 4332 4333#define set_beep_amp(spec, nid, idx, dir) \ 4334 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir)) 4335 4336/* 4337 * OK, here we have finally the patch for ALC880 4338 */ 4339 4340static int patch_alc880(struct hda_codec *codec) 4341{ 4342 struct alc_spec *spec; 4343 int board_config; 4344 int err; 4345 4346 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 4347 if (spec == NULL) 4348 return -ENOMEM; 4349 4350 codec->spec = spec; 4351 4352 board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST, 4353 alc880_models, 4354 alc880_cfg_tbl); 4355 if (board_config < 0) { 4356 printk(KERN_INFO "hda_codec: Unknown model for ALC880, " 4357 "trying auto-probe from BIOS...\n"); 4358 board_config = ALC880_AUTO; 4359 } 4360 4361 if (board_config == ALC880_AUTO) { 4362 /* automatic parse from the BIOS config */ 4363 err = alc880_parse_auto_config(codec); 4364 if (err < 0) { 4365 alc_free(codec); 4366 return err; 4367 } else if (!err) { 4368 printk(KERN_INFO 4369 "hda_codec: Cannot set up configuration " 4370 "from BIOS. Using 3-stack mode...\n"); 4371 board_config = ALC880_3ST; 4372 } 4373 } 4374 4375 err = snd_hda_attach_beep_device(codec, 0x1); 4376 if (err < 0) { 4377 alc_free(codec); 4378 return err; 4379 } 4380 4381 if (board_config != ALC880_AUTO) 4382 setup_preset(spec, &alc880_presets[board_config]); 4383 4384 spec->stream_name_analog = "ALC880 Analog"; 4385 spec->stream_analog_playback = &alc880_pcm_analog_playback; 4386 spec->stream_analog_capture = &alc880_pcm_analog_capture; 4387 spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture; 4388 4389 spec->stream_name_digital = "ALC880 Digital"; 4390 spec->stream_digital_playback = &alc880_pcm_digital_playback; 4391 spec->stream_digital_capture = &alc880_pcm_digital_capture; 4392 4393 if (!spec->adc_nids && spec->input_mux) { 4394 /* check whether NID 0x07 is valid */ 4395 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]); 4396 /* get type */ 4397 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 4398 if (wcap != AC_WID_AUD_IN) { 4399 spec->adc_nids = alc880_adc_nids_alt; 4400 spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt); 4401 } else { 4402 spec->adc_nids = alc880_adc_nids; 4403 spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids); 4404 } 4405 } 4406 set_capture_mixer(spec); 4407 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 4408 4409 spec->vmaster_nid = 0x0c; 4410 4411 codec->patch_ops = alc_patch_ops; 4412 if (board_config == ALC880_AUTO) 4413 spec->init_hook = alc880_auto_init; 4414#ifdef CONFIG_SND_HDA_POWER_SAVE 4415 if (!spec->loopback.amplist) 4416 spec->loopback.amplist = alc880_loopbacks; 4417#endif 4418 codec->proc_widget_hook = print_realtek_coef; 4419 4420 return 0; 4421} 4422 4423 4424/* 4425 * ALC260 support 4426 */ 4427 4428static hda_nid_t alc260_dac_nids[1] = { 4429 /* front */ 4430 0x02, 4431}; 4432 4433static hda_nid_t alc260_adc_nids[1] = { 4434 /* ADC0 */ 4435 0x04, 4436}; 4437 4438static hda_nid_t alc260_adc_nids_alt[1] = { 4439 /* ADC1 */ 4440 0x05, 4441}; 4442 4443/* NIDs used when simultaneous access to both ADCs makes sense. Note that 4444 * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC. 4445 */ 4446static hda_nid_t alc260_dual_adc_nids[2] = { 4447 /* ADC0, ADC1 */ 4448 0x04, 0x05 4449}; 4450 4451#define ALC260_DIGOUT_NID 0x03 4452#define ALC260_DIGIN_NID 0x06 4453 4454static struct hda_input_mux alc260_capture_source = { 4455 .num_items = 4, 4456 .items = { 4457 { "Mic", 0x0 }, 4458 { "Front Mic", 0x1 }, 4459 { "Line", 0x2 }, 4460 { "CD", 0x4 }, 4461 }, 4462}; 4463 4464/* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack, 4465 * headphone jack and the internal CD lines since these are the only pins at 4466 * which audio can appear. For flexibility, also allow the option of 4467 * recording the mixer output on the second ADC (ADC0 doesn't have a 4468 * connection to the mixer output). 4469 */ 4470static struct hda_input_mux alc260_fujitsu_capture_sources[2] = { 4471 { 4472 .num_items = 3, 4473 .items = { 4474 { "Mic/Line", 0x0 }, 4475 { "CD", 0x4 }, 4476 { "Headphone", 0x2 }, 4477 }, 4478 }, 4479 { 4480 .num_items = 4, 4481 .items = { 4482 { "Mic/Line", 0x0 }, 4483 { "CD", 0x4 }, 4484 { "Headphone", 0x2 }, 4485 { "Mixer", 0x5 }, 4486 }, 4487 }, 4488 4489}; 4490 4491/* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to 4492 * the Fujitsu S702x, but jacks are marked differently. 4493 */ 4494static struct hda_input_mux alc260_acer_capture_sources[2] = { 4495 { 4496 .num_items = 4, 4497 .items = { 4498 { "Mic", 0x0 }, 4499 { "Line", 0x2 }, 4500 { "CD", 0x4 }, 4501 { "Headphone", 0x5 }, 4502 }, 4503 }, 4504 { 4505 .num_items = 5, 4506 .items = { 4507 { "Mic", 0x0 }, 4508 { "Line", 0x2 }, 4509 { "CD", 0x4 }, 4510 { "Headphone", 0x6 }, 4511 { "Mixer", 0x5 }, 4512 }, 4513 }, 4514}; 4515/* 4516 * This is just place-holder, so there's something for alc_build_pcms to look 4517 * at when it calculates the maximum number of channels. ALC260 has no mixer 4518 * element which allows changing the channel mode, so the verb list is 4519 * never used. 4520 */ 4521static struct hda_channel_mode alc260_modes[1] = { 4522 { 2, NULL }, 4523}; 4524 4525 4526/* Mixer combinations 4527 * 4528 * basic: base_output + input + pc_beep + capture 4529 * HP: base_output + input + capture_alt 4530 * HP_3013: hp_3013 + input + capture 4531 * fujitsu: fujitsu + capture 4532 * acer: acer + capture 4533 */ 4534 4535static struct snd_kcontrol_new alc260_base_output_mixer[] = { 4536 HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4537 HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT), 4538 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT), 4539 HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT), 4540 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT), 4541 HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT), 4542 { } /* end */ 4543}; 4544 4545static struct snd_kcontrol_new alc260_input_mixer[] = { 4546 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 4547 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 4548 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT), 4549 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT), 4550 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT), 4551 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT), 4552 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT), 4553 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT), 4554 { } /* end */ 4555}; 4556 4557/* update HP, line and mono out pins according to the master switch */ 4558static void alc260_hp_master_update(struct hda_codec *codec, 4559 hda_nid_t hp, hda_nid_t line, 4560 hda_nid_t mono) 4561{ 4562 struct alc_spec *spec = codec->spec; 4563 unsigned int val = spec->master_sw ? PIN_HP : 0; 4564 /* change HP and line-out pins */ 4565 snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4566 val); 4567 snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4568 val); 4569 /* mono (speaker) depending on the HP jack sense */ 4570 val = (val && !spec->jack_present) ? PIN_OUT : 0; 4571 snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4572 val); 4573} 4574 4575static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol, 4576 struct snd_ctl_elem_value *ucontrol) 4577{ 4578 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 4579 struct alc_spec *spec = codec->spec; 4580 *ucontrol->value.integer.value = spec->master_sw; 4581 return 0; 4582} 4583 4584static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol, 4585 struct snd_ctl_elem_value *ucontrol) 4586{ 4587 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 4588 struct alc_spec *spec = codec->spec; 4589 int val = !!*ucontrol->value.integer.value; 4590 hda_nid_t hp, line, mono; 4591 4592 if (val == spec->master_sw) 4593 return 0; 4594 spec->master_sw = val; 4595 hp = (kcontrol->private_value >> 16) & 0xff; 4596 line = (kcontrol->private_value >> 8) & 0xff; 4597 mono = kcontrol->private_value & 0xff; 4598 alc260_hp_master_update(codec, hp, line, mono); 4599 return 1; 4600} 4601 4602static struct snd_kcontrol_new alc260_hp_output_mixer[] = { 4603 { 4604 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4605 .name = "Master Playback Switch", 4606 .info = snd_ctl_boolean_mono_info, 4607 .get = alc260_hp_master_sw_get, 4608 .put = alc260_hp_master_sw_put, 4609 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11 4610 }, 4611 HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4612 HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT), 4613 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT), 4614 HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT), 4615 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, 4616 HDA_OUTPUT), 4617 HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT), 4618 { } /* end */ 4619}; 4620 4621static struct hda_verb alc260_hp_unsol_verbs[] = { 4622 {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 4623 {}, 4624}; 4625 4626static void alc260_hp_automute(struct hda_codec *codec) 4627{ 4628 struct alc_spec *spec = codec->spec; 4629 unsigned int present; 4630 4631 present = snd_hda_codec_read(codec, 0x10, 0, 4632 AC_VERB_GET_PIN_SENSE, 0); 4633 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0; 4634 alc260_hp_master_update(codec, 0x0f, 0x10, 0x11); 4635} 4636 4637static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res) 4638{ 4639 if ((res >> 26) == ALC880_HP_EVENT) 4640 alc260_hp_automute(codec); 4641} 4642 4643static struct snd_kcontrol_new alc260_hp_3013_mixer[] = { 4644 { 4645 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4646 .name = "Master Playback Switch", 4647 .info = snd_ctl_boolean_mono_info, 4648 .get = alc260_hp_master_sw_get, 4649 .put = alc260_hp_master_sw_put, 4650 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11 4651 }, 4652 HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT), 4653 HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT), 4654 HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT), 4655 HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT), 4656 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4657 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 4658 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT), 4659 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT), 4660 { } /* end */ 4661}; 4662 4663static struct hda_bind_ctls alc260_dc7600_bind_master_vol = { 4664 .ops = &snd_hda_bind_vol, 4665 .values = { 4666 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT), 4667 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT), 4668 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT), 4669 0 4670 }, 4671}; 4672 4673static struct hda_bind_ctls alc260_dc7600_bind_switch = { 4674 .ops = &snd_hda_bind_sw, 4675 .values = { 4676 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT), 4677 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT), 4678 0 4679 }, 4680}; 4681 4682static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = { 4683 HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol), 4684 HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch), 4685 HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT), 4686 HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT), 4687 { } /* end */ 4688}; 4689 4690static struct hda_verb alc260_hp_3013_unsol_verbs[] = { 4691 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 4692 {}, 4693}; 4694 4695static void alc260_hp_3013_automute(struct hda_codec *codec) 4696{ 4697 struct alc_spec *spec = codec->spec; 4698 unsigned int present; 4699 4700 present = snd_hda_codec_read(codec, 0x15, 0, 4701 AC_VERB_GET_PIN_SENSE, 0); 4702 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0; 4703 alc260_hp_master_update(codec, 0x15, 0x10, 0x11); 4704} 4705 4706static void alc260_hp_3013_unsol_event(struct hda_codec *codec, 4707 unsigned int res) 4708{ 4709 if ((res >> 26) == ALC880_HP_EVENT) 4710 alc260_hp_3013_automute(codec); 4711} 4712 4713static void alc260_hp_3012_automute(struct hda_codec *codec) 4714{ 4715 unsigned int present, bits; 4716 4717 present = snd_hda_codec_read(codec, 0x10, 0, 4718 AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE; 4719 4720 bits = present ? 0 : PIN_OUT; 4721 snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4722 bits); 4723 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4724 bits); 4725 snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4726 bits); 4727} 4728 4729static void alc260_hp_3012_unsol_event(struct hda_codec *codec, 4730 unsigned int res) 4731{ 4732 if ((res >> 26) == ALC880_HP_EVENT) 4733 alc260_hp_3012_automute(codec); 4734} 4735 4736/* Fujitsu S702x series laptops. ALC260 pin usage: Mic/Line jack = 0x12, 4737 * HP jack = 0x14, CD audio = 0x16, internal speaker = 0x10. 4738 */ 4739static struct snd_kcontrol_new alc260_fujitsu_mixer[] = { 4740 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4741 HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT), 4742 ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT), 4743 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 4744 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 4745 HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT), 4746 HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT), 4747 ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN), 4748 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT), 4749 HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT), 4750 { } /* end */ 4751}; 4752 4753/* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks. Note that current 4754 * versions of the ALC260 don't act on requests to enable mic bias from NID 4755 * 0x0f (used to drive the headphone jack in these laptops). The ALC260 4756 * datasheet doesn't mention this restriction. At this stage it's not clear 4757 * whether this behaviour is intentional or is a hardware bug in chip 4758 * revisions available in early 2006. Therefore for now allow the 4759 * "Headphone Jack Mode" control to span all choices, but if it turns out 4760 * that the lack of mic bias for this NID is intentional we could change the 4761 * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS. 4762 * 4763 * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006 4764 * don't appear to make the mic bias available from the "line" jack, even 4765 * though the NID used for this jack (0x14) can supply it. The theory is 4766 * that perhaps Acer have included blocking capacitors between the ALC260 4767 * and the output jack. If this turns out to be the case for all such 4768 * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT 4769 * to ALC_PIN_DIR_INOUT_NOMICBIAS. 4770 * 4771 * The C20x Tablet series have a mono internal speaker which is controlled 4772 * via the chip's Mono sum widget and pin complex, so include the necessary 4773 * controls for such models. On models without a "mono speaker" the control 4774 * won't do anything. 4775 */ 4776static struct snd_kcontrol_new alc260_acer_mixer[] = { 4777 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4778 HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT), 4779 ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT), 4780 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, 4781 HDA_OUTPUT), 4782 HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, 4783 HDA_INPUT), 4784 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 4785 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 4786 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT), 4787 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT), 4788 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN), 4789 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT), 4790 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT), 4791 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT), 4792 { } /* end */ 4793}; 4794 4795/* Packard bell V7900 ALC260 pin usage: HP = 0x0f, Mic jack = 0x12, 4796 * Line In jack = 0x14, CD audio = 0x16, pc beep = 0x17. 4797 */ 4798static struct snd_kcontrol_new alc260_will_mixer[] = { 4799 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4800 HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT), 4801 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT), 4802 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT), 4803 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN), 4804 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT), 4805 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT), 4806 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT), 4807 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 4808 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 4809 { } /* end */ 4810}; 4811 4812/* Replacer 672V ALC260 pin usage: Mic jack = 0x12, 4813 * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f. 4814 */ 4815static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = { 4816 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4817 HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT), 4818 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT), 4819 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT), 4820 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN), 4821 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT), 4822 HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT), 4823 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT), 4824 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT), 4825 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT), 4826 { } /* end */ 4827}; 4828 4829/* 4830 * initialization verbs 4831 */ 4832static struct hda_verb alc260_init_verbs[] = { 4833 /* Line In pin widget for input */ 4834 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 4835 /* CD pin widget for input */ 4836 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 4837 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 4838 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 4839 /* Mic2 (front panel) pin widget for input and vref at 80% */ 4840 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 4841 /* LINE-2 is used for line-out in rear */ 4842 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4843 /* select line-out */ 4844 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00}, 4845 /* LINE-OUT pin */ 4846 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4847 /* enable HP */ 4848 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 4849 /* enable Mono */ 4850 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4851 /* mute capture amp left and right */ 4852 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4853 /* set connection select to line in (default select for this ADC) */ 4854 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02}, 4855 /* mute capture amp left and right */ 4856 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4857 /* set connection select to line in (default select for this ADC) */ 4858 {0x05, AC_VERB_SET_CONNECT_SEL, 0x02}, 4859 /* set vol=0 Line-Out mixer amp left and right */ 4860 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4861 /* unmute pin widget amp left and right (no gain on this amp) */ 4862 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4863 /* set vol=0 HP mixer amp left and right */ 4864 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4865 /* unmute pin widget amp left and right (no gain on this amp) */ 4866 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4867 /* set vol=0 Mono mixer amp left and right */ 4868 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4869 /* unmute pin widget amp left and right (no gain on this amp) */ 4870 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4871 /* unmute LINE-2 out pin */ 4872 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4873 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & 4874 * Line In 2 = 0x03 4875 */ 4876 /* mute analog inputs */ 4877 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4878 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4879 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 4880 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 4881 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 4882 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */ 4883 /* mute Front out path */ 4884 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4885 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4886 /* mute Headphone out path */ 4887 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4888 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4889 /* mute Mono out path */ 4890 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4891 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4892 { } 4893}; 4894 4895#if 0 /* should be identical with alc260_init_verbs? */ 4896static struct hda_verb alc260_hp_init_verbs[] = { 4897 /* Headphone and output */ 4898 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 4899 /* mono output */ 4900 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 4901 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 4902 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 4903 /* Mic2 (front panel) pin widget for input and vref at 80% */ 4904 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 4905 /* Line In pin widget for input */ 4906 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 4907 /* Line-2 pin widget for output */ 4908 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 4909 /* CD pin widget for input */ 4910 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 4911 /* unmute amp left and right */ 4912 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000}, 4913 /* set connection select to line in (default select for this ADC) */ 4914 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02}, 4915 /* unmute Line-Out mixer amp left and right (volume = 0) */ 4916 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 4917 /* mute pin widget amp left and right (no gain on this amp) */ 4918 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 4919 /* unmute HP mixer amp left and right (volume = 0) */ 4920 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 4921 /* mute pin widget amp left and right (no gain on this amp) */ 4922 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 4923 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & 4924 * Line In 2 = 0x03 4925 */ 4926 /* mute analog inputs */ 4927 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4928 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4929 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 4930 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 4931 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 4932 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */ 4933 /* Unmute Front out path */ 4934 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4935 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4936 /* Unmute Headphone out path */ 4937 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4938 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4939 /* Unmute Mono out path */ 4940 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4941 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4942 { } 4943}; 4944#endif 4945 4946static struct hda_verb alc260_hp_3013_init_verbs[] = { 4947 /* Line out and output */ 4948 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 4949 /* mono output */ 4950 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 4951 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 4952 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 4953 /* Mic2 (front panel) pin widget for input and vref at 80% */ 4954 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 4955 /* Line In pin widget for input */ 4956 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 4957 /* Headphone pin widget for output */ 4958 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 4959 /* CD pin widget for input */ 4960 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 4961 /* unmute amp left and right */ 4962 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000}, 4963 /* set connection select to line in (default select for this ADC) */ 4964 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02}, 4965 /* unmute Line-Out mixer amp left and right (volume = 0) */ 4966 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 4967 /* mute pin widget amp left and right (no gain on this amp) */ 4968 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 4969 /* unmute HP mixer amp left and right (volume = 0) */ 4970 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 4971 /* mute pin widget amp left and right (no gain on this amp) */ 4972 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 4973 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & 4974 * Line In 2 = 0x03 4975 */ 4976 /* mute analog inputs */ 4977 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4978 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4979 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 4980 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 4981 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 4982 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */ 4983 /* Unmute Front out path */ 4984 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4985 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4986 /* Unmute Headphone out path */ 4987 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4988 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4989 /* Unmute Mono out path */ 4990 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4991 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4992 { } 4993}; 4994 4995/* Initialisation sequence for ALC260 as configured in Fujitsu S702x 4996 * laptops. ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD 4997 * audio = 0x16, internal speaker = 0x10. 4998 */ 4999static struct hda_verb alc260_fujitsu_init_verbs[] = { 5000 /* Disable all GPIOs */ 5001 {0x01, AC_VERB_SET_GPIO_MASK, 0}, 5002 /* Internal speaker is connected to headphone pin */ 5003 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 5004 /* Headphone/Line-out jack connects to Line1 pin; make it an output */ 5005 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5006 /* Mic/Line-in jack is connected to mic1 pin, so make it an input */ 5007 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 5008 /* Ensure all other unused pins are disabled and muted. */ 5009 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 5010 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5011 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 5012 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5013 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 5014 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5015 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 5016 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5017 5018 /* Disable digital (SPDIF) pins */ 5019 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0}, 5020 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0}, 5021 5022 /* Ensure Line1 pin widget takes its input from the OUT1 sum bus 5023 * when acting as an output. 5024 */ 5025 {0x0d, AC_VERB_SET_CONNECT_SEL, 0}, 5026 5027 /* Start with output sum widgets muted and their output gains at min */ 5028 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5029 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5030 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5031 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5032 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5033 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5034 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5035 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5036 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5037 5038 /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */ 5039 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5040 /* Unmute Line1 pin widget output buffer since it starts as an output. 5041 * If the pin mode is changed by the user the pin mode control will 5042 * take care of enabling the pin's input/output buffers as needed. 5043 * Therefore there's no need to enable the input buffer at this 5044 * stage. 5045 */ 5046 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5047 /* Unmute input buffer of pin widget used for Line-in (no equiv 5048 * mixer ctrl) 5049 */ 5050 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5051 5052 /* Mute capture amp left and right */ 5053 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5054 /* Set ADC connection select to match default mixer setting - line 5055 * in (on mic1 pin) 5056 */ 5057 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00}, 5058 5059 /* Do the same for the second ADC: mute capture input amp and 5060 * set ADC connection to line in (on mic1 pin) 5061 */ 5062 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5063 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00}, 5064 5065 /* Mute all inputs to mixer widget (even unconnected ones) */ 5066 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */ 5067 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */ 5068 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */ 5069 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */ 5070 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */ 5071 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */ 5072 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */ 5073 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */ 5074 5075 { } 5076}; 5077 5078/* Initialisation sequence for ALC260 as configured in Acer TravelMate and 5079 * similar laptops (adapted from Fujitsu init verbs). 5080 */ 5081static struct hda_verb alc260_acer_init_verbs[] = { 5082 /* On TravelMate laptops, GPIO 0 enables the internal speaker and 5083 * the headphone jack. Turn this on and rely on the standard mute 5084 * methods whenever the user wants to turn these outputs off. 5085 */ 5086 {0x01, AC_VERB_SET_GPIO_MASK, 0x01}, 5087 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, 5088 {0x01, AC_VERB_SET_GPIO_DATA, 0x01}, 5089 /* Internal speaker/Headphone jack is connected to Line-out pin */ 5090 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 5091 /* Internal microphone/Mic jack is connected to Mic1 pin */ 5092 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50}, 5093 /* Line In jack is connected to Line1 pin */ 5094 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 5095 /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */ 5096 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 5097 /* Ensure all other unused pins are disabled and muted. */ 5098 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 5099 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5100 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 5101 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5102 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 5103 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5104 /* Disable digital (SPDIF) pins */ 5105 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0}, 5106 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0}, 5107 5108 /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum 5109 * bus when acting as outputs. 5110 */ 5111 {0x0b, AC_VERB_SET_CONNECT_SEL, 0}, 5112 {0x0d, AC_VERB_SET_CONNECT_SEL, 0}, 5113 5114 /* Start with output sum widgets muted and their output gains at min */ 5115 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5116 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5117 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5118 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5119 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5120 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5121 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5122 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5123 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5124 5125 /* Unmute Line-out pin widget amp left and right 5126 * (no equiv mixer ctrl) 5127 */ 5128 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5129 /* Unmute mono pin widget amp output (no equiv mixer ctrl) */ 5130 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5131 /* Unmute Mic1 and Line1 pin widget input buffers since they start as 5132 * inputs. If the pin mode is changed by the user the pin mode control 5133 * will take care of enabling the pin's input/output buffers as needed. 5134 * Therefore there's no need to enable the input buffer at this 5135 * stage. 5136 */ 5137 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5138 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5139 5140 /* Mute capture amp left and right */ 5141 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5142 /* Set ADC connection select to match default mixer setting - mic 5143 * (on mic1 pin) 5144 */ 5145 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00}, 5146 5147 /* Do similar with the second ADC: mute capture input amp and 5148 * set ADC connection to mic to match ALSA's default state. 5149 */ 5150 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5151 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00}, 5152 5153 /* Mute all inputs to mixer widget (even unconnected ones) */ 5154 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */ 5155 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */ 5156 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */ 5157 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */ 5158 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */ 5159 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */ 5160 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */ 5161 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */ 5162 5163 { } 5164}; 5165 5166static struct hda_verb alc260_will_verbs[] = { 5167 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 5168 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00}, 5169 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00}, 5170 {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02}, 5171 {0x1a, AC_VERB_SET_COEF_INDEX, 0x07}, 5172 {0x1a, AC_VERB_SET_PROC_COEF, 0x3040}, 5173 {} 5174}; 5175 5176static struct hda_verb alc260_replacer_672v_verbs[] = { 5177 {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02}, 5178 {0x1a, AC_VERB_SET_COEF_INDEX, 0x07}, 5179 {0x1a, AC_VERB_SET_PROC_COEF, 0x3050}, 5180 5181 {0x01, AC_VERB_SET_GPIO_MASK, 0x01}, 5182 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, 5183 {0x01, AC_VERB_SET_GPIO_DATA, 0x00}, 5184 5185 {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 5186 {} 5187}; 5188 5189/* toggle speaker-output according to the hp-jack state */ 5190static void alc260_replacer_672v_automute(struct hda_codec *codec) 5191{ 5192 unsigned int present; 5193 5194 /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */ 5195 present = snd_hda_codec_read(codec, 0x0f, 0, 5196 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 5197 if (present) { 5198 snd_hda_codec_write_cache(codec, 0x01, 0, 5199 AC_VERB_SET_GPIO_DATA, 1); 5200 snd_hda_codec_write_cache(codec, 0x0f, 0, 5201 AC_VERB_SET_PIN_WIDGET_CONTROL, 5202 PIN_HP); 5203 } else { 5204 snd_hda_codec_write_cache(codec, 0x01, 0, 5205 AC_VERB_SET_GPIO_DATA, 0); 5206 snd_hda_codec_write_cache(codec, 0x0f, 0, 5207 AC_VERB_SET_PIN_WIDGET_CONTROL, 5208 PIN_OUT); 5209 } 5210} 5211 5212static void alc260_replacer_672v_unsol_event(struct hda_codec *codec, 5213 unsigned int res) 5214{ 5215 if ((res >> 26) == ALC880_HP_EVENT) 5216 alc260_replacer_672v_automute(codec); 5217} 5218 5219static struct hda_verb alc260_hp_dc7600_verbs[] = { 5220 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01}, 5221 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 5222 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5223 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 5224 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5225 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5226 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 5227 {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 5228 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 5229 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 5230 {} 5231}; 5232 5233/* Test configuration for debugging, modelled after the ALC880 test 5234 * configuration. 5235 */ 5236#ifdef CONFIG_SND_DEBUG 5237static hda_nid_t alc260_test_dac_nids[1] = { 5238 0x02, 5239}; 5240static hda_nid_t alc260_test_adc_nids[2] = { 5241 0x04, 0x05, 5242}; 5243/* For testing the ALC260, each input MUX needs its own definition since 5244 * the signal assignments are different. This assumes that the first ADC 5245 * is NID 0x04. 5246 */ 5247static struct hda_input_mux alc260_test_capture_sources[2] = { 5248 { 5249 .num_items = 7, 5250 .items = { 5251 { "MIC1 pin", 0x0 }, 5252 { "MIC2 pin", 0x1 }, 5253 { "LINE1 pin", 0x2 }, 5254 { "LINE2 pin", 0x3 }, 5255 { "CD pin", 0x4 }, 5256 { "LINE-OUT pin", 0x5 }, 5257 { "HP-OUT pin", 0x6 }, 5258 }, 5259 }, 5260 { 5261 .num_items = 8, 5262 .items = { 5263 { "MIC1 pin", 0x0 }, 5264 { "MIC2 pin", 0x1 }, 5265 { "LINE1 pin", 0x2 }, 5266 { "LINE2 pin", 0x3 }, 5267 { "CD pin", 0x4 }, 5268 { "Mixer", 0x5 }, 5269 { "LINE-OUT pin", 0x6 }, 5270 { "HP-OUT pin", 0x7 }, 5271 }, 5272 }, 5273}; 5274static struct snd_kcontrol_new alc260_test_mixer[] = { 5275 /* Output driver widgets */ 5276 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT), 5277 HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT), 5278 HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT), 5279 HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT), 5280 HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT), 5281 HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT), 5282 5283 /* Modes for retasking pin widgets 5284 * Note: the ALC260 doesn't seem to act on requests to enable mic 5285 * bias from NIDs 0x0f and 0x10. The ALC260 datasheet doesn't 5286 * mention this restriction. At this stage it's not clear whether 5287 * this behaviour is intentional or is a hardware bug in chip 5288 * revisions available at least up until early 2006. Therefore for 5289 * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all 5290 * choices, but if it turns out that the lack of mic bias for these 5291 * NIDs is intentional we could change their modes from 5292 * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS. 5293 */ 5294 ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT), 5295 ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT), 5296 ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT), 5297 ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT), 5298 ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT), 5299 ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT), 5300 5301 /* Loopback mixer controls */ 5302 HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT), 5303 HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT), 5304 HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT), 5305 HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT), 5306 HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT), 5307 HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT), 5308 HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT), 5309 HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT), 5310 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 5311 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 5312 HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT), 5313 HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT), 5314 HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT), 5315 HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT), 5316 5317 /* Controls for GPIO pins, assuming they are configured as outputs */ 5318 ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01), 5319 ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02), 5320 ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04), 5321 ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08), 5322 5323 /* Switches to allow the digital IO pins to be enabled. The datasheet 5324 * is ambigious as to which NID is which; testing on laptops which 5325 * make this output available should provide clarification. 5326 */ 5327 ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01), 5328 ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01), 5329 5330 /* A switch allowing EAPD to be enabled. Some laptops seem to use 5331 * this output to turn on an external amplifier. 5332 */ 5333 ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02), 5334 ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02), 5335 5336 { } /* end */ 5337}; 5338static struct hda_verb alc260_test_init_verbs[] = { 5339 /* Enable all GPIOs as outputs with an initial value of 0 */ 5340 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f}, 5341 {0x01, AC_VERB_SET_GPIO_DATA, 0x00}, 5342 {0x01, AC_VERB_SET_GPIO_MASK, 0x0f}, 5343 5344 /* Enable retasking pins as output, initially without power amp */ 5345 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5346 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5347 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5348 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5349 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5350 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5351 5352 /* Disable digital (SPDIF) pins initially, but users can enable 5353 * them via a mixer switch. In the case of SPDIF-out, this initverb 5354 * payload also sets the generation to 0, output to be in "consumer" 5355 * PCM format, copyright asserted, no pre-emphasis and no validity 5356 * control. 5357 */ 5358 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0}, 5359 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0}, 5360 5361 /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the 5362 * OUT1 sum bus when acting as an output. 5363 */ 5364 {0x0b, AC_VERB_SET_CONNECT_SEL, 0}, 5365 {0x0c, AC_VERB_SET_CONNECT_SEL, 0}, 5366 {0x0d, AC_VERB_SET_CONNECT_SEL, 0}, 5367 {0x0e, AC_VERB_SET_CONNECT_SEL, 0}, 5368 5369 /* Start with output sum widgets muted and their output gains at min */ 5370 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5371 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5372 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5373 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5374 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5375 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5376 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5377 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5378 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5379 5380 /* Unmute retasking pin widget output buffers since the default 5381 * state appears to be output. As the pin mode is changed by the 5382 * user the pin mode control will take care of enabling the pin's 5383 * input/output buffers as needed. 5384 */ 5385 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5386 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5387 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5388 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5389 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5390 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5391 /* Also unmute the mono-out pin widget */ 5392 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5393 5394 /* Mute capture amp left and right */ 5395 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5396 /* Set ADC connection select to match default mixer setting (mic1 5397 * pin) 5398 */ 5399 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00}, 5400 5401 /* Do the same for the second ADC: mute capture input amp and 5402 * set ADC connection to mic1 pin 5403 */ 5404 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5405 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00}, 5406 5407 /* Mute all inputs to mixer widget (even unconnected ones) */ 5408 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */ 5409 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */ 5410 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */ 5411 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */ 5412 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */ 5413 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */ 5414 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */ 5415 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */ 5416 5417 { } 5418}; 5419#endif 5420 5421#define alc260_pcm_analog_playback alc880_pcm_analog_alt_playback 5422#define alc260_pcm_analog_capture alc880_pcm_analog_capture 5423 5424#define alc260_pcm_digital_playback alc880_pcm_digital_playback 5425#define alc260_pcm_digital_capture alc880_pcm_digital_capture 5426 5427/* 5428 * for BIOS auto-configuration 5429 */ 5430 5431static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid, 5432 const char *pfx, int *vol_bits) 5433{ 5434 hda_nid_t nid_vol; 5435 unsigned long vol_val, sw_val; 5436 char name[32]; 5437 int err; 5438 5439 if (nid >= 0x0f && nid < 0x11) { 5440 nid_vol = nid - 0x7; 5441 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT); 5442 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 5443 } else if (nid == 0x11) { 5444 nid_vol = nid - 0x7; 5445 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT); 5446 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT); 5447 } else if (nid >= 0x12 && nid <= 0x15) { 5448 nid_vol = 0x08; 5449 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT); 5450 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 5451 } else 5452 return 0; /* N/A */ 5453 5454 if (!(*vol_bits & (1 << nid_vol))) { 5455 /* first control for the volume widget */ 5456 snprintf(name, sizeof(name), "%s Playback Volume", pfx); 5457 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val); 5458 if (err < 0) 5459 return err; 5460 *vol_bits |= (1 << nid_vol); 5461 } 5462 snprintf(name, sizeof(name), "%s Playback Switch", pfx); 5463 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val); 5464 if (err < 0) 5465 return err; 5466 return 1; 5467} 5468 5469/* add playback controls from the parsed DAC table */ 5470static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec, 5471 const struct auto_pin_cfg *cfg) 5472{ 5473 hda_nid_t nid; 5474 int err; 5475 int vols = 0; 5476 5477 spec->multiout.num_dacs = 1; 5478 spec->multiout.dac_nids = spec->private_dac_nids; 5479 spec->multiout.dac_nids[0] = 0x02; 5480 5481 nid = cfg->line_out_pins[0]; 5482 if (nid) { 5483 err = alc260_add_playback_controls(spec, nid, "Front", &vols); 5484 if (err < 0) 5485 return err; 5486 } 5487 5488 nid = cfg->speaker_pins[0]; 5489 if (nid) { 5490 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols); 5491 if (err < 0) 5492 return err; 5493 } 5494 5495 nid = cfg->hp_pins[0]; 5496 if (nid) { 5497 err = alc260_add_playback_controls(spec, nid, "Headphone", 5498 &vols); 5499 if (err < 0) 5500 return err; 5501 } 5502 return 0; 5503} 5504 5505/* create playback/capture controls for input pins */ 5506static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec, 5507 const struct auto_pin_cfg *cfg) 5508{ 5509 struct hda_input_mux *imux = &spec->private_imux[0]; 5510 int i, err, idx; 5511 5512 for (i = 0; i < AUTO_PIN_LAST; i++) { 5513 if (cfg->input_pins[i] >= 0x12) { 5514 idx = cfg->input_pins[i] - 0x12; 5515 err = new_analog_input(spec, cfg->input_pins[i], 5516 auto_pin_cfg_labels[i], idx, 5517 0x07); 5518 if (err < 0) 5519 return err; 5520 imux->items[imux->num_items].label = 5521 auto_pin_cfg_labels[i]; 5522 imux->items[imux->num_items].index = idx; 5523 imux->num_items++; 5524 } 5525 if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){ 5526 idx = cfg->input_pins[i] - 0x09; 5527 err = new_analog_input(spec, cfg->input_pins[i], 5528 auto_pin_cfg_labels[i], idx, 5529 0x07); 5530 if (err < 0) 5531 return err; 5532 imux->items[imux->num_items].label = 5533 auto_pin_cfg_labels[i]; 5534 imux->items[imux->num_items].index = idx; 5535 imux->num_items++; 5536 } 5537 } 5538 return 0; 5539} 5540 5541static void alc260_auto_set_output_and_unmute(struct hda_codec *codec, 5542 hda_nid_t nid, int pin_type, 5543 int sel_idx) 5544{ 5545 alc_set_pin_output(codec, nid, pin_type); 5546 /* need the manual connection? */ 5547 if (nid >= 0x12) { 5548 int idx = nid - 0x12; 5549 snd_hda_codec_write(codec, idx + 0x0b, 0, 5550 AC_VERB_SET_CONNECT_SEL, sel_idx); 5551 } 5552} 5553 5554static void alc260_auto_init_multi_out(struct hda_codec *codec) 5555{ 5556 struct alc_spec *spec = codec->spec; 5557 hda_nid_t nid; 5558 5559 alc_subsystem_id(codec, 0x10, 0x15, 0x0f); 5560 nid = spec->autocfg.line_out_pins[0]; 5561 if (nid) { 5562 int pin_type = get_pin_type(spec->autocfg.line_out_type); 5563 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0); 5564 } 5565 5566 nid = spec->autocfg.speaker_pins[0]; 5567 if (nid) 5568 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0); 5569 5570 nid = spec->autocfg.hp_pins[0]; 5571 if (nid) 5572 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0); 5573} 5574 5575#define ALC260_PIN_CD_NID 0x16 5576static void alc260_auto_init_analog_input(struct hda_codec *codec) 5577{ 5578 struct alc_spec *spec = codec->spec; 5579 int i; 5580 5581 for (i = 0; i < AUTO_PIN_LAST; i++) { 5582 hda_nid_t nid = spec->autocfg.input_pins[i]; 5583 if (nid >= 0x12) { 5584 snd_hda_codec_write(codec, nid, 0, 5585 AC_VERB_SET_PIN_WIDGET_CONTROL, 5586 i <= AUTO_PIN_FRONT_MIC ? 5587 PIN_VREF80 : PIN_IN); 5588 if (nid != ALC260_PIN_CD_NID) 5589 snd_hda_codec_write(codec, nid, 0, 5590 AC_VERB_SET_AMP_GAIN_MUTE, 5591 AMP_OUT_MUTE); 5592 } 5593 } 5594} 5595 5596/* 5597 * generic initialization of ADC, input mixers and output mixers 5598 */ 5599static struct hda_verb alc260_volume_init_verbs[] = { 5600 /* 5601 * Unmute ADC0-1 and set the default input to mic-in 5602 */ 5603 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00}, 5604 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5605 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00}, 5606 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5607 5608 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 5609 * mixer widget 5610 * Note: PASD motherboards uses the Line In 2 as the input for 5611 * front panel mic (mic 2) 5612 */ 5613 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 5614 /* mute analog inputs */ 5615 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5616 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5617 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5618 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5619 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5620 5621 /* 5622 * Set up output mixers (0x08 - 0x0a) 5623 */ 5624 /* set vol=0 to output mixers */ 5625 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5626 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5627 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5628 /* set up input amps for analog loopback */ 5629 /* Amp Indices: DAC = 0, mixer = 1 */ 5630 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5631 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5632 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5633 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5634 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5635 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5636 5637 { } 5638}; 5639 5640static int alc260_parse_auto_config(struct hda_codec *codec) 5641{ 5642 struct alc_spec *spec = codec->spec; 5643 int err; 5644 static hda_nid_t alc260_ignore[] = { 0x17, 0 }; 5645 5646 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 5647 alc260_ignore); 5648 if (err < 0) 5649 return err; 5650 err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg); 5651 if (err < 0) 5652 return err; 5653 if (!spec->kctls.list) 5654 return 0; /* can't find valid BIOS pin config */ 5655 err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg); 5656 if (err < 0) 5657 return err; 5658 5659 spec->multiout.max_channels = 2; 5660 5661 if (spec->autocfg.dig_outs) 5662 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID; 5663 if (spec->kctls.list) 5664 add_mixer(spec, spec->kctls.list); 5665 5666 add_verb(spec, alc260_volume_init_verbs); 5667 5668 spec->num_mux_defs = 1; 5669 spec->input_mux = &spec->private_imux[0]; 5670 5671 store_pin_configs(codec); 5672 return 1; 5673} 5674 5675/* additional initialization for auto-configuration model */ 5676static void alc260_auto_init(struct hda_codec *codec) 5677{ 5678 struct alc_spec *spec = codec->spec; 5679 alc260_auto_init_multi_out(codec); 5680 alc260_auto_init_analog_input(codec); 5681 if (spec->unsol_event) 5682 alc_inithook(codec); 5683} 5684 5685#ifdef CONFIG_SND_HDA_POWER_SAVE 5686static struct hda_amp_list alc260_loopbacks[] = { 5687 { 0x07, HDA_INPUT, 0 }, 5688 { 0x07, HDA_INPUT, 1 }, 5689 { 0x07, HDA_INPUT, 2 }, 5690 { 0x07, HDA_INPUT, 3 }, 5691 { 0x07, HDA_INPUT, 4 }, 5692 { } /* end */ 5693}; 5694#endif 5695 5696/* 5697 * ALC260 configurations 5698 */ 5699static const char *alc260_models[ALC260_MODEL_LAST] = { 5700 [ALC260_BASIC] = "basic", 5701 [ALC260_HP] = "hp", 5702 [ALC260_HP_3013] = "hp-3013", 5703 [ALC260_HP_DC7600] = "hp-dc7600", 5704 [ALC260_FUJITSU_S702X] = "fujitsu", 5705 [ALC260_ACER] = "acer", 5706 [ALC260_WILL] = "will", 5707 [ALC260_REPLACER_672V] = "replacer", 5708#ifdef CONFIG_SND_DEBUG 5709 [ALC260_TEST] = "test", 5710#endif 5711 [ALC260_AUTO] = "auto", 5712}; 5713 5714static struct snd_pci_quirk alc260_cfg_tbl[] = { 5715 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER), 5716 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER), 5717 SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013), 5718 SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013), 5719 SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013), 5720 SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013), 5721 SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600), 5722 SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013), 5723 SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP), 5724 SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP), 5725 SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP), 5726 SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC), 5727 SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC), 5728 SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC), 5729 SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X), 5730 SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC), 5731 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V), 5732 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL), 5733 {} 5734}; 5735 5736static struct alc_config_preset alc260_presets[] = { 5737 [ALC260_BASIC] = { 5738 .mixers = { alc260_base_output_mixer, 5739 alc260_input_mixer }, 5740 .init_verbs = { alc260_init_verbs }, 5741 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5742 .dac_nids = alc260_dac_nids, 5743 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids), 5744 .adc_nids = alc260_adc_nids, 5745 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5746 .channel_mode = alc260_modes, 5747 .input_mux = &alc260_capture_source, 5748 }, 5749 [ALC260_HP] = { 5750 .mixers = { alc260_hp_output_mixer, 5751 alc260_input_mixer }, 5752 .init_verbs = { alc260_init_verbs, 5753 alc260_hp_unsol_verbs }, 5754 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5755 .dac_nids = alc260_dac_nids, 5756 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt), 5757 .adc_nids = alc260_adc_nids_alt, 5758 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5759 .channel_mode = alc260_modes, 5760 .input_mux = &alc260_capture_source, 5761 .unsol_event = alc260_hp_unsol_event, 5762 .init_hook = alc260_hp_automute, 5763 }, 5764 [ALC260_HP_DC7600] = { 5765 .mixers = { alc260_hp_dc7600_mixer, 5766 alc260_input_mixer }, 5767 .init_verbs = { alc260_init_verbs, 5768 alc260_hp_dc7600_verbs }, 5769 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5770 .dac_nids = alc260_dac_nids, 5771 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt), 5772 .adc_nids = alc260_adc_nids_alt, 5773 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5774 .channel_mode = alc260_modes, 5775 .input_mux = &alc260_capture_source, 5776 .unsol_event = alc260_hp_3012_unsol_event, 5777 .init_hook = alc260_hp_3012_automute, 5778 }, 5779 [ALC260_HP_3013] = { 5780 .mixers = { alc260_hp_3013_mixer, 5781 alc260_input_mixer }, 5782 .init_verbs = { alc260_hp_3013_init_verbs, 5783 alc260_hp_3013_unsol_verbs }, 5784 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5785 .dac_nids = alc260_dac_nids, 5786 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt), 5787 .adc_nids = alc260_adc_nids_alt, 5788 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5789 .channel_mode = alc260_modes, 5790 .input_mux = &alc260_capture_source, 5791 .unsol_event = alc260_hp_3013_unsol_event, 5792 .init_hook = alc260_hp_3013_automute, 5793 }, 5794 [ALC260_FUJITSU_S702X] = { 5795 .mixers = { alc260_fujitsu_mixer }, 5796 .init_verbs = { alc260_fujitsu_init_verbs }, 5797 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5798 .dac_nids = alc260_dac_nids, 5799 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids), 5800 .adc_nids = alc260_dual_adc_nids, 5801 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5802 .channel_mode = alc260_modes, 5803 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources), 5804 .input_mux = alc260_fujitsu_capture_sources, 5805 }, 5806 [ALC260_ACER] = { 5807 .mixers = { alc260_acer_mixer }, 5808 .init_verbs = { alc260_acer_init_verbs }, 5809 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5810 .dac_nids = alc260_dac_nids, 5811 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids), 5812 .adc_nids = alc260_dual_adc_nids, 5813 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5814 .channel_mode = alc260_modes, 5815 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources), 5816 .input_mux = alc260_acer_capture_sources, 5817 }, 5818 [ALC260_WILL] = { 5819 .mixers = { alc260_will_mixer }, 5820 .init_verbs = { alc260_init_verbs, alc260_will_verbs }, 5821 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5822 .dac_nids = alc260_dac_nids, 5823 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids), 5824 .adc_nids = alc260_adc_nids, 5825 .dig_out_nid = ALC260_DIGOUT_NID, 5826 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5827 .channel_mode = alc260_modes, 5828 .input_mux = &alc260_capture_source, 5829 }, 5830 [ALC260_REPLACER_672V] = { 5831 .mixers = { alc260_replacer_672v_mixer }, 5832 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs }, 5833 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5834 .dac_nids = alc260_dac_nids, 5835 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids), 5836 .adc_nids = alc260_adc_nids, 5837 .dig_out_nid = ALC260_DIGOUT_NID, 5838 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5839 .channel_mode = alc260_modes, 5840 .input_mux = &alc260_capture_source, 5841 .unsol_event = alc260_replacer_672v_unsol_event, 5842 .init_hook = alc260_replacer_672v_automute, 5843 }, 5844#ifdef CONFIG_SND_DEBUG 5845 [ALC260_TEST] = { 5846 .mixers = { alc260_test_mixer }, 5847 .init_verbs = { alc260_test_init_verbs }, 5848 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids), 5849 .dac_nids = alc260_test_dac_nids, 5850 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids), 5851 .adc_nids = alc260_test_adc_nids, 5852 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5853 .channel_mode = alc260_modes, 5854 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources), 5855 .input_mux = alc260_test_capture_sources, 5856 }, 5857#endif 5858}; 5859 5860static int patch_alc260(struct hda_codec *codec) 5861{ 5862 struct alc_spec *spec; 5863 int err, board_config; 5864 5865 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5866 if (spec == NULL) 5867 return -ENOMEM; 5868 5869 codec->spec = spec; 5870 5871 board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST, 5872 alc260_models, 5873 alc260_cfg_tbl); 5874 if (board_config < 0) { 5875 snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260, " 5876 "trying auto-probe from BIOS...\n"); 5877 board_config = ALC260_AUTO; 5878 } 5879 5880 if (board_config == ALC260_AUTO) { 5881 /* automatic parse from the BIOS config */ 5882 err = alc260_parse_auto_config(codec); 5883 if (err < 0) { 5884 alc_free(codec); 5885 return err; 5886 } else if (!err) { 5887 printk(KERN_INFO 5888 "hda_codec: Cannot set up configuration " 5889 "from BIOS. Using base mode...\n"); 5890 board_config = ALC260_BASIC; 5891 } 5892 } 5893 5894 err = snd_hda_attach_beep_device(codec, 0x1); 5895 if (err < 0) { 5896 alc_free(codec); 5897 return err; 5898 } 5899 5900 if (board_config != ALC260_AUTO) 5901 setup_preset(spec, &alc260_presets[board_config]); 5902 5903 spec->stream_name_analog = "ALC260 Analog"; 5904 spec->stream_analog_playback = &alc260_pcm_analog_playback; 5905 spec->stream_analog_capture = &alc260_pcm_analog_capture; 5906 5907 spec->stream_name_digital = "ALC260 Digital"; 5908 spec->stream_digital_playback = &alc260_pcm_digital_playback; 5909 spec->stream_digital_capture = &alc260_pcm_digital_capture; 5910 5911 if (!spec->adc_nids && spec->input_mux) { 5912 /* check whether NID 0x04 is valid */ 5913 unsigned int wcap = get_wcaps(codec, 0x04); 5914 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 5915 /* get type */ 5916 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) { 5917 spec->adc_nids = alc260_adc_nids_alt; 5918 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt); 5919 } else { 5920 spec->adc_nids = alc260_adc_nids; 5921 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids); 5922 } 5923 } 5924 set_capture_mixer(spec); 5925 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT); 5926 5927 spec->vmaster_nid = 0x08; 5928 5929 codec->patch_ops = alc_patch_ops; 5930 if (board_config == ALC260_AUTO) 5931 spec->init_hook = alc260_auto_init; 5932#ifdef CONFIG_SND_HDA_POWER_SAVE 5933 if (!spec->loopback.amplist) 5934 spec->loopback.amplist = alc260_loopbacks; 5935#endif 5936 codec->proc_widget_hook = print_realtek_coef; 5937 5938 return 0; 5939} 5940 5941 5942/* 5943 * ALC882 support 5944 * 5945 * ALC882 is almost identical with ALC880 but has cleaner and more flexible 5946 * configuration. Each pin widget can choose any input DACs and a mixer. 5947 * Each ADC is connected from a mixer of all inputs. This makes possible 5948 * 6-channel independent captures. 5949 * 5950 * In addition, an independent DAC for the multi-playback (not used in this 5951 * driver yet). 5952 */ 5953#define ALC882_DIGOUT_NID 0x06 5954#define ALC882_DIGIN_NID 0x0a 5955 5956static struct hda_channel_mode alc882_ch_modes[1] = { 5957 { 8, NULL } 5958}; 5959 5960static hda_nid_t alc882_dac_nids[4] = { 5961 /* front, rear, clfe, rear_surr */ 5962 0x02, 0x03, 0x04, 0x05 5963}; 5964 5965/* identical with ALC880 */ 5966#define alc882_adc_nids alc880_adc_nids 5967#define alc882_adc_nids_alt alc880_adc_nids_alt 5968 5969static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 }; 5970static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 }; 5971 5972/* input MUX */ 5973/* FIXME: should be a matrix-type input source selection */ 5974 5975static struct hda_input_mux alc882_capture_source = { 5976 .num_items = 4, 5977 .items = { 5978 { "Mic", 0x0 }, 5979 { "Front Mic", 0x1 }, 5980 { "Line", 0x2 }, 5981 { "CD", 0x4 }, 5982 }, 5983}; 5984/* 5985 * 2ch mode 5986 */ 5987static struct hda_verb alc882_3ST_ch2_init[] = { 5988 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 5989 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 5990 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 5991 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 5992 { } /* end */ 5993}; 5994 5995/* 5996 * 6ch mode 5997 */ 5998static struct hda_verb alc882_3ST_ch6_init[] = { 5999 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6000 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 6001 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 }, 6002 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6003 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 6004 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 6005 { } /* end */ 6006}; 6007 6008static struct hda_channel_mode alc882_3ST_6ch_modes[2] = { 6009 { 2, alc882_3ST_ch2_init }, 6010 { 6, alc882_3ST_ch6_init }, 6011}; 6012 6013/* 6014 * 6ch mode 6015 */ 6016static struct hda_verb alc882_sixstack_ch6_init[] = { 6017 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 6018 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6019 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6020 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6021 { } /* end */ 6022}; 6023 6024/* 6025 * 8ch mode 6026 */ 6027static struct hda_verb alc882_sixstack_ch8_init[] = { 6028 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6029 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6030 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6031 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6032 { } /* end */ 6033}; 6034 6035static struct hda_channel_mode alc882_sixstack_modes[2] = { 6036 { 6, alc882_sixstack_ch6_init }, 6037 { 8, alc882_sixstack_ch8_init }, 6038}; 6039 6040/* 6041 * macbook pro ALC885 can switch LineIn to LineOut without loosing Mic 6042 */ 6043 6044/* 6045 * 2ch mode 6046 */ 6047static struct hda_verb alc885_mbp_ch2_init[] = { 6048 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 6049 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6050 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6051 { } /* end */ 6052}; 6053 6054/* 6055 * 6ch mode 6056 */ 6057static struct hda_verb alc885_mbp_ch6_init[] = { 6058 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6059 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6060 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 6061 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6062 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6063 { } /* end */ 6064}; 6065 6066static struct hda_channel_mode alc885_mbp_6ch_modes[2] = { 6067 { 2, alc885_mbp_ch2_init }, 6068 { 6, alc885_mbp_ch6_init }, 6069}; 6070 6071 6072/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17 6073 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b 6074 */ 6075static struct snd_kcontrol_new alc882_base_mixer[] = { 6076 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 6077 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 6078 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 6079 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 6080 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 6081 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 6082 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 6083 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 6084 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 6085 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 6086 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 6087 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 6088 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 6089 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 6090 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 6091 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 6092 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 6093 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 6094 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 6095 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 6096 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 6097 { } /* end */ 6098}; 6099 6100static struct snd_kcontrol_new alc885_mbp3_mixer[] = { 6101 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT), 6102 HDA_BIND_MUTE ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT), 6103 HDA_CODEC_MUTE ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT), 6104 HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT), 6105 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 6106 HDA_CODEC_MUTE ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 6107 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT), 6108 HDA_CODEC_MUTE ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT), 6109 HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT), 6110 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT), 6111 { } /* end */ 6112}; 6113static struct snd_kcontrol_new alc882_w2jc_mixer[] = { 6114 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 6115 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 6116 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 6117 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 6118 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 6119 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 6120 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 6121 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 6122 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 6123 { } /* end */ 6124}; 6125 6126static struct snd_kcontrol_new alc882_targa_mixer[] = { 6127 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 6128 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 6129 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 6130 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 6131 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 6132 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 6133 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 6134 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 6135 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 6136 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 6137 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 6138 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 6139 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 6140 { } /* end */ 6141}; 6142 6143/* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ??? 6144 * Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c 6145 */ 6146static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = { 6147 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 6148 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 6149 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 6150 HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT), 6151 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 6152 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 6153 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 6154 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 6155 HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT), 6156 HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT), 6157 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 6158 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 6159 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 6160 { } /* end */ 6161}; 6162 6163static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = { 6164 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 6165 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 6166 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 6167 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 6168 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 6169 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 6170 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 6171 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 6172 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 6173 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 6174 { } /* end */ 6175}; 6176 6177static struct snd_kcontrol_new alc882_chmode_mixer[] = { 6178 { 6179 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6180 .name = "Channel Mode", 6181 .info = alc_ch_mode_info, 6182 .get = alc_ch_mode_get, 6183 .put = alc_ch_mode_put, 6184 }, 6185 { } /* end */ 6186}; 6187 6188static struct hda_verb alc882_init_verbs[] = { 6189 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 6190 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6191 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6192 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6193 /* Rear mixer */ 6194 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6195 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6196 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6197 /* CLFE mixer */ 6198 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6199 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6200 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6201 /* Side mixer */ 6202 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6203 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6204 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6205 6206 /* Front Pin: output 0 (0x0c) */ 6207 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6208 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6209 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 6210 /* Rear Pin: output 1 (0x0d) */ 6211 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6212 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6213 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 6214 /* CLFE Pin: output 2 (0x0e) */ 6215 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6216 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6217 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02}, 6218 /* Side Pin: output 3 (0x0f) */ 6219 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6220 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6221 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 6222 /* Mic (rear) pin: input vref at 80% */ 6223 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 6224 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 6225 /* Front Mic pin: input vref at 80% */ 6226 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 6227 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 6228 /* Line In pin: input */ 6229 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 6230 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 6231 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 6232 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 6233 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6234 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 6235 /* CD pin widget for input */ 6236 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 6237 6238 /* FIXME: use matrix-type input source selection */ 6239 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 6240 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 6241 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6242 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6243 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6244 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6245 /* Input mixer2 */ 6246 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6247 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6248 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6249 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6250 /* Input mixer3 */ 6251 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6252 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6253 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6254 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6255 /* ADC1: mute amp left and right */ 6256 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6257 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 6258 /* ADC2: mute amp left and right */ 6259 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6260 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 6261 /* ADC3: mute amp left and right */ 6262 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6263 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 6264 6265 { } 6266}; 6267 6268static struct hda_verb alc882_eapd_verbs[] = { 6269 /* change to EAPD mode */ 6270 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 6271 {0x20, AC_VERB_SET_PROC_COEF, 0x3060}, 6272 { } 6273}; 6274 6275/* Mac Pro test */ 6276static struct snd_kcontrol_new alc882_macpro_mixer[] = { 6277 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 6278 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 6279 HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT), 6280 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT), 6281 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT), 6282 /* FIXME: this looks suspicious... 6283 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT), 6284 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT), 6285 */ 6286 { } /* end */ 6287}; 6288 6289static struct hda_verb alc882_macpro_init_verbs[] = { 6290 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 6291 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6292 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6293 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6294 /* Front Pin: output 0 (0x0c) */ 6295 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6296 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6297 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 6298 /* Front Mic pin: input vref at 80% */ 6299 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 6300 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 6301 /* Speaker: output */ 6302 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6303 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6304 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04}, 6305 /* Headphone output (output 0 - 0x0c) */ 6306 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 6307 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6308 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00}, 6309 6310 /* FIXME: use matrix-type input source selection */ 6311 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 6312 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 6313 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6314 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6315 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6316 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6317 /* Input mixer2 */ 6318 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6319 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6320 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6321 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6322 /* Input mixer3 */ 6323 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6324 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6325 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6326 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6327 /* ADC1: mute amp left and right */ 6328 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6329 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 6330 /* ADC2: mute amp left and right */ 6331 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6332 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 6333 /* ADC3: mute amp left and right */ 6334 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6335 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 6336 6337 { } 6338}; 6339 6340/* Macbook Pro rev3 */ 6341static struct hda_verb alc885_mbp3_init_verbs[] = { 6342 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 6343 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6344 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6345 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6346 /* Rear mixer */ 6347 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6348 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6349 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6350 /* Front Pin: output 0 (0x0c) */ 6351 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6352 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6353 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 6354 /* HP Pin: output 0 (0x0d) */ 6355 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4}, 6356 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 6357 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 6358 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 6359 /* Mic (rear) pin: input vref at 80% */ 6360 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 6361 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 6362 /* Front Mic pin: input vref at 80% */ 6363 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 6364 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 6365 /* Line In pin: use output 1 when in LineOut mode */ 6366 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 6367 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 6368 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, 6369 6370 /* FIXME: use matrix-type input source selection */ 6371 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 6372 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 6373 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6374 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6375 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6376 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6377 /* Input mixer2 */ 6378 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6379 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6380 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6381 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6382 /* Input mixer3 */ 6383 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6384 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6385 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6386 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6387 /* ADC1: mute amp left and right */ 6388 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6389 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 6390 /* ADC2: mute amp left and right */ 6391 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6392 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 6393 /* ADC3: mute amp left and right */ 6394 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6395 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 6396 6397 { } 6398}; 6399 6400/* iMac 24 mixer. */ 6401static struct snd_kcontrol_new alc885_imac24_mixer[] = { 6402 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT), 6403 HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT), 6404 { } /* end */ 6405}; 6406 6407/* iMac 24 init verbs. */ 6408static struct hda_verb alc885_imac24_init_verbs[] = { 6409 /* Internal speakers: output 0 (0x0c) */ 6410 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6411 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6412 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00}, 6413 /* Internal speakers: output 0 (0x0c) */ 6414 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6415 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6416 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00}, 6417 /* Headphone: output 0 (0x0c) */ 6418 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 6419 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 6420 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 6421 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 6422 /* Front Mic: input vref at 80% */ 6423 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 6424 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 6425 { } 6426}; 6427 6428/* Toggle speaker-output according to the hp-jack state */ 6429static void alc885_imac24_automute(struct hda_codec *codec) 6430{ 6431 unsigned int present; 6432 6433 present = snd_hda_codec_read(codec, 0x14, 0, 6434 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 6435 snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0, 6436 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 6437 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0, 6438 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 6439} 6440 6441/* Processes unsolicited events. */ 6442static void alc885_imac24_unsol_event(struct hda_codec *codec, 6443 unsigned int res) 6444{ 6445 /* Headphone insertion or removal. */ 6446 if ((res >> 26) == ALC880_HP_EVENT) 6447 alc885_imac24_automute(codec); 6448} 6449 6450static void alc885_mbp3_automute(struct hda_codec *codec) 6451{ 6452 unsigned int present; 6453 6454 present = snd_hda_codec_read(codec, 0x15, 0, 6455 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 6456 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 6457 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 6458 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 6459 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE); 6460 6461} 6462static void alc885_mbp3_unsol_event(struct hda_codec *codec, 6463 unsigned int res) 6464{ 6465 /* Headphone insertion or removal. */ 6466 if ((res >> 26) == ALC880_HP_EVENT) 6467 alc885_mbp3_automute(codec); 6468} 6469 6470 6471static struct hda_verb alc882_targa_verbs[] = { 6472 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6473 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6474 6475 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 6476 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6477 6478 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 6479 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */ 6480 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 6481 6482 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 6483 {0x01, AC_VERB_SET_GPIO_MASK, 0x03}, 6484 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03}, 6485 {0x01, AC_VERB_SET_GPIO_DATA, 0x03}, 6486 { } /* end */ 6487}; 6488 6489/* toggle speaker-output according to the hp-jack state */ 6490static void alc882_targa_automute(struct hda_codec *codec) 6491{ 6492 unsigned int present; 6493 6494 present = snd_hda_codec_read(codec, 0x14, 0, 6495 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 6496 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 6497 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 6498 snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA, 6499 present ? 1 : 3); 6500} 6501 6502static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res) 6503{ 6504 /* Looks like the unsol event is incompatible with the standard 6505 * definition. 4bit tag is placed at 26 bit! 6506 */ 6507 if (((res >> 26) == ALC880_HP_EVENT)) { 6508 alc882_targa_automute(codec); 6509 } 6510} 6511 6512static struct hda_verb alc882_asus_a7j_verbs[] = { 6513 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6514 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6515 6516 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 6517 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6518 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6519 6520 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */ 6521 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 6522 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */ 6523 6524 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 6525 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */ 6526 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 6527 { } /* end */ 6528}; 6529 6530static struct hda_verb alc882_asus_a7m_verbs[] = { 6531 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6532 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6533 6534 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 6535 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6536 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6537 6538 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */ 6539 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 6540 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */ 6541 6542 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 6543 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */ 6544 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 6545 { } /* end */ 6546}; 6547 6548static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted) 6549{ 6550 unsigned int gpiostate, gpiomask, gpiodir; 6551 6552 gpiostate = snd_hda_codec_read(codec, codec->afg, 0, 6553 AC_VERB_GET_GPIO_DATA, 0); 6554 6555 if (!muted) 6556 gpiostate |= (1 << pin); 6557 else 6558 gpiostate &= ~(1 << pin); 6559 6560 gpiomask = snd_hda_codec_read(codec, codec->afg, 0, 6561 AC_VERB_GET_GPIO_MASK, 0); 6562 gpiomask |= (1 << pin); 6563 6564 gpiodir = snd_hda_codec_read(codec, codec->afg, 0, 6565 AC_VERB_GET_GPIO_DIRECTION, 0); 6566 gpiodir |= (1 << pin); 6567 6568 6569 snd_hda_codec_write(codec, codec->afg, 0, 6570 AC_VERB_SET_GPIO_MASK, gpiomask); 6571 snd_hda_codec_write(codec, codec->afg, 0, 6572 AC_VERB_SET_GPIO_DIRECTION, gpiodir); 6573 6574 msleep(1); 6575 6576 snd_hda_codec_write(codec, codec->afg, 0, 6577 AC_VERB_SET_GPIO_DATA, gpiostate); 6578} 6579 6580/* set up GPIO at initialization */ 6581static void alc885_macpro_init_hook(struct hda_codec *codec) 6582{ 6583 alc882_gpio_mute(codec, 0, 0); 6584 alc882_gpio_mute(codec, 1, 0); 6585} 6586 6587/* set up GPIO and update auto-muting at initialization */ 6588static void alc885_imac24_init_hook(struct hda_codec *codec) 6589{ 6590 alc885_macpro_init_hook(codec); 6591 alc885_imac24_automute(codec); 6592} 6593 6594/* 6595 * generic initialization of ADC, input mixers and output mixers 6596 */ 6597static struct hda_verb alc882_auto_init_verbs[] = { 6598 /* 6599 * Unmute ADC0-2 and set the default input to mic-in 6600 */ 6601 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 6602 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6603 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 6604 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6605 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 6606 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6607 6608 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 6609 * mixer widget 6610 * Note: PASD motherboards uses the Line In 2 as the input for 6611 * front panel mic (mic 2) 6612 */ 6613 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 6614 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6615 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6616 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6617 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6618 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6619 6620 /* 6621 * Set up output mixers (0x0c - 0x0f) 6622 */ 6623 /* set vol=0 to output mixers */ 6624 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6625 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6626 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6627 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6628 /* set up input amps for analog loopback */ 6629 /* Amp Indices: DAC = 0, mixer = 1 */ 6630 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6631 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6632 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6633 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6634 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6635 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6636 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6637 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6638 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6639 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6640 6641 /* FIXME: use matrix-type input source selection */ 6642 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 6643 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 6644 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 6645 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 6646 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 6647 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 6648 /* Input mixer2 */ 6649 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 6650 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 6651 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 6652 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 6653 /* Input mixer3 */ 6654 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 6655 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 6656 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 6657 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 6658 6659 { } 6660}; 6661 6662#ifdef CONFIG_SND_HDA_POWER_SAVE 6663#define alc882_loopbacks alc880_loopbacks 6664#endif 6665 6666/* pcm configuration: identiacal with ALC880 */ 6667#define alc882_pcm_analog_playback alc880_pcm_analog_playback 6668#define alc882_pcm_analog_capture alc880_pcm_analog_capture 6669#define alc882_pcm_digital_playback alc880_pcm_digital_playback 6670#define alc882_pcm_digital_capture alc880_pcm_digital_capture 6671 6672/* 6673 * configuration and preset 6674 */ 6675static const char *alc882_models[ALC882_MODEL_LAST] = { 6676 [ALC882_3ST_DIG] = "3stack-dig", 6677 [ALC882_6ST_DIG] = "6stack-dig", 6678 [ALC882_ARIMA] = "arima", 6679 [ALC882_W2JC] = "w2jc", 6680 [ALC882_TARGA] = "targa", 6681 [ALC882_ASUS_A7J] = "asus-a7j", 6682 [ALC882_ASUS_A7M] = "asus-a7m", 6683 [ALC885_MACPRO] = "macpro", 6684 [ALC885_MBP3] = "mbp3", 6685 [ALC885_IMAC24] = "imac24", 6686 [ALC882_AUTO] = "auto", 6687}; 6688 6689static struct snd_pci_quirk alc882_cfg_tbl[] = { 6690 SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG), 6691 SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J), 6692 SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J), 6693 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M), 6694 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC), 6695 SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG), 6696 SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG), 6697 SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG), 6698 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG), 6699 SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8 */ 6700 SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG), 6701 SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), 6702 {} 6703}; 6704 6705static struct alc_config_preset alc882_presets[] = { 6706 [ALC882_3ST_DIG] = { 6707 .mixers = { alc882_base_mixer }, 6708 .init_verbs = { alc882_init_verbs }, 6709 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6710 .dac_nids = alc882_dac_nids, 6711 .dig_out_nid = ALC882_DIGOUT_NID, 6712 .dig_in_nid = ALC882_DIGIN_NID, 6713 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes), 6714 .channel_mode = alc882_ch_modes, 6715 .need_dac_fix = 1, 6716 .input_mux = &alc882_capture_source, 6717 }, 6718 [ALC882_6ST_DIG] = { 6719 .mixers = { alc882_base_mixer, alc882_chmode_mixer }, 6720 .init_verbs = { alc882_init_verbs }, 6721 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6722 .dac_nids = alc882_dac_nids, 6723 .dig_out_nid = ALC882_DIGOUT_NID, 6724 .dig_in_nid = ALC882_DIGIN_NID, 6725 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes), 6726 .channel_mode = alc882_sixstack_modes, 6727 .input_mux = &alc882_capture_source, 6728 }, 6729 [ALC882_ARIMA] = { 6730 .mixers = { alc882_base_mixer, alc882_chmode_mixer }, 6731 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs }, 6732 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6733 .dac_nids = alc882_dac_nids, 6734 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes), 6735 .channel_mode = alc882_sixstack_modes, 6736 .input_mux = &alc882_capture_source, 6737 }, 6738 [ALC882_W2JC] = { 6739 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer }, 6740 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs, 6741 alc880_gpio1_init_verbs }, 6742 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6743 .dac_nids = alc882_dac_nids, 6744 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 6745 .channel_mode = alc880_threestack_modes, 6746 .need_dac_fix = 1, 6747 .input_mux = &alc882_capture_source, 6748 .dig_out_nid = ALC882_DIGOUT_NID, 6749 }, 6750 [ALC885_MBP3] = { 6751 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer }, 6752 .init_verbs = { alc885_mbp3_init_verbs, 6753 alc880_gpio1_init_verbs }, 6754 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6755 .dac_nids = alc882_dac_nids, 6756 .channel_mode = alc885_mbp_6ch_modes, 6757 .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes), 6758 .input_mux = &alc882_capture_source, 6759 .dig_out_nid = ALC882_DIGOUT_NID, 6760 .dig_in_nid = ALC882_DIGIN_NID, 6761 .unsol_event = alc885_mbp3_unsol_event, 6762 .init_hook = alc885_mbp3_automute, 6763 }, 6764 [ALC885_MACPRO] = { 6765 .mixers = { alc882_macpro_mixer }, 6766 .init_verbs = { alc882_macpro_init_verbs }, 6767 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6768 .dac_nids = alc882_dac_nids, 6769 .dig_out_nid = ALC882_DIGOUT_NID, 6770 .dig_in_nid = ALC882_DIGIN_NID, 6771 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes), 6772 .channel_mode = alc882_ch_modes, 6773 .input_mux = &alc882_capture_source, 6774 .init_hook = alc885_macpro_init_hook, 6775 }, 6776 [ALC885_IMAC24] = { 6777 .mixers = { alc885_imac24_mixer }, 6778 .init_verbs = { alc885_imac24_init_verbs }, 6779 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6780 .dac_nids = alc882_dac_nids, 6781 .dig_out_nid = ALC882_DIGOUT_NID, 6782 .dig_in_nid = ALC882_DIGIN_NID, 6783 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes), 6784 .channel_mode = alc882_ch_modes, 6785 .input_mux = &alc882_capture_source, 6786 .unsol_event = alc885_imac24_unsol_event, 6787 .init_hook = alc885_imac24_init_hook, 6788 }, 6789 [ALC882_TARGA] = { 6790 .mixers = { alc882_targa_mixer, alc882_chmode_mixer }, 6791 .init_verbs = { alc882_init_verbs, alc882_targa_verbs}, 6792 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6793 .dac_nids = alc882_dac_nids, 6794 .dig_out_nid = ALC882_DIGOUT_NID, 6795 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids), 6796 .adc_nids = alc882_adc_nids, 6797 .capsrc_nids = alc882_capsrc_nids, 6798 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes), 6799 .channel_mode = alc882_3ST_6ch_modes, 6800 .need_dac_fix = 1, 6801 .input_mux = &alc882_capture_source, 6802 .unsol_event = alc882_targa_unsol_event, 6803 .init_hook = alc882_targa_automute, 6804 }, 6805 [ALC882_ASUS_A7J] = { 6806 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer }, 6807 .init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs}, 6808 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6809 .dac_nids = alc882_dac_nids, 6810 .dig_out_nid = ALC882_DIGOUT_NID, 6811 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids), 6812 .adc_nids = alc882_adc_nids, 6813 .capsrc_nids = alc882_capsrc_nids, 6814 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes), 6815 .channel_mode = alc882_3ST_6ch_modes, 6816 .need_dac_fix = 1, 6817 .input_mux = &alc882_capture_source, 6818 }, 6819 [ALC882_ASUS_A7M] = { 6820 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer }, 6821 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs, 6822 alc880_gpio1_init_verbs, 6823 alc882_asus_a7m_verbs }, 6824 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6825 .dac_nids = alc882_dac_nids, 6826 .dig_out_nid = ALC882_DIGOUT_NID, 6827 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 6828 .channel_mode = alc880_threestack_modes, 6829 .need_dac_fix = 1, 6830 .input_mux = &alc882_capture_source, 6831 }, 6832}; 6833 6834 6835/* 6836 * Pin config fixes 6837 */ 6838enum { 6839 PINFIX_ABIT_AW9D_MAX 6840}; 6841 6842static struct alc_pincfg alc882_abit_aw9d_pinfix[] = { 6843 { 0x15, 0x01080104 }, /* side */ 6844 { 0x16, 0x01011012 }, /* rear */ 6845 { 0x17, 0x01016011 }, /* clfe */ 6846 { } 6847}; 6848 6849static const struct alc_pincfg *alc882_pin_fixes[] = { 6850 [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix, 6851}; 6852 6853static struct snd_pci_quirk alc882_pinfix_tbl[] = { 6854 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX), 6855 {} 6856}; 6857 6858/* 6859 * BIOS auto configuration 6860 */ 6861static void alc882_auto_set_output_and_unmute(struct hda_codec *codec, 6862 hda_nid_t nid, int pin_type, 6863 int dac_idx) 6864{ 6865 /* set as output */ 6866 struct alc_spec *spec = codec->spec; 6867 int idx; 6868 6869 alc_set_pin_output(codec, nid, pin_type); 6870 if (spec->multiout.dac_nids[dac_idx] == 0x25) 6871 idx = 4; 6872 else 6873 idx = spec->multiout.dac_nids[dac_idx] - 2; 6874 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx); 6875 6876} 6877 6878static void alc882_auto_init_multi_out(struct hda_codec *codec) 6879{ 6880 struct alc_spec *spec = codec->spec; 6881 int i; 6882 6883 alc_subsystem_id(codec, 0x15, 0x1b, 0x14); 6884 for (i = 0; i <= HDA_SIDE; i++) { 6885 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 6886 int pin_type = get_pin_type(spec->autocfg.line_out_type); 6887 if (nid) 6888 alc882_auto_set_output_and_unmute(codec, nid, pin_type, 6889 i); 6890 } 6891} 6892 6893static void alc882_auto_init_hp_out(struct hda_codec *codec) 6894{ 6895 struct alc_spec *spec = codec->spec; 6896 hda_nid_t pin; 6897 6898 pin = spec->autocfg.hp_pins[0]; 6899 if (pin) /* connect to front */ 6900 /* use dac 0 */ 6901 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 6902 pin = spec->autocfg.speaker_pins[0]; 6903 if (pin) 6904 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 6905} 6906 6907#define alc882_is_input_pin(nid) alc880_is_input_pin(nid) 6908#define ALC882_PIN_CD_NID ALC880_PIN_CD_NID 6909 6910static void alc882_auto_init_analog_input(struct hda_codec *codec) 6911{ 6912 struct alc_spec *spec = codec->spec; 6913 int i; 6914 6915 for (i = 0; i < AUTO_PIN_LAST; i++) { 6916 hda_nid_t nid = spec->autocfg.input_pins[i]; 6917 unsigned int vref; 6918 if (!nid) 6919 continue; 6920 vref = PIN_IN; 6921 if (1 /*i <= AUTO_PIN_FRONT_MIC*/) { 6922 unsigned int pincap; 6923 pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP); 6924 if ((pincap >> AC_PINCAP_VREF_SHIFT) & 6925 AC_PINCAP_VREF_80) 6926 vref = PIN_VREF80; 6927 } 6928 snd_hda_codec_write(codec, nid, 0, 6929 AC_VERB_SET_PIN_WIDGET_CONTROL, vref); 6930 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) 6931 snd_hda_codec_write(codec, nid, 0, 6932 AC_VERB_SET_AMP_GAIN_MUTE, 6933 AMP_OUT_MUTE); 6934 } 6935} 6936 6937static void alc882_auto_init_input_src(struct hda_codec *codec) 6938{ 6939 struct alc_spec *spec = codec->spec; 6940 int c; 6941 6942 for (c = 0; c < spec->num_adc_nids; c++) { 6943 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS]; 6944 hda_nid_t nid = spec->capsrc_nids[c]; 6945 unsigned int mux_idx; 6946 const struct hda_input_mux *imux; 6947 int conns, mute, idx, item; 6948 6949 conns = snd_hda_get_connections(codec, nid, conn_list, 6950 ARRAY_SIZE(conn_list)); 6951 if (conns < 0) 6952 continue; 6953 mux_idx = c >= spec->num_mux_defs ? 0 : c; 6954 imux = &spec->input_mux[mux_idx]; 6955 for (idx = 0; idx < conns; idx++) { 6956 /* if the current connection is the selected one, 6957 * unmute it as default - otherwise mute it 6958 */ 6959 mute = AMP_IN_MUTE(idx); 6960 for (item = 0; item < imux->num_items; item++) { 6961 if (imux->items[item].index == idx) { 6962 if (spec->cur_mux[c] == item) 6963 mute = AMP_IN_UNMUTE(idx); 6964 break; 6965 } 6966 } 6967 /* check if we have a selector or mixer 6968 * we could check for the widget type instead, but 6969 * just check for Amp-In presence (in case of mixer 6970 * without amp-in there is something wrong, this 6971 * function shouldn't be used or capsrc nid is wrong) 6972 */ 6973 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) 6974 snd_hda_codec_write(codec, nid, 0, 6975 AC_VERB_SET_AMP_GAIN_MUTE, 6976 mute); 6977 else if (mute != AMP_IN_MUTE(idx)) 6978 snd_hda_codec_write(codec, nid, 0, 6979 AC_VERB_SET_CONNECT_SEL, 6980 idx); 6981 } 6982 } 6983} 6984 6985/* add mic boosts if needed */ 6986static int alc_auto_add_mic_boost(struct hda_codec *codec) 6987{ 6988 struct alc_spec *spec = codec->spec; 6989 int err; 6990 hda_nid_t nid; 6991 6992 nid = spec->autocfg.input_pins[AUTO_PIN_MIC]; 6993 if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) { 6994 err = add_control(spec, ALC_CTL_WIDGET_VOL, 6995 "Mic Boost", 6996 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT)); 6997 if (err < 0) 6998 return err; 6999 } 7000 nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC]; 7001 if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) { 7002 err = add_control(spec, ALC_CTL_WIDGET_VOL, 7003 "Front Mic Boost", 7004 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT)); 7005 if (err < 0) 7006 return err; 7007 } 7008 return 0; 7009} 7010 7011/* almost identical with ALC880 parser... */ 7012static int alc882_parse_auto_config(struct hda_codec *codec) 7013{ 7014 struct alc_spec *spec = codec->spec; 7015 int err = alc880_parse_auto_config(codec); 7016 7017 if (err < 0) 7018 return err; 7019 else if (!err) 7020 return 0; /* no config found */ 7021 7022 err = alc_auto_add_mic_boost(codec); 7023 if (err < 0) 7024 return err; 7025 7026 /* hack - override the init verbs */ 7027 spec->init_verbs[0] = alc882_auto_init_verbs; 7028 7029 return 1; /* config found */ 7030} 7031 7032/* additional initialization for auto-configuration model */ 7033static void alc882_auto_init(struct hda_codec *codec) 7034{ 7035 struct alc_spec *spec = codec->spec; 7036 alc882_auto_init_multi_out(codec); 7037 alc882_auto_init_hp_out(codec); 7038 alc882_auto_init_analog_input(codec); 7039 alc882_auto_init_input_src(codec); 7040 if (spec->unsol_event) 7041 alc_inithook(codec); 7042} 7043 7044static int patch_alc883(struct hda_codec *codec); /* called in patch_alc882() */ 7045 7046static int patch_alc882(struct hda_codec *codec) 7047{ 7048 struct alc_spec *spec; 7049 int err, board_config; 7050 7051 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 7052 if (spec == NULL) 7053 return -ENOMEM; 7054 7055 codec->spec = spec; 7056 7057 board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST, 7058 alc882_models, 7059 alc882_cfg_tbl); 7060 7061 if (board_config < 0 || board_config >= ALC882_MODEL_LAST) { 7062 /* Pick up systems that don't supply PCI SSID */ 7063 switch (codec->subsystem_id) { 7064 case 0x106b0c00: /* Mac Pro */ 7065 board_config = ALC885_MACPRO; 7066 break; 7067 case 0x106b1000: /* iMac 24 */ 7068 case 0x106b2800: /* AppleTV */ 7069 case 0x106b3e00: /* iMac 24 Aluminium */ 7070 board_config = ALC885_IMAC24; 7071 break; 7072 case 0x106b00a1: /* Macbook (might be wrong - PCI SSID?) */ 7073 case 0x106b00a4: /* MacbookPro4,1 */ 7074 case 0x106b2c00: /* Macbook Pro rev3 */ 7075 case 0x106b3600: /* Macbook 3.1 */ 7076 case 0x106b3800: /* MacbookPro4,1 - latter revision */ 7077 board_config = ALC885_MBP3; 7078 break; 7079 default: 7080 /* ALC889A is handled better as ALC888-compatible */ 7081 if (codec->revision_id == 0x100101 || 7082 codec->revision_id == 0x100103) { 7083 alc_free(codec); 7084 return patch_alc883(codec); 7085 } 7086 printk(KERN_INFO "hda_codec: Unknown model for ALC882, " 7087 "trying auto-probe from BIOS...\n"); 7088 board_config = ALC882_AUTO; 7089 } 7090 } 7091 7092 alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes); 7093 7094 if (board_config == ALC882_AUTO) { 7095 /* automatic parse from the BIOS config */ 7096 err = alc882_parse_auto_config(codec); 7097 if (err < 0) { 7098 alc_free(codec); 7099 return err; 7100 } else if (!err) { 7101 printk(KERN_INFO 7102 "hda_codec: Cannot set up configuration " 7103 "from BIOS. Using base mode...\n"); 7104 board_config = ALC882_3ST_DIG; 7105 } 7106 } 7107 7108 err = snd_hda_attach_beep_device(codec, 0x1); 7109 if (err < 0) { 7110 alc_free(codec); 7111 return err; 7112 } 7113 7114 if (board_config != ALC882_AUTO) 7115 setup_preset(spec, &alc882_presets[board_config]); 7116 7117 if (codec->vendor_id == 0x10ec0885) { 7118 spec->stream_name_analog = "ALC885 Analog"; 7119 spec->stream_name_digital = "ALC885 Digital"; 7120 } else { 7121 spec->stream_name_analog = "ALC882 Analog"; 7122 spec->stream_name_digital = "ALC882 Digital"; 7123 } 7124 7125 spec->stream_analog_playback = &alc882_pcm_analog_playback; 7126 spec->stream_analog_capture = &alc882_pcm_analog_capture; 7127 /* FIXME: setup DAC5 */ 7128 /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/ 7129 spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture; 7130 7131 spec->stream_digital_playback = &alc882_pcm_digital_playback; 7132 spec->stream_digital_capture = &alc882_pcm_digital_capture; 7133 7134 spec->capture_style = CAPT_MIX; /* matrix-style capture */ 7135 if (!spec->adc_nids && spec->input_mux) { 7136 /* check whether NID 0x07 is valid */ 7137 unsigned int wcap = get_wcaps(codec, 0x07); 7138 /* get type */ 7139 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 7140 if (wcap != AC_WID_AUD_IN) { 7141 spec->adc_nids = alc882_adc_nids_alt; 7142 spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt); 7143 spec->capsrc_nids = alc882_capsrc_nids_alt; 7144 } else { 7145 spec->adc_nids = alc882_adc_nids; 7146 spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids); 7147 spec->capsrc_nids = alc882_capsrc_nids; 7148 } 7149 } 7150 set_capture_mixer(spec); 7151 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 7152 7153 spec->vmaster_nid = 0x0c; 7154 7155 codec->patch_ops = alc_patch_ops; 7156 if (board_config == ALC882_AUTO) 7157 spec->init_hook = alc882_auto_init; 7158#ifdef CONFIG_SND_HDA_POWER_SAVE 7159 if (!spec->loopback.amplist) 7160 spec->loopback.amplist = alc882_loopbacks; 7161#endif 7162 codec->proc_widget_hook = print_realtek_coef; 7163 7164 return 0; 7165} 7166 7167/* 7168 * ALC883 support 7169 * 7170 * ALC883 is almost identical with ALC880 but has cleaner and more flexible 7171 * configuration. Each pin widget can choose any input DACs and a mixer. 7172 * Each ADC is connected from a mixer of all inputs. This makes possible 7173 * 6-channel independent captures. 7174 * 7175 * In addition, an independent DAC for the multi-playback (not used in this 7176 * driver yet). 7177 */ 7178#define ALC883_DIGOUT_NID 0x06 7179#define ALC883_DIGIN_NID 0x0a 7180 7181#define ALC1200_DIGOUT_NID 0x10 7182 7183static hda_nid_t alc883_dac_nids[4] = { 7184 /* front, rear, clfe, rear_surr */ 7185 0x02, 0x03, 0x04, 0x05 7186}; 7187 7188static hda_nid_t alc883_adc_nids[2] = { 7189 /* ADC1-2 */ 7190 0x08, 0x09, 7191}; 7192 7193static hda_nid_t alc883_adc_nids_alt[1] = { 7194 /* ADC1 */ 7195 0x08, 7196}; 7197 7198static hda_nid_t alc883_adc_nids_rev[2] = { 7199 /* ADC2-1 */ 7200 0x09, 0x08 7201}; 7202 7203#define alc889_adc_nids alc880_adc_nids 7204 7205static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 }; 7206 7207static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 }; 7208 7209#define alc889_capsrc_nids alc882_capsrc_nids 7210 7211/* input MUX */ 7212/* FIXME: should be a matrix-type input source selection */ 7213 7214static struct hda_input_mux alc883_capture_source = { 7215 .num_items = 4, 7216 .items = { 7217 { "Mic", 0x0 }, 7218 { "Front Mic", 0x1 }, 7219 { "Line", 0x2 }, 7220 { "CD", 0x4 }, 7221 }, 7222}; 7223 7224static struct hda_input_mux alc883_3stack_6ch_intel = { 7225 .num_items = 4, 7226 .items = { 7227 { "Mic", 0x1 }, 7228 { "Front Mic", 0x0 }, 7229 { "Line", 0x2 }, 7230 { "CD", 0x4 }, 7231 }, 7232}; 7233 7234static struct hda_input_mux alc883_lenovo_101e_capture_source = { 7235 .num_items = 2, 7236 .items = { 7237 { "Mic", 0x1 }, 7238 { "Line", 0x2 }, 7239 }, 7240}; 7241 7242static struct hda_input_mux alc883_lenovo_nb0763_capture_source = { 7243 .num_items = 4, 7244 .items = { 7245 { "Mic", 0x0 }, 7246 { "iMic", 0x1 }, 7247 { "Line", 0x2 }, 7248 { "CD", 0x4 }, 7249 }, 7250}; 7251 7252static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = { 7253 .num_items = 2, 7254 .items = { 7255 { "Mic", 0x0 }, 7256 { "Int Mic", 0x1 }, 7257 }, 7258}; 7259 7260static struct hda_input_mux alc883_lenovo_sky_capture_source = { 7261 .num_items = 3, 7262 .items = { 7263 { "Mic", 0x0 }, 7264 { "Front Mic", 0x1 }, 7265 { "Line", 0x4 }, 7266 }, 7267}; 7268 7269static struct hda_input_mux alc883_asus_eee1601_capture_source = { 7270 .num_items = 2, 7271 .items = { 7272 { "Mic", 0x0 }, 7273 { "Line", 0x2 }, 7274 }, 7275}; 7276 7277/* 7278 * 2ch mode 7279 */ 7280static struct hda_channel_mode alc883_3ST_2ch_modes[1] = { 7281 { 2, NULL } 7282}; 7283 7284/* 7285 * 2ch mode 7286 */ 7287static struct hda_verb alc883_3ST_ch2_init[] = { 7288 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 7289 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7290 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 7291 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7292 { } /* end */ 7293}; 7294 7295/* 7296 * 4ch mode 7297 */ 7298static struct hda_verb alc883_3ST_ch4_init[] = { 7299 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 7300 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7301 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7302 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7303 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 7304 { } /* end */ 7305}; 7306 7307/* 7308 * 6ch mode 7309 */ 7310static struct hda_verb alc883_3ST_ch6_init[] = { 7311 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7312 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7313 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 }, 7314 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7315 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7316 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 7317 { } /* end */ 7318}; 7319 7320static struct hda_channel_mode alc883_3ST_6ch_modes[3] = { 7321 { 2, alc883_3ST_ch2_init }, 7322 { 4, alc883_3ST_ch4_init }, 7323 { 6, alc883_3ST_ch6_init }, 7324}; 7325 7326/* 7327 * 2ch mode 7328 */ 7329static struct hda_verb alc883_3ST_ch2_intel_init[] = { 7330 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 7331 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7332 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 7333 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7334 { } /* end */ 7335}; 7336 7337/* 7338 * 4ch mode 7339 */ 7340static struct hda_verb alc883_3ST_ch4_intel_init[] = { 7341 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 7342 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7343 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7344 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7345 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 7346 { } /* end */ 7347}; 7348 7349/* 7350 * 6ch mode 7351 */ 7352static struct hda_verb alc883_3ST_ch6_intel_init[] = { 7353 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7354 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7355 { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 }, 7356 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7357 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7358 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 7359 { } /* end */ 7360}; 7361 7362static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = { 7363 { 2, alc883_3ST_ch2_intel_init }, 7364 { 4, alc883_3ST_ch4_intel_init }, 7365 { 6, alc883_3ST_ch6_intel_init }, 7366}; 7367 7368/* 7369 * 6ch mode 7370 */ 7371static struct hda_verb alc883_sixstack_ch6_init[] = { 7372 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 7373 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7374 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7375 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7376 { } /* end */ 7377}; 7378 7379/* 7380 * 8ch mode 7381 */ 7382static struct hda_verb alc883_sixstack_ch8_init[] = { 7383 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7384 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7385 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7386 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7387 { } /* end */ 7388}; 7389 7390static struct hda_channel_mode alc883_sixstack_modes[2] = { 7391 { 6, alc883_sixstack_ch6_init }, 7392 { 8, alc883_sixstack_ch8_init }, 7393}; 7394 7395static struct hda_verb alc883_medion_eapd_verbs[] = { 7396 /* eanable EAPD on medion laptop */ 7397 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 7398 {0x20, AC_VERB_SET_PROC_COEF, 0x3070}, 7399 { } 7400}; 7401 7402/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17 7403 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b 7404 */ 7405 7406static struct snd_kcontrol_new alc883_base_mixer[] = { 7407 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7408 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7409 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7410 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 7411 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 7412 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 7413 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 7414 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 7415 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 7416 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 7417 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7418 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7419 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7420 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7421 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7422 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7423 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7424 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7425 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7426 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 7427 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7428 { } /* end */ 7429}; 7430 7431static struct snd_kcontrol_new alc883_mitac_mixer[] = { 7432 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7433 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7434 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 7435 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 7436 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 7437 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 7438 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 7439 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7440 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7441 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7442 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7443 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 7444 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7445 { } /* end */ 7446}; 7447 7448static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = { 7449 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7450 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 7451 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7452 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 7453 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7454 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7455 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7456 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7457 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 7458 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7459 { } /* end */ 7460}; 7461 7462static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = { 7463 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7464 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 7465 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7466 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 7467 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7468 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7469 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7470 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7471 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 7472 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7473 { } /* end */ 7474}; 7475 7476static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = { 7477 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7478 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7479 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7480 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7481 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7482 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7483 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7484 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7485 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7486 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7487 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7488 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 7489 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7490 { } /* end */ 7491}; 7492 7493static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = { 7494 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7495 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7496 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7497 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 7498 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 7499 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 7500 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 7501 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 7502 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7503 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7504 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7505 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7506 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7507 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7508 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7509 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7510 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7511 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 7512 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7513 { } /* end */ 7514}; 7515 7516static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = { 7517 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7518 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7519 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7520 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 7521 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, 7522 HDA_OUTPUT), 7523 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 7524 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 7525 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 7526 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 7527 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7528 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7529 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7530 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7531 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7532 HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT), 7533 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7534 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7535 HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT), 7536 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7537 { } /* end */ 7538}; 7539 7540static struct snd_kcontrol_new alc883_fivestack_mixer[] = { 7541 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7542 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7543 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7544 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 7545 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 7546 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 7547 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 7548 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 7549 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7550 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7551 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7552 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7553 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7554 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7555 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7556 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7557 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7558 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 7559 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7560 { } /* end */ 7561}; 7562 7563static struct snd_kcontrol_new alc883_tagra_mixer[] = { 7564 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7565 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 7566 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7567 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7568 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 7569 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 7570 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 7571 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 7572 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 7573 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7574 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7575 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7576 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7577 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7578 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7579 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7580 { } /* end */ 7581}; 7582 7583static struct snd_kcontrol_new alc883_tagra_2ch_mixer[] = { 7584 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7585 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 7586 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7587 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7588 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7589 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7590 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7591 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7592 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7593 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 7594 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7595 { } /* end */ 7596}; 7597 7598static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = { 7599 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7600 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7601 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7602 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 7603 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7604 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7605 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7606 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7607 { } /* end */ 7608}; 7609 7610static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = { 7611 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7612 HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT), 7613 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 7614 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7615 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7616 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7617 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7618 HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7619 HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7620 { } /* end */ 7621}; 7622 7623static struct snd_kcontrol_new alc883_medion_md2_mixer[] = { 7624 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7625 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 7626 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT), 7627 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7628 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7629 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7630 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7631 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7632 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7633 { } /* end */ 7634}; 7635 7636static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = { 7637 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7638 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7639 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 7640 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7641 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7642 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7643 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7644 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7645 { } /* end */ 7646}; 7647 7648static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = { 7649 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7650 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7651 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT), 7652 HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT), 7653 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 7654 0x0d, 1, 0x0, HDA_OUTPUT), 7655 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT), 7656 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT), 7657 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT), 7658 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 7659 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 7660 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7661 HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x1a, 0x0, HDA_OUTPUT), 7662 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7663 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7664 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7665 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7666 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7667 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7668 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7669 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7670 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 7671 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7672 { } /* end */ 7673}; 7674 7675static struct hda_bind_ctls alc883_bind_cap_vol = { 7676 .ops = &snd_hda_bind_vol, 7677 .values = { 7678 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT), 7679 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT), 7680 0 7681 }, 7682}; 7683 7684static struct hda_bind_ctls alc883_bind_cap_switch = { 7685 .ops = &snd_hda_bind_sw, 7686 .values = { 7687 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT), 7688 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT), 7689 0 7690 }, 7691}; 7692 7693static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = { 7694 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7695 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7696 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 7697 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7698 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7699 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7700 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7701 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7702 { } /* end */ 7703}; 7704 7705static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = { 7706 HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol), 7707 HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch), 7708 { 7709 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7710 /* .name = "Capture Source", */ 7711 .name = "Input Source", 7712 .count = 1, 7713 .info = alc_mux_enum_info, 7714 .get = alc_mux_enum_get, 7715 .put = alc_mux_enum_put, 7716 }, 7717 { } /* end */ 7718}; 7719 7720static struct snd_kcontrol_new alc883_chmode_mixer[] = { 7721 { 7722 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7723 .name = "Channel Mode", 7724 .info = alc_ch_mode_info, 7725 .get = alc_ch_mode_get, 7726 .put = alc_ch_mode_put, 7727 }, 7728 { } /* end */ 7729}; 7730 7731static struct hda_verb alc883_init_verbs[] = { 7732 /* ADC1: mute amp left and right */ 7733 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7734 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 7735 /* ADC2: mute amp left and right */ 7736 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7737 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 7738 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 7739 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7740 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7741 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7742 /* Rear mixer */ 7743 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7744 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7745 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7746 /* CLFE mixer */ 7747 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7748 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7749 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7750 /* Side mixer */ 7751 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7752 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7753 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7754 7755 /* mute analog input loopbacks */ 7756 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7757 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7758 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 7759 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 7760 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 7761 7762 /* Front Pin: output 0 (0x0c) */ 7763 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7764 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7765 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 7766 /* Rear Pin: output 1 (0x0d) */ 7767 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7768 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7769 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 7770 /* CLFE Pin: output 2 (0x0e) */ 7771 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7772 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7773 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02}, 7774 /* Side Pin: output 3 (0x0f) */ 7775 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7776 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7777 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 7778 /* Mic (rear) pin: input vref at 80% */ 7779 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 7780 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 7781 /* Front Mic pin: input vref at 80% */ 7782 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 7783 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 7784 /* Line In pin: input */ 7785 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 7786 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 7787 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 7788 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7789 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7790 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 7791 /* CD pin widget for input */ 7792 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 7793 7794 /* FIXME: use matrix-type input source selection */ 7795 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 7796 /* Input mixer2 */ 7797 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7798 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7799 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 7800 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 7801 /* Input mixer3 */ 7802 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7803 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7804 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 7805 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 7806 { } 7807}; 7808 7809/* toggle speaker-output according to the hp-jack state */ 7810static void alc883_mitac_hp_automute(struct hda_codec *codec) 7811{ 7812 unsigned int present; 7813 7814 present = snd_hda_codec_read(codec, 0x15, 0, 7815 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7816 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 7817 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7818 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0, 7819 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7820} 7821 7822/* auto-toggle front mic */ 7823/* 7824static void alc883_mitac_mic_automute(struct hda_codec *codec) 7825{ 7826 unsigned int present; 7827 unsigned char bits; 7828 7829 present = snd_hda_codec_read(codec, 0x18, 0, 7830 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7831 bits = present ? HDA_AMP_MUTE : 0; 7832 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits); 7833} 7834*/ 7835 7836static void alc883_mitac_automute(struct hda_codec *codec) 7837{ 7838 alc883_mitac_hp_automute(codec); 7839 /* alc883_mitac_mic_automute(codec); */ 7840} 7841 7842static void alc883_mitac_unsol_event(struct hda_codec *codec, 7843 unsigned int res) 7844{ 7845 switch (res >> 26) { 7846 case ALC880_HP_EVENT: 7847 alc883_mitac_hp_automute(codec); 7848 break; 7849 case ALC880_MIC_EVENT: 7850 /* alc883_mitac_mic_automute(codec); */ 7851 break; 7852 } 7853} 7854 7855static struct hda_verb alc883_mitac_verbs[] = { 7856 /* HP */ 7857 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 7858 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7859 /* Subwoofer */ 7860 {0x17, AC_VERB_SET_CONNECT_SEL, 0x02}, 7861 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7862 7863 /* enable unsolicited event */ 7864 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7865 /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */ 7866 7867 { } /* end */ 7868}; 7869 7870static struct hda_verb alc883_clevo_m720_verbs[] = { 7871 /* HP */ 7872 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 7873 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7874 /* Int speaker */ 7875 {0x14, AC_VERB_SET_CONNECT_SEL, 0x01}, 7876 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7877 7878 /* enable unsolicited event */ 7879 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7880 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, 7881 7882 { } /* end */ 7883}; 7884 7885static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = { 7886 /* HP */ 7887 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 7888 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7889 /* Subwoofer */ 7890 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 7891 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7892 7893 /* enable unsolicited event */ 7894 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7895 7896 { } /* end */ 7897}; 7898 7899static struct hda_verb alc883_tagra_verbs[] = { 7900 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7901 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7902 7903 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7904 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7905 7906 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 7907 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */ 7908 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 7909 7910 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7911 {0x01, AC_VERB_SET_GPIO_MASK, 0x03}, 7912 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03}, 7913 {0x01, AC_VERB_SET_GPIO_DATA, 0x03}, 7914 7915 { } /* end */ 7916}; 7917 7918static struct hda_verb alc883_lenovo_101e_verbs[] = { 7919 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 7920 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN}, 7921 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN}, 7922 { } /* end */ 7923}; 7924 7925static struct hda_verb alc883_lenovo_nb0763_verbs[] = { 7926 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 7927 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7928 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7929 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7930 { } /* end */ 7931}; 7932 7933static struct hda_verb alc888_lenovo_ms7195_verbs[] = { 7934 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7935 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7936 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 7937 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN}, 7938 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7939 { } /* end */ 7940}; 7941 7942static struct hda_verb alc883_haier_w66_verbs[] = { 7943 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7944 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7945 7946 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7947 7948 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 7949 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7950 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7951 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7952 { } /* end */ 7953}; 7954 7955static struct hda_verb alc888_lenovo_sky_verbs[] = { 7956 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7957 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7958 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7959 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7960 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7961 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7962 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00}, 7963 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7964 { } /* end */ 7965}; 7966 7967static struct hda_verb alc888_3st_hp_verbs[] = { 7968 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front: output 0 (0x0c) */ 7969 {0x16, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Rear : output 1 (0x0d) */ 7970 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* CLFE : output 2 (0x0e) */ 7971 { } 7972}; 7973 7974static struct hda_verb alc888_6st_dell_verbs[] = { 7975 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7976 { } 7977}; 7978 7979static struct hda_verb alc888_3st_hp_2ch_init[] = { 7980 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 7981 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7982 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 7983 { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7984 { } 7985}; 7986 7987static struct hda_verb alc888_3st_hp_6ch_init[] = { 7988 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7989 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7990 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7991 { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7992 { } 7993}; 7994 7995static struct hda_channel_mode alc888_3st_hp_modes[2] = { 7996 { 2, alc888_3st_hp_2ch_init }, 7997 { 6, alc888_3st_hp_6ch_init }, 7998}; 7999 8000/* toggle front-jack and RCA according to the hp-jack state */ 8001static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec) 8002{ 8003 unsigned int present; 8004 8005 present = snd_hda_codec_read(codec, 0x1b, 0, 8006 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 8007 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 8008 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 8009 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 8010 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 8011} 8012 8013/* toggle RCA according to the front-jack state */ 8014static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec) 8015{ 8016 unsigned int present; 8017 8018 present = snd_hda_codec_read(codec, 0x14, 0, 8019 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 8020 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 8021 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 8022} 8023 8024static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec, 8025 unsigned int res) 8026{ 8027 if ((res >> 26) == ALC880_HP_EVENT) 8028 alc888_lenovo_ms7195_front_automute(codec); 8029 if ((res >> 26) == ALC880_FRONT_EVENT) 8030 alc888_lenovo_ms7195_rca_automute(codec); 8031} 8032 8033static struct hda_verb alc883_medion_md2_verbs[] = { 8034 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8035 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8036 8037 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8038 8039 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 8040 { } /* end */ 8041}; 8042 8043/* toggle speaker-output according to the hp-jack state */ 8044static void alc883_medion_md2_automute(struct hda_codec *codec) 8045{ 8046 unsigned int present; 8047 8048 present = snd_hda_codec_read(codec, 0x14, 0, 8049 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 8050 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 8051 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 8052} 8053 8054static void alc883_medion_md2_unsol_event(struct hda_codec *codec, 8055 unsigned int res) 8056{ 8057 if ((res >> 26) == ALC880_HP_EVENT) 8058 alc883_medion_md2_automute(codec); 8059} 8060 8061/* toggle speaker-output according to the hp-jack state */ 8062static void alc883_tagra_automute(struct hda_codec *codec) 8063{ 8064 unsigned int present; 8065 unsigned char bits; 8066 8067 present = snd_hda_codec_read(codec, 0x14, 0, 8068 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 8069 bits = present ? HDA_AMP_MUTE : 0; 8070 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 8071 HDA_AMP_MUTE, bits); 8072 snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA, 8073 present ? 1 : 3); 8074} 8075 8076static void alc883_tagra_unsol_event(struct hda_codec *codec, unsigned int res) 8077{ 8078 if ((res >> 26) == ALC880_HP_EVENT) 8079 alc883_tagra_automute(codec); 8080} 8081 8082/* toggle speaker-output according to the hp-jack state */ 8083static void alc883_clevo_m720_hp_automute(struct hda_codec *codec) 8084{ 8085 unsigned int present; 8086 unsigned char bits; 8087 8088 present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0) 8089 & AC_PINSENSE_PRESENCE; 8090 bits = present ? HDA_AMP_MUTE : 0; 8091 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 8092 HDA_AMP_MUTE, bits); 8093} 8094 8095static void alc883_clevo_m720_mic_automute(struct hda_codec *codec) 8096{ 8097 unsigned int present; 8098 8099 present = snd_hda_codec_read(codec, 0x18, 0, 8100 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 8101 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, 8102 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 8103} 8104 8105static void alc883_clevo_m720_automute(struct hda_codec *codec) 8106{ 8107 alc883_clevo_m720_hp_automute(codec); 8108 alc883_clevo_m720_mic_automute(codec); 8109} 8110 8111static void alc883_clevo_m720_unsol_event(struct hda_codec *codec, 8112 unsigned int res) 8113{ 8114 switch (res >> 26) { 8115 case ALC880_HP_EVENT: 8116 alc883_clevo_m720_hp_automute(codec); 8117 break; 8118 case ALC880_MIC_EVENT: 8119 alc883_clevo_m720_mic_automute(codec); 8120 break; 8121 } 8122} 8123 8124/* toggle speaker-output according to the hp-jack state */ 8125static void alc883_2ch_fujitsu_pi2515_automute(struct hda_codec *codec) 8126{ 8127 unsigned int present; 8128 unsigned char bits; 8129 8130 present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0) 8131 & AC_PINSENSE_PRESENCE; 8132 bits = present ? HDA_AMP_MUTE : 0; 8133 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 8134 HDA_AMP_MUTE, bits); 8135} 8136 8137static void alc883_2ch_fujitsu_pi2515_unsol_event(struct hda_codec *codec, 8138 unsigned int res) 8139{ 8140 if ((res >> 26) == ALC880_HP_EVENT) 8141 alc883_2ch_fujitsu_pi2515_automute(codec); 8142} 8143 8144static void alc883_haier_w66_automute(struct hda_codec *codec) 8145{ 8146 unsigned int present; 8147 unsigned char bits; 8148 8149 present = snd_hda_codec_read(codec, 0x1b, 0, 8150 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 8151 bits = present ? 0x80 : 0; 8152 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 8153 0x80, bits); 8154} 8155 8156static void alc883_haier_w66_unsol_event(struct hda_codec *codec, 8157 unsigned int res) 8158{ 8159 if ((res >> 26) == ALC880_HP_EVENT) 8160 alc883_haier_w66_automute(codec); 8161} 8162 8163static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec) 8164{ 8165 unsigned int present; 8166 unsigned char bits; 8167 8168 present = snd_hda_codec_read(codec, 0x14, 0, 8169 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 8170 bits = present ? HDA_AMP_MUTE : 0; 8171 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 8172 HDA_AMP_MUTE, bits); 8173} 8174 8175static void alc883_lenovo_101e_all_automute(struct hda_codec *codec) 8176{ 8177 unsigned int present; 8178 unsigned char bits; 8179 8180 present = snd_hda_codec_read(codec, 0x1b, 0, 8181 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 8182 bits = present ? HDA_AMP_MUTE : 0; 8183 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 8184 HDA_AMP_MUTE, bits); 8185 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 8186 HDA_AMP_MUTE, bits); 8187} 8188 8189static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec, 8190 unsigned int res) 8191{ 8192 if ((res >> 26) == ALC880_HP_EVENT) 8193 alc883_lenovo_101e_all_automute(codec); 8194 if ((res >> 26) == ALC880_FRONT_EVENT) 8195 alc883_lenovo_101e_ispeaker_automute(codec); 8196} 8197 8198/* toggle speaker-output according to the hp-jack state */ 8199static void alc883_acer_aspire_automute(struct hda_codec *codec) 8200{ 8201 unsigned int present; 8202 8203 present = snd_hda_codec_read(codec, 0x14, 0, 8204 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 8205 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 8206 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 8207 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 8208 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 8209} 8210 8211static void alc883_acer_aspire_unsol_event(struct hda_codec *codec, 8212 unsigned int res) 8213{ 8214 if ((res >> 26) == ALC880_HP_EVENT) 8215 alc883_acer_aspire_automute(codec); 8216} 8217 8218static struct hda_verb alc883_acer_eapd_verbs[] = { 8219 /* HP Pin: output 0 (0x0c) */ 8220 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8221 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8222 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 8223 /* Front Pin: output 0 (0x0c) */ 8224 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8225 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 8226 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8227 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, 8228 /* eanable EAPD on medion laptop */ 8229 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 8230 {0x20, AC_VERB_SET_PROC_COEF, 0x3050}, 8231 /* enable unsolicited event */ 8232 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 8233 { } 8234}; 8235 8236static void alc888_6st_dell_front_automute(struct hda_codec *codec) 8237{ 8238 unsigned int present; 8239 8240 present = snd_hda_codec_read(codec, 0x1b, 0, 8241 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 8242 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 8243 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 8244 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 8245 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 8246 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 8247 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 8248 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0, 8249 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 8250} 8251 8252static void alc888_6st_dell_unsol_event(struct hda_codec *codec, 8253 unsigned int res) 8254{ 8255 switch (res >> 26) { 8256 case ALC880_HP_EVENT: 8257 /* printk(KERN_DEBUG "hp_event\n"); */ 8258 alc888_6st_dell_front_automute(codec); 8259 break; 8260 } 8261} 8262 8263static void alc888_lenovo_sky_front_automute(struct hda_codec *codec) 8264{ 8265 unsigned int mute; 8266 unsigned int present; 8267 8268 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0); 8269 present = snd_hda_codec_read(codec, 0x1b, 0, 8270 AC_VERB_GET_PIN_SENSE, 0); 8271 present = (present & 0x80000000) != 0; 8272 if (present) { 8273 /* mute internal speaker */ 8274 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 8275 HDA_AMP_MUTE, HDA_AMP_MUTE); 8276 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 8277 HDA_AMP_MUTE, HDA_AMP_MUTE); 8278 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 8279 HDA_AMP_MUTE, HDA_AMP_MUTE); 8280 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0, 8281 HDA_AMP_MUTE, HDA_AMP_MUTE); 8282 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0, 8283 HDA_AMP_MUTE, HDA_AMP_MUTE); 8284 } else { 8285 /* unmute internal speaker if necessary */ 8286 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0); 8287 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 8288 HDA_AMP_MUTE, mute); 8289 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 8290 HDA_AMP_MUTE, mute); 8291 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 8292 HDA_AMP_MUTE, mute); 8293 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0, 8294 HDA_AMP_MUTE, mute); 8295 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0, 8296 HDA_AMP_MUTE, mute); 8297 } 8298} 8299 8300static void alc883_lenovo_sky_unsol_event(struct hda_codec *codec, 8301 unsigned int res) 8302{ 8303 if ((res >> 26) == ALC880_HP_EVENT) 8304 alc888_lenovo_sky_front_automute(codec); 8305} 8306 8307/* 8308 * generic initialization of ADC, input mixers and output mixers 8309 */ 8310static struct hda_verb alc883_auto_init_verbs[] = { 8311 /* 8312 * Unmute ADC0-2 and set the default input to mic-in 8313 */ 8314 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 8315 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8316 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 8317 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8318 8319 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 8320 * mixer widget 8321 * Note: PASD motherboards uses the Line In 2 as the input for 8322 * front panel mic (mic 2) 8323 */ 8324 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 8325 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8326 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8327 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 8328 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 8329 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 8330 8331 /* 8332 * Set up output mixers (0x0c - 0x0f) 8333 */ 8334 /* set vol=0 to output mixers */ 8335 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8336 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8337 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8338 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8339 /* set up input amps for analog loopback */ 8340 /* Amp Indices: DAC = 0, mixer = 1 */ 8341 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8342 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8343 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8344 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8345 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8346 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8347 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8348 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8349 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8350 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8351 8352 /* FIXME: use matrix-type input source selection */ 8353 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 8354 /* Input mixer1 */ 8355 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8356 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8357 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 8358 /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */ 8359 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 8360 /* Input mixer2 */ 8361 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8362 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8363 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 8364 /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */ 8365 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 8366 8367 { } 8368}; 8369 8370static struct hda_verb alc888_asus_m90v_verbs[] = { 8371 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8372 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8373 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8374 /* enable unsolicited event */ 8375 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 8376 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, 8377 { } /* end */ 8378}; 8379 8380static void alc883_nb_mic_automute(struct hda_codec *codec) 8381{ 8382 unsigned int present; 8383 8384 present = snd_hda_codec_read(codec, 0x18, 0, 8385 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 8386 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE, 8387 0x7000 | (0x00 << 8) | (present ? 0 : 0x80)); 8388 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE, 8389 0x7000 | (0x01 << 8) | (present ? 0x80 : 0)); 8390} 8391 8392static void alc883_M90V_speaker_automute(struct hda_codec *codec) 8393{ 8394 unsigned int present; 8395 unsigned char bits; 8396 8397 present = snd_hda_codec_read(codec, 0x1b, 0, 8398 AC_VERB_GET_PIN_SENSE, 0) 8399 & AC_PINSENSE_PRESENCE; 8400 bits = present ? 0 : PIN_OUT; 8401 snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 8402 bits); 8403 snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 8404 bits); 8405 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 8406 bits); 8407} 8408 8409static void alc883_mode2_unsol_event(struct hda_codec *codec, 8410 unsigned int res) 8411{ 8412 switch (res >> 26) { 8413 case ALC880_HP_EVENT: 8414 alc883_M90V_speaker_automute(codec); 8415 break; 8416 case ALC880_MIC_EVENT: 8417 alc883_nb_mic_automute(codec); 8418 break; 8419 } 8420} 8421 8422static void alc883_mode2_inithook(struct hda_codec *codec) 8423{ 8424 alc883_M90V_speaker_automute(codec); 8425 alc883_nb_mic_automute(codec); 8426} 8427 8428static struct hda_verb alc888_asus_eee1601_verbs[] = { 8429 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8430 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8431 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8432 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8433 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8434 {0x20, AC_VERB_SET_COEF_INDEX, 0x0b}, 8435 {0x20, AC_VERB_SET_PROC_COEF, 0x0838}, 8436 /* enable unsolicited event */ 8437 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 8438 { } /* end */ 8439}; 8440 8441static void alc883_eee1601_speaker_automute(struct hda_codec *codec) 8442{ 8443 unsigned int present; 8444 unsigned char bits; 8445 8446 present = snd_hda_codec_read(codec, 0x14, 0, 8447 AC_VERB_GET_PIN_SENSE, 0) 8448 & AC_PINSENSE_PRESENCE; 8449 bits = present ? 0 : PIN_OUT; 8450 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 8451 bits); 8452} 8453 8454static void alc883_eee1601_unsol_event(struct hda_codec *codec, 8455 unsigned int res) 8456{ 8457 switch (res >> 26) { 8458 case ALC880_HP_EVENT: 8459 alc883_eee1601_speaker_automute(codec); 8460 break; 8461 } 8462} 8463 8464static void alc883_eee1601_inithook(struct hda_codec *codec) 8465{ 8466 alc883_eee1601_speaker_automute(codec); 8467} 8468 8469#ifdef CONFIG_SND_HDA_POWER_SAVE 8470#define alc883_loopbacks alc880_loopbacks 8471#endif 8472 8473/* pcm configuration: identiacal with ALC880 */ 8474#define alc883_pcm_analog_playback alc880_pcm_analog_playback 8475#define alc883_pcm_analog_capture alc880_pcm_analog_capture 8476#define alc883_pcm_analog_alt_capture alc880_pcm_analog_alt_capture 8477#define alc883_pcm_digital_playback alc880_pcm_digital_playback 8478#define alc883_pcm_digital_capture alc880_pcm_digital_capture 8479 8480/* 8481 * configuration and preset 8482 */ 8483static const char *alc883_models[ALC883_MODEL_LAST] = { 8484 [ALC883_3ST_2ch_DIG] = "3stack-dig", 8485 [ALC883_3ST_6ch_DIG] = "3stack-6ch-dig", 8486 [ALC883_3ST_6ch] = "3stack-6ch", 8487 [ALC883_6ST_DIG] = "6stack-dig", 8488 [ALC883_TARGA_DIG] = "targa-dig", 8489 [ALC883_TARGA_2ch_DIG] = "targa-2ch-dig", 8490 [ALC883_ACER] = "acer", 8491 [ALC883_ACER_ASPIRE] = "acer-aspire", 8492 [ALC888_ACER_ASPIRE_4930G] = "acer-aspire-4930g", 8493 [ALC883_MEDION] = "medion", 8494 [ALC883_MEDION_MD2] = "medion-md2", 8495 [ALC883_LAPTOP_EAPD] = "laptop-eapd", 8496 [ALC883_LENOVO_101E_2ch] = "lenovo-101e", 8497 [ALC883_LENOVO_NB0763] = "lenovo-nb0763", 8498 [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig", 8499 [ALC888_LENOVO_SKY] = "lenovo-sky", 8500 [ALC883_HAIER_W66] = "haier-w66", 8501 [ALC888_3ST_HP] = "3stack-hp", 8502 [ALC888_6ST_DELL] = "6stack-dell", 8503 [ALC883_MITAC] = "mitac", 8504 [ALC883_CLEVO_M720] = "clevo-m720", 8505 [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515", 8506 [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530", 8507 [ALC883_3ST_6ch_INTEL] = "3stack-6ch-intel", 8508 [ALC1200_ASUS_P5Q] = "asus-p5q", 8509 [ALC883_AUTO] = "auto", 8510}; 8511 8512static struct snd_pci_quirk alc883_cfg_tbl[] = { 8513 SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG), 8514 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE), 8515 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE), 8516 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE), 8517 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE), 8518 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE), 8519 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G", 8520 ALC888_ACER_ASPIRE_4930G), 8521 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G", 8522 ALC888_ACER_ASPIRE_4930G), 8523 SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC883_AUTO), 8524 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G", 8525 ALC888_ACER_ASPIRE_4930G), 8526 /* default Acer */ 8527 SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), 8528 SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL), 8529 SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG), 8530 SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP), 8531 SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP), 8532 SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG), 8533 SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP), 8534 SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V), 8535 SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG), 8536 SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG), 8537 SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q), 8538 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601), 8539 SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG), 8540 SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG), 8541 SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC), 8542 SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC), 8543 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD), 8544 SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL), 8545 SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch), 8546 SND_PCI_QUIRK(0x1458, 0xa002, "MSI", ALC883_6ST_DIG), 8547 SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG), 8548 SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG), 8549 SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG), 8550 SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG), 8551 SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG), 8552 SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG), 8553 SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG), 8554 SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG), 8555 SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG), 8556 SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG), 8557 SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG), 8558 SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG), 8559 SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG), 8560 SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG), 8561 SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG), 8562 SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG), 8563 SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG), 8564 SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG), 8565 SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG), 8566 SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG), 8567 SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG), 8568 SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG), 8569 SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG), 8570 SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG), 8571 SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720), 8572 SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720), 8573 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD), 8574 SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch), 8575 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION), 8576 SND_PCI_QUIRK(0x1734, 0x1107, "FSC AMILO Xi2550", 8577 ALC883_FUJITSU_PI2515), 8578 SND_PCI_QUIRK(0x1734, 0x1108, "Fujitsu AMILO Pi2515", ALC883_FUJITSU_PI2515), 8579 SND_PCI_QUIRK(0x1734, 0x113d, "Fujitsu AMILO Xa3530", 8580 ALC888_FUJITSU_XA3530), 8581 SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch), 8582 SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763), 8583 SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763), 8584 SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763), 8585 SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY), 8586 SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2), 8587 SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG), 8588 SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG), 8589 SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66), 8590 SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL), 8591 SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL), 8592 SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC), 8593 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC883_3ST_6ch_INTEL), 8594 SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch), 8595 {} 8596}; 8597 8598static hda_nid_t alc1200_slave_dig_outs[] = { 8599 ALC883_DIGOUT_NID, 0, 8600}; 8601 8602static struct alc_config_preset alc883_presets[] = { 8603 [ALC883_3ST_2ch_DIG] = { 8604 .mixers = { alc883_3ST_2ch_mixer }, 8605 .init_verbs = { alc883_init_verbs }, 8606 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8607 .dac_nids = alc883_dac_nids, 8608 .dig_out_nid = ALC883_DIGOUT_NID, 8609 .dig_in_nid = ALC883_DIGIN_NID, 8610 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8611 .channel_mode = alc883_3ST_2ch_modes, 8612 .input_mux = &alc883_capture_source, 8613 }, 8614 [ALC883_3ST_6ch_DIG] = { 8615 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 8616 .init_verbs = { alc883_init_verbs }, 8617 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8618 .dac_nids = alc883_dac_nids, 8619 .dig_out_nid = ALC883_DIGOUT_NID, 8620 .dig_in_nid = ALC883_DIGIN_NID, 8621 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 8622 .channel_mode = alc883_3ST_6ch_modes, 8623 .need_dac_fix = 1, 8624 .input_mux = &alc883_capture_source, 8625 }, 8626 [ALC883_3ST_6ch] = { 8627 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 8628 .init_verbs = { alc883_init_verbs }, 8629 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8630 .dac_nids = alc883_dac_nids, 8631 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 8632 .channel_mode = alc883_3ST_6ch_modes, 8633 .need_dac_fix = 1, 8634 .input_mux = &alc883_capture_source, 8635 }, 8636 [ALC883_3ST_6ch_INTEL] = { 8637 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer }, 8638 .init_verbs = { alc883_init_verbs }, 8639 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8640 .dac_nids = alc883_dac_nids, 8641 .dig_out_nid = ALC883_DIGOUT_NID, 8642 .dig_in_nid = ALC883_DIGIN_NID, 8643 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes), 8644 .channel_mode = alc883_3ST_6ch_intel_modes, 8645 .need_dac_fix = 1, 8646 .input_mux = &alc883_3stack_6ch_intel, 8647 }, 8648 [ALC883_6ST_DIG] = { 8649 .mixers = { alc883_base_mixer, alc883_chmode_mixer }, 8650 .init_verbs = { alc883_init_verbs }, 8651 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8652 .dac_nids = alc883_dac_nids, 8653 .dig_out_nid = ALC883_DIGOUT_NID, 8654 .dig_in_nid = ALC883_DIGIN_NID, 8655 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes), 8656 .channel_mode = alc883_sixstack_modes, 8657 .input_mux = &alc883_capture_source, 8658 }, 8659 [ALC883_TARGA_DIG] = { 8660 .mixers = { alc883_tagra_mixer, alc883_chmode_mixer }, 8661 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs}, 8662 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8663 .dac_nids = alc883_dac_nids, 8664 .dig_out_nid = ALC883_DIGOUT_NID, 8665 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 8666 .channel_mode = alc883_3ST_6ch_modes, 8667 .need_dac_fix = 1, 8668 .input_mux = &alc883_capture_source, 8669 .unsol_event = alc883_tagra_unsol_event, 8670 .init_hook = alc883_tagra_automute, 8671 }, 8672 [ALC883_TARGA_2ch_DIG] = { 8673 .mixers = { alc883_tagra_2ch_mixer}, 8674 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs}, 8675 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8676 .dac_nids = alc883_dac_nids, 8677 .adc_nids = alc883_adc_nids_alt, 8678 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt), 8679 .dig_out_nid = ALC883_DIGOUT_NID, 8680 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8681 .channel_mode = alc883_3ST_2ch_modes, 8682 .input_mux = &alc883_capture_source, 8683 .unsol_event = alc883_tagra_unsol_event, 8684 .init_hook = alc883_tagra_automute, 8685 }, 8686 [ALC883_ACER] = { 8687 .mixers = { alc883_base_mixer }, 8688 /* On TravelMate laptops, GPIO 0 enables the internal speaker 8689 * and the headphone jack. Turn this on and rely on the 8690 * standard mute methods whenever the user wants to turn 8691 * these outputs off. 8692 */ 8693 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs }, 8694 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8695 .dac_nids = alc883_dac_nids, 8696 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8697 .channel_mode = alc883_3ST_2ch_modes, 8698 .input_mux = &alc883_capture_source, 8699 }, 8700 [ALC883_ACER_ASPIRE] = { 8701 .mixers = { alc883_acer_aspire_mixer }, 8702 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs }, 8703 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8704 .dac_nids = alc883_dac_nids, 8705 .dig_out_nid = ALC883_DIGOUT_NID, 8706 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8707 .channel_mode = alc883_3ST_2ch_modes, 8708 .input_mux = &alc883_capture_source, 8709 .unsol_event = alc883_acer_aspire_unsol_event, 8710 .init_hook = alc883_acer_aspire_automute, 8711 }, 8712 [ALC888_ACER_ASPIRE_4930G] = { 8713 .mixers = { alc888_base_mixer, 8714 alc883_chmode_mixer }, 8715 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs, 8716 alc888_acer_aspire_4930g_verbs }, 8717 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8718 .dac_nids = alc883_dac_nids, 8719 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev), 8720 .adc_nids = alc883_adc_nids_rev, 8721 .capsrc_nids = alc883_capsrc_nids_rev, 8722 .dig_out_nid = ALC883_DIGOUT_NID, 8723 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 8724 .channel_mode = alc883_3ST_6ch_modes, 8725 .need_dac_fix = 1, 8726 .num_mux_defs = 8727 ARRAY_SIZE(alc888_2_capture_sources), 8728 .input_mux = alc888_2_capture_sources, 8729 .unsol_event = alc888_acer_aspire_4930g_unsol_event, 8730 .init_hook = alc888_acer_aspire_4930g_automute, 8731 }, 8732 [ALC883_MEDION] = { 8733 .mixers = { alc883_fivestack_mixer, 8734 alc883_chmode_mixer }, 8735 .init_verbs = { alc883_init_verbs, 8736 alc883_medion_eapd_verbs }, 8737 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8738 .dac_nids = alc883_dac_nids, 8739 .adc_nids = alc883_adc_nids_alt, 8740 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt), 8741 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes), 8742 .channel_mode = alc883_sixstack_modes, 8743 .input_mux = &alc883_capture_source, 8744 }, 8745 [ALC883_MEDION_MD2] = { 8746 .mixers = { alc883_medion_md2_mixer}, 8747 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs}, 8748 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8749 .dac_nids = alc883_dac_nids, 8750 .dig_out_nid = ALC883_DIGOUT_NID, 8751 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8752 .channel_mode = alc883_3ST_2ch_modes, 8753 .input_mux = &alc883_capture_source, 8754 .unsol_event = alc883_medion_md2_unsol_event, 8755 .init_hook = alc883_medion_md2_automute, 8756 }, 8757 [ALC883_LAPTOP_EAPD] = { 8758 .mixers = { alc883_base_mixer }, 8759 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs }, 8760 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8761 .dac_nids = alc883_dac_nids, 8762 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8763 .channel_mode = alc883_3ST_2ch_modes, 8764 .input_mux = &alc883_capture_source, 8765 }, 8766 [ALC883_CLEVO_M720] = { 8767 .mixers = { alc883_clevo_m720_mixer }, 8768 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs }, 8769 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8770 .dac_nids = alc883_dac_nids, 8771 .dig_out_nid = ALC883_DIGOUT_NID, 8772 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8773 .channel_mode = alc883_3ST_2ch_modes, 8774 .input_mux = &alc883_capture_source, 8775 .unsol_event = alc883_clevo_m720_unsol_event, 8776 .init_hook = alc883_clevo_m720_automute, 8777 }, 8778 [ALC883_LENOVO_101E_2ch] = { 8779 .mixers = { alc883_lenovo_101e_2ch_mixer}, 8780 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs}, 8781 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8782 .dac_nids = alc883_dac_nids, 8783 .adc_nids = alc883_adc_nids_alt, 8784 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt), 8785 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8786 .channel_mode = alc883_3ST_2ch_modes, 8787 .input_mux = &alc883_lenovo_101e_capture_source, 8788 .unsol_event = alc883_lenovo_101e_unsol_event, 8789 .init_hook = alc883_lenovo_101e_all_automute, 8790 }, 8791 [ALC883_LENOVO_NB0763] = { 8792 .mixers = { alc883_lenovo_nb0763_mixer }, 8793 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs}, 8794 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8795 .dac_nids = alc883_dac_nids, 8796 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8797 .channel_mode = alc883_3ST_2ch_modes, 8798 .need_dac_fix = 1, 8799 .input_mux = &alc883_lenovo_nb0763_capture_source, 8800 .unsol_event = alc883_medion_md2_unsol_event, 8801 .init_hook = alc883_medion_md2_automute, 8802 }, 8803 [ALC888_LENOVO_MS7195_DIG] = { 8804 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 8805 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs}, 8806 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8807 .dac_nids = alc883_dac_nids, 8808 .dig_out_nid = ALC883_DIGOUT_NID, 8809 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 8810 .channel_mode = alc883_3ST_6ch_modes, 8811 .need_dac_fix = 1, 8812 .input_mux = &alc883_capture_source, 8813 .unsol_event = alc883_lenovo_ms7195_unsol_event, 8814 .init_hook = alc888_lenovo_ms7195_front_automute, 8815 }, 8816 [ALC883_HAIER_W66] = { 8817 .mixers = { alc883_tagra_2ch_mixer}, 8818 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs}, 8819 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8820 .dac_nids = alc883_dac_nids, 8821 .dig_out_nid = ALC883_DIGOUT_NID, 8822 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8823 .channel_mode = alc883_3ST_2ch_modes, 8824 .input_mux = &alc883_capture_source, 8825 .unsol_event = alc883_haier_w66_unsol_event, 8826 .init_hook = alc883_haier_w66_automute, 8827 }, 8828 [ALC888_3ST_HP] = { 8829 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 8830 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs }, 8831 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8832 .dac_nids = alc883_dac_nids, 8833 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes), 8834 .channel_mode = alc888_3st_hp_modes, 8835 .need_dac_fix = 1, 8836 .input_mux = &alc883_capture_source, 8837 }, 8838 [ALC888_6ST_DELL] = { 8839 .mixers = { alc883_base_mixer, alc883_chmode_mixer }, 8840 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs }, 8841 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8842 .dac_nids = alc883_dac_nids, 8843 .dig_out_nid = ALC883_DIGOUT_NID, 8844 .dig_in_nid = ALC883_DIGIN_NID, 8845 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes), 8846 .channel_mode = alc883_sixstack_modes, 8847 .input_mux = &alc883_capture_source, 8848 .unsol_event = alc888_6st_dell_unsol_event, 8849 .init_hook = alc888_6st_dell_front_automute, 8850 }, 8851 [ALC883_MITAC] = { 8852 .mixers = { alc883_mitac_mixer }, 8853 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs }, 8854 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8855 .dac_nids = alc883_dac_nids, 8856 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8857 .channel_mode = alc883_3ST_2ch_modes, 8858 .input_mux = &alc883_capture_source, 8859 .unsol_event = alc883_mitac_unsol_event, 8860 .init_hook = alc883_mitac_automute, 8861 }, 8862 [ALC883_FUJITSU_PI2515] = { 8863 .mixers = { alc883_2ch_fujitsu_pi2515_mixer }, 8864 .init_verbs = { alc883_init_verbs, 8865 alc883_2ch_fujitsu_pi2515_verbs}, 8866 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8867 .dac_nids = alc883_dac_nids, 8868 .dig_out_nid = ALC883_DIGOUT_NID, 8869 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8870 .channel_mode = alc883_3ST_2ch_modes, 8871 .input_mux = &alc883_fujitsu_pi2515_capture_source, 8872 .unsol_event = alc883_2ch_fujitsu_pi2515_unsol_event, 8873 .init_hook = alc883_2ch_fujitsu_pi2515_automute, 8874 }, 8875 [ALC888_FUJITSU_XA3530] = { 8876 .mixers = { alc888_base_mixer, alc883_chmode_mixer }, 8877 .init_verbs = { alc883_init_verbs, 8878 alc888_fujitsu_xa3530_verbs }, 8879 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8880 .dac_nids = alc883_dac_nids, 8881 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev), 8882 .adc_nids = alc883_adc_nids_rev, 8883 .capsrc_nids = alc883_capsrc_nids_rev, 8884 .dig_out_nid = ALC883_DIGOUT_NID, 8885 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes), 8886 .channel_mode = alc888_4ST_8ch_intel_modes, 8887 .num_mux_defs = 8888 ARRAY_SIZE(alc888_2_capture_sources), 8889 .input_mux = alc888_2_capture_sources, 8890 .unsol_event = alc888_fujitsu_xa3530_unsol_event, 8891 .init_hook = alc888_fujitsu_xa3530_automute, 8892 }, 8893 [ALC888_LENOVO_SKY] = { 8894 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer }, 8895 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs}, 8896 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8897 .dac_nids = alc883_dac_nids, 8898 .dig_out_nid = ALC883_DIGOUT_NID, 8899 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes), 8900 .channel_mode = alc883_sixstack_modes, 8901 .need_dac_fix = 1, 8902 .input_mux = &alc883_lenovo_sky_capture_source, 8903 .unsol_event = alc883_lenovo_sky_unsol_event, 8904 .init_hook = alc888_lenovo_sky_front_automute, 8905 }, 8906 [ALC888_ASUS_M90V] = { 8907 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 8908 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs }, 8909 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8910 .dac_nids = alc883_dac_nids, 8911 .dig_out_nid = ALC883_DIGOUT_NID, 8912 .dig_in_nid = ALC883_DIGIN_NID, 8913 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 8914 .channel_mode = alc883_3ST_6ch_modes, 8915 .need_dac_fix = 1, 8916 .input_mux = &alc883_fujitsu_pi2515_capture_source, 8917 .unsol_event = alc883_mode2_unsol_event, 8918 .init_hook = alc883_mode2_inithook, 8919 }, 8920 [ALC888_ASUS_EEE1601] = { 8921 .mixers = { alc883_asus_eee1601_mixer }, 8922 .cap_mixer = alc883_asus_eee1601_cap_mixer, 8923 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs }, 8924 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8925 .dac_nids = alc883_dac_nids, 8926 .dig_out_nid = ALC883_DIGOUT_NID, 8927 .dig_in_nid = ALC883_DIGIN_NID, 8928 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8929 .channel_mode = alc883_3ST_2ch_modes, 8930 .need_dac_fix = 1, 8931 .input_mux = &alc883_asus_eee1601_capture_source, 8932 .unsol_event = alc883_eee1601_unsol_event, 8933 .init_hook = alc883_eee1601_inithook, 8934 }, 8935 [ALC1200_ASUS_P5Q] = { 8936 .mixers = { alc883_base_mixer, alc883_chmode_mixer }, 8937 .init_verbs = { alc883_init_verbs }, 8938 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8939 .dac_nids = alc883_dac_nids, 8940 .dig_out_nid = ALC1200_DIGOUT_NID, 8941 .dig_in_nid = ALC883_DIGIN_NID, 8942 .slave_dig_outs = alc1200_slave_dig_outs, 8943 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes), 8944 .channel_mode = alc883_sixstack_modes, 8945 .input_mux = &alc883_capture_source, 8946 }, 8947}; 8948 8949 8950/* 8951 * BIOS auto configuration 8952 */ 8953static void alc883_auto_set_output_and_unmute(struct hda_codec *codec, 8954 hda_nid_t nid, int pin_type, 8955 int dac_idx) 8956{ 8957 /* set as output */ 8958 struct alc_spec *spec = codec->spec; 8959 int idx; 8960 8961 alc_set_pin_output(codec, nid, pin_type); 8962 if (spec->multiout.dac_nids[dac_idx] == 0x25) 8963 idx = 4; 8964 else 8965 idx = spec->multiout.dac_nids[dac_idx] - 2; 8966 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx); 8967 8968} 8969 8970static void alc883_auto_init_multi_out(struct hda_codec *codec) 8971{ 8972 struct alc_spec *spec = codec->spec; 8973 int i; 8974 8975 alc_subsystem_id(codec, 0x15, 0x1b, 0x14); 8976 for (i = 0; i <= HDA_SIDE; i++) { 8977 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 8978 int pin_type = get_pin_type(spec->autocfg.line_out_type); 8979 if (nid) 8980 alc883_auto_set_output_and_unmute(codec, nid, pin_type, 8981 i); 8982 } 8983} 8984 8985static void alc883_auto_init_hp_out(struct hda_codec *codec) 8986{ 8987 struct alc_spec *spec = codec->spec; 8988 hda_nid_t pin; 8989 8990 pin = spec->autocfg.hp_pins[0]; 8991 if (pin) /* connect to front */ 8992 /* use dac 0 */ 8993 alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 8994 pin = spec->autocfg.speaker_pins[0]; 8995 if (pin) 8996 alc883_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 8997} 8998 8999#define alc883_is_input_pin(nid) alc880_is_input_pin(nid) 9000#define ALC883_PIN_CD_NID ALC880_PIN_CD_NID 9001 9002static void alc883_auto_init_analog_input(struct hda_codec *codec) 9003{ 9004 struct alc_spec *spec = codec->spec; 9005 int i; 9006 9007 for (i = 0; i < AUTO_PIN_LAST; i++) { 9008 hda_nid_t nid = spec->autocfg.input_pins[i]; 9009 if (alc883_is_input_pin(nid)) { 9010 snd_hda_codec_write(codec, nid, 0, 9011 AC_VERB_SET_PIN_WIDGET_CONTROL, 9012 (i <= AUTO_PIN_FRONT_MIC ? 9013 PIN_VREF80 : PIN_IN)); 9014 if (nid != ALC883_PIN_CD_NID) 9015 snd_hda_codec_write(codec, nid, 0, 9016 AC_VERB_SET_AMP_GAIN_MUTE, 9017 AMP_OUT_MUTE); 9018 } 9019 } 9020} 9021 9022#define alc883_auto_init_input_src alc882_auto_init_input_src 9023 9024/* almost identical with ALC880 parser... */ 9025static int alc883_parse_auto_config(struct hda_codec *codec) 9026{ 9027 struct alc_spec *spec = codec->spec; 9028 int err = alc880_parse_auto_config(codec); 9029 struct auto_pin_cfg *cfg = &spec->autocfg; 9030 int i; 9031 9032 if (err < 0) 9033 return err; 9034 else if (!err) 9035 return 0; /* no config found */ 9036 9037 err = alc_auto_add_mic_boost(codec); 9038 if (err < 0) 9039 return err; 9040 9041 /* hack - override the init verbs */ 9042 spec->init_verbs[0] = alc883_auto_init_verbs; 9043 9044 /* setup input_mux for ALC889 */ 9045 if (codec->vendor_id == 0x10ec0889) { 9046 /* digital-mic input pin is excluded in alc880_auto_create..() 9047 * because it's under 0x18 9048 */ 9049 if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 || 9050 cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) { 9051 struct hda_input_mux *imux = &spec->private_imux[0]; 9052 for (i = 1; i < 3; i++) 9053 memcpy(&spec->private_imux[i], 9054 &spec->private_imux[0], 9055 sizeof(spec->private_imux[0])); 9056 imux->items[imux->num_items].label = "Int DMic"; 9057 imux->items[imux->num_items].index = 0x0b; 9058 imux->num_items++; 9059 spec->num_mux_defs = 3; 9060 spec->input_mux = spec->private_imux; 9061 } 9062 } 9063 9064 return 1; /* config found */ 9065} 9066 9067/* additional initialization for auto-configuration model */ 9068static void alc883_auto_init(struct hda_codec *codec) 9069{ 9070 struct alc_spec *spec = codec->spec; 9071 alc883_auto_init_multi_out(codec); 9072 alc883_auto_init_hp_out(codec); 9073 alc883_auto_init_analog_input(codec); 9074 alc883_auto_init_input_src(codec); 9075 if (spec->unsol_event) 9076 alc_inithook(codec); 9077} 9078 9079static int patch_alc883(struct hda_codec *codec) 9080{ 9081 struct alc_spec *spec; 9082 int err, board_config; 9083 9084 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 9085 if (spec == NULL) 9086 return -ENOMEM; 9087 9088 codec->spec = spec; 9089 9090 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 9091 9092 board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST, 9093 alc883_models, 9094 alc883_cfg_tbl); 9095 if (board_config < 0) { 9096 printk(KERN_INFO "hda_codec: Unknown model for ALC883, " 9097 "trying auto-probe from BIOS...\n"); 9098 board_config = ALC883_AUTO; 9099 } 9100 9101 if (board_config == ALC883_AUTO) { 9102 /* automatic parse from the BIOS config */ 9103 err = alc883_parse_auto_config(codec); 9104 if (err < 0) { 9105 alc_free(codec); 9106 return err; 9107 } else if (!err) { 9108 printk(KERN_INFO 9109 "hda_codec: Cannot set up configuration " 9110 "from BIOS. Using base mode...\n"); 9111 board_config = ALC883_3ST_2ch_DIG; 9112 } 9113 } 9114 9115 err = snd_hda_attach_beep_device(codec, 0x1); 9116 if (err < 0) { 9117 alc_free(codec); 9118 return err; 9119 } 9120 9121 if (board_config != ALC883_AUTO) 9122 setup_preset(spec, &alc883_presets[board_config]); 9123 9124 switch (codec->vendor_id) { 9125 case 0x10ec0888: 9126 if (codec->revision_id == 0x100101) { 9127 spec->stream_name_analog = "ALC1200 Analog"; 9128 spec->stream_name_digital = "ALC1200 Digital"; 9129 } else { 9130 spec->stream_name_analog = "ALC888 Analog"; 9131 spec->stream_name_digital = "ALC888 Digital"; 9132 } 9133 if (!spec->num_adc_nids) { 9134 spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids); 9135 spec->adc_nids = alc883_adc_nids; 9136 } 9137 if (!spec->capsrc_nids) 9138 spec->capsrc_nids = alc883_capsrc_nids; 9139 spec->capture_style = CAPT_MIX; /* matrix-style capture */ 9140 break; 9141 case 0x10ec0889: 9142 spec->stream_name_analog = "ALC889 Analog"; 9143 spec->stream_name_digital = "ALC889 Digital"; 9144 if (!spec->num_adc_nids) { 9145 spec->num_adc_nids = ARRAY_SIZE(alc889_adc_nids); 9146 spec->adc_nids = alc889_adc_nids; 9147 } 9148 if (!spec->capsrc_nids) 9149 spec->capsrc_nids = alc889_capsrc_nids; 9150 spec->capture_style = CAPT_1MUX_MIX; /* 1mux/Nmix-style 9151 capture */ 9152 break; 9153 default: 9154 spec->stream_name_analog = "ALC883 Analog"; 9155 spec->stream_name_digital = "ALC883 Digital"; 9156 if (!spec->num_adc_nids) { 9157 spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids); 9158 spec->adc_nids = alc883_adc_nids; 9159 } 9160 if (!spec->capsrc_nids) 9161 spec->capsrc_nids = alc883_capsrc_nids; 9162 spec->capture_style = CAPT_MIX; /* matrix-style capture */ 9163 break; 9164 } 9165 9166 spec->stream_analog_playback = &alc883_pcm_analog_playback; 9167 spec->stream_analog_capture = &alc883_pcm_analog_capture; 9168 spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture; 9169 9170 spec->stream_digital_playback = &alc883_pcm_digital_playback; 9171 spec->stream_digital_capture = &alc883_pcm_digital_capture; 9172 9173 if (!spec->cap_mixer) 9174 set_capture_mixer(spec); 9175 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 9176 9177 spec->vmaster_nid = 0x0c; 9178 9179 codec->patch_ops = alc_patch_ops; 9180 if (board_config == ALC883_AUTO) 9181 spec->init_hook = alc883_auto_init; 9182 9183#ifdef CONFIG_SND_HDA_POWER_SAVE 9184 if (!spec->loopback.amplist) 9185 spec->loopback.amplist = alc883_loopbacks; 9186#endif 9187 codec->proc_widget_hook = print_realtek_coef; 9188 9189 return 0; 9190} 9191 9192/* 9193 * ALC262 support 9194 */ 9195 9196#define ALC262_DIGOUT_NID ALC880_DIGOUT_NID 9197#define ALC262_DIGIN_NID ALC880_DIGIN_NID 9198 9199#define alc262_dac_nids alc260_dac_nids 9200#define alc262_adc_nids alc882_adc_nids 9201#define alc262_adc_nids_alt alc882_adc_nids_alt 9202#define alc262_capsrc_nids alc882_capsrc_nids 9203#define alc262_capsrc_nids_alt alc882_capsrc_nids_alt 9204 9205#define alc262_modes alc260_modes 9206#define alc262_capture_source alc882_capture_source 9207 9208static hda_nid_t alc262_dmic_adc_nids[1] = { 9209 /* ADC0 */ 9210 0x09 9211}; 9212 9213static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 }; 9214 9215static struct snd_kcontrol_new alc262_base_mixer[] = { 9216 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9217 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 9218 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 9219 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 9220 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 9221 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 9222 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9223 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9224 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 9225 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 9226 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 9227 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 9228 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT), 9229 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 9230 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 9231 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT), 9232 { } /* end */ 9233}; 9234 9235static struct snd_kcontrol_new alc262_hippo1_mixer[] = { 9236 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9237 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 9238 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 9239 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 9240 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 9241 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 9242 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9243 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9244 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 9245 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 9246 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 9247 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 9248 /*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/ 9249 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 9250 { } /* end */ 9251}; 9252 9253/* update HP, line and mono-out pins according to the master switch */ 9254static void alc262_hp_master_update(struct hda_codec *codec) 9255{ 9256 struct alc_spec *spec = codec->spec; 9257 int val = spec->master_sw; 9258 9259 /* HP & line-out */ 9260 snd_hda_codec_write_cache(codec, 0x1b, 0, 9261 AC_VERB_SET_PIN_WIDGET_CONTROL, 9262 val ? PIN_HP : 0); 9263 snd_hda_codec_write_cache(codec, 0x15, 0, 9264 AC_VERB_SET_PIN_WIDGET_CONTROL, 9265 val ? PIN_HP : 0); 9266 /* mono (speaker) depending on the HP jack sense */ 9267 val = val && !spec->jack_present; 9268 snd_hda_codec_write_cache(codec, 0x16, 0, 9269 AC_VERB_SET_PIN_WIDGET_CONTROL, 9270 val ? PIN_OUT : 0); 9271} 9272 9273static void alc262_hp_bpc_automute(struct hda_codec *codec) 9274{ 9275 struct alc_spec *spec = codec->spec; 9276 unsigned int presence; 9277 presence = snd_hda_codec_read(codec, 0x1b, 0, 9278 AC_VERB_GET_PIN_SENSE, 0); 9279 spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE); 9280 alc262_hp_master_update(codec); 9281} 9282 9283static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res) 9284{ 9285 if ((res >> 26) != ALC880_HP_EVENT) 9286 return; 9287 alc262_hp_bpc_automute(codec); 9288} 9289 9290static void alc262_hp_wildwest_automute(struct hda_codec *codec) 9291{ 9292 struct alc_spec *spec = codec->spec; 9293 unsigned int presence; 9294 presence = snd_hda_codec_read(codec, 0x15, 0, 9295 AC_VERB_GET_PIN_SENSE, 0); 9296 spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE); 9297 alc262_hp_master_update(codec); 9298} 9299 9300static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec, 9301 unsigned int res) 9302{ 9303 if ((res >> 26) != ALC880_HP_EVENT) 9304 return; 9305 alc262_hp_wildwest_automute(codec); 9306} 9307 9308static int alc262_hp_master_sw_get(struct snd_kcontrol *kcontrol, 9309 struct snd_ctl_elem_value *ucontrol) 9310{ 9311 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 9312 struct alc_spec *spec = codec->spec; 9313 *ucontrol->value.integer.value = spec->master_sw; 9314 return 0; 9315} 9316 9317static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol, 9318 struct snd_ctl_elem_value *ucontrol) 9319{ 9320 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 9321 struct alc_spec *spec = codec->spec; 9322 int val = !!*ucontrol->value.integer.value; 9323 9324 if (val == spec->master_sw) 9325 return 0; 9326 spec->master_sw = val; 9327 alc262_hp_master_update(codec); 9328 return 1; 9329} 9330 9331static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = { 9332 { 9333 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 9334 .name = "Master Playback Switch", 9335 .info = snd_ctl_boolean_mono_info, 9336 .get = alc262_hp_master_sw_get, 9337 .put = alc262_hp_master_sw_put, 9338 }, 9339 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9340 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT), 9341 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 9342 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0, 9343 HDA_OUTPUT), 9344 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0, 9345 HDA_OUTPUT), 9346 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9347 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9348 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 9349 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 9350 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 9351 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 9352 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 9353 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 9354 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 9355 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 9356 HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT), 9357 HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT), 9358 { } /* end */ 9359}; 9360 9361static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = { 9362 { 9363 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 9364 .name = "Master Playback Switch", 9365 .info = snd_ctl_boolean_mono_info, 9366 .get = alc262_hp_master_sw_get, 9367 .put = alc262_hp_master_sw_put, 9368 }, 9369 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9370 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 9371 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 9372 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 9373 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0, 9374 HDA_OUTPUT), 9375 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0, 9376 HDA_OUTPUT), 9377 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT), 9378 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT), 9379 HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT), 9380 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT), 9381 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT), 9382 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 9383 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 9384 { } /* end */ 9385}; 9386 9387static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = { 9388 HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9389 HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9390 HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT), 9391 { } /* end */ 9392}; 9393 9394/* mute/unmute internal speaker according to the hp jack and mute state */ 9395static void alc262_hp_t5735_automute(struct hda_codec *codec, int force) 9396{ 9397 struct alc_spec *spec = codec->spec; 9398 9399 if (force || !spec->sense_updated) { 9400 unsigned int present; 9401 present = snd_hda_codec_read(codec, 0x15, 0, 9402 AC_VERB_GET_PIN_SENSE, 0); 9403 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0; 9404 spec->sense_updated = 1; 9405 } 9406 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, HDA_AMP_MUTE, 9407 spec->jack_present ? HDA_AMP_MUTE : 0); 9408} 9409 9410static void alc262_hp_t5735_unsol_event(struct hda_codec *codec, 9411 unsigned int res) 9412{ 9413 if ((res >> 26) != ALC880_HP_EVENT) 9414 return; 9415 alc262_hp_t5735_automute(codec, 1); 9416} 9417 9418static void alc262_hp_t5735_init_hook(struct hda_codec *codec) 9419{ 9420 alc262_hp_t5735_automute(codec, 1); 9421} 9422 9423static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = { 9424 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9425 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 9426 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 9427 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 9428 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9429 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9430 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 9431 { } /* end */ 9432}; 9433 9434static struct hda_verb alc262_hp_t5735_verbs[] = { 9435 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9436 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9437 9438 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9439 { } 9440}; 9441 9442static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = { 9443 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9444 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 9445 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT), 9446 HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT), 9447 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT), 9448 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT), 9449 { } /* end */ 9450}; 9451 9452static struct hda_verb alc262_hp_rp5700_verbs[] = { 9453 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 9454 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 9455 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9456 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9457 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 9458 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 9459 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 9460 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 9461 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))}, 9462 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))}, 9463 {} 9464}; 9465 9466static struct hda_input_mux alc262_hp_rp5700_capture_source = { 9467 .num_items = 1, 9468 .items = { 9469 { "Line", 0x1 }, 9470 }, 9471}; 9472 9473/* bind hp and internal speaker mute (with plug check) */ 9474static int alc262_sony_master_sw_put(struct snd_kcontrol *kcontrol, 9475 struct snd_ctl_elem_value *ucontrol) 9476{ 9477 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 9478 long *valp = ucontrol->value.integer.value; 9479 int change; 9480 9481 /* change hp mute */ 9482 change = snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0, 9483 HDA_AMP_MUTE, 9484 valp[0] ? 0 : HDA_AMP_MUTE); 9485 change |= snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0, 9486 HDA_AMP_MUTE, 9487 valp[1] ? 0 : HDA_AMP_MUTE); 9488 if (change) { 9489 /* change speaker according to HP jack state */ 9490 struct alc_spec *spec = codec->spec; 9491 unsigned int mute; 9492 if (spec->jack_present) 9493 mute = HDA_AMP_MUTE; 9494 else 9495 mute = snd_hda_codec_amp_read(codec, 0x15, 0, 9496 HDA_OUTPUT, 0); 9497 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9498 HDA_AMP_MUTE, mute); 9499 } 9500 return change; 9501} 9502 9503static struct snd_kcontrol_new alc262_sony_mixer[] = { 9504 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9505 { 9506 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 9507 .name = "Master Playback Switch", 9508 .info = snd_hda_mixer_amp_switch_info, 9509 .get = snd_hda_mixer_amp_switch_get, 9510 .put = alc262_sony_master_sw_put, 9511 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT), 9512 }, 9513 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9514 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9515 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 9516 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 9517 { } /* end */ 9518}; 9519 9520static struct snd_kcontrol_new alc262_benq_t31_mixer[] = { 9521 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9522 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 9523 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 9524 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9525 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9526 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 9527 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 9528 { } /* end */ 9529}; 9530 9531static struct snd_kcontrol_new alc262_tyan_mixer[] = { 9532 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9533 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT), 9534 HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT), 9535 HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT), 9536 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 9537 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 9538 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9539 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9540 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 9541 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 9542 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 9543 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 9544 { } /* end */ 9545}; 9546 9547static struct hda_verb alc262_tyan_verbs[] = { 9548 /* Headphone automute */ 9549 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 9550 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9551 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 9552 9553 /* P11 AUX_IN, white 4-pin connector */ 9554 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 9555 {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1}, 9556 {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93}, 9557 {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19}, 9558 9559 {} 9560}; 9561 9562/* unsolicited event for HP jack sensing */ 9563static void alc262_tyan_automute(struct hda_codec *codec) 9564{ 9565 unsigned int mute; 9566 unsigned int present; 9567 9568 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0); 9569 present = snd_hda_codec_read(codec, 0x1b, 0, 9570 AC_VERB_GET_PIN_SENSE, 0); 9571 present = (present & 0x80000000) != 0; 9572 if (present) { 9573 /* mute line output on ATX panel */ 9574 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 9575 HDA_AMP_MUTE, HDA_AMP_MUTE); 9576 } else { 9577 /* unmute line output if necessary */ 9578 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0); 9579 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 9580 HDA_AMP_MUTE, mute); 9581 } 9582} 9583 9584static void alc262_tyan_unsol_event(struct hda_codec *codec, 9585 unsigned int res) 9586{ 9587 if ((res >> 26) != ALC880_HP_EVENT) 9588 return; 9589 alc262_tyan_automute(codec); 9590} 9591 9592#define alc262_capture_mixer alc882_capture_mixer 9593#define alc262_capture_alt_mixer alc882_capture_alt_mixer 9594 9595/* 9596 * generic initialization of ADC, input mixers and output mixers 9597 */ 9598static struct hda_verb alc262_init_verbs[] = { 9599 /* 9600 * Unmute ADC0-2 and set the default input to mic-in 9601 */ 9602 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 9603 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9604 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 9605 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9606 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 9607 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9608 9609 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 9610 * mixer widget 9611 * Note: PASD motherboards uses the Line In 2 as the input for 9612 * front panel mic (mic 2) 9613 */ 9614 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 9615 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 9616 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 9617 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 9618 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 9619 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 9620 9621 /* 9622 * Set up output mixers (0x0c - 0x0e) 9623 */ 9624 /* set vol=0 to output mixers */ 9625 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9626 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9627 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9628 /* set up input amps for analog loopback */ 9629 /* Amp Indices: DAC = 0, mixer = 1 */ 9630 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9631 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9632 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9633 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9634 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9635 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9636 9637 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 9638 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 9639 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 9640 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 9641 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 9642 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 9643 9644 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 9645 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 9646 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 9647 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 9648 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 9649 9650 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 9651 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 9652 9653 /* FIXME: use matrix-type input source selection */ 9654 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 9655 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 9656 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 9657 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 9658 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 9659 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 9660 /* Input mixer2 */ 9661 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 9662 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 9663 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 9664 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 9665 /* Input mixer3 */ 9666 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 9667 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 9668 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 9669 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 9670 9671 { } 9672}; 9673 9674static struct hda_verb alc262_eapd_verbs[] = { 9675 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 9676 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 9677 { } 9678}; 9679 9680static struct hda_verb alc262_hippo_unsol_verbs[] = { 9681 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 9682 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9683 {} 9684}; 9685 9686static struct hda_verb alc262_hippo1_unsol_verbs[] = { 9687 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 9688 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 9689 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 9690 9691 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 9692 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9693 {} 9694}; 9695 9696static struct hda_verb alc262_sony_unsol_verbs[] = { 9697 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 9698 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 9699 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, // Front Mic 9700 9701 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 9702 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9703 {} 9704}; 9705 9706static struct hda_input_mux alc262_dmic_capture_source = { 9707 .num_items = 2, 9708 .items = { 9709 { "Int DMic", 0x9 }, 9710 { "Mic", 0x0 }, 9711 }, 9712}; 9713 9714static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = { 9715 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9716 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 9717 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 9718 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9719 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9720 { } /* end */ 9721}; 9722 9723static struct hda_verb alc262_toshiba_s06_verbs[] = { 9724 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 9725 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9726 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9727 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 9728 {0x22, AC_VERB_SET_CONNECT_SEL, 0x09}, 9729 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 9730 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 9731 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 9732 {} 9733}; 9734 9735static void alc262_dmic_automute(struct hda_codec *codec) 9736{ 9737 unsigned int present; 9738 9739 present = snd_hda_codec_read(codec, 0x18, 0, 9740 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 9741 snd_hda_codec_write(codec, 0x22, 0, 9742 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x09); 9743} 9744 9745/* toggle speaker-output according to the hp-jack state */ 9746static void alc262_toshiba_s06_speaker_automute(struct hda_codec *codec) 9747{ 9748 unsigned int present; 9749 unsigned char bits; 9750 9751 present = snd_hda_codec_read(codec, 0x15, 0, 9752 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 9753 bits = present ? 0 : PIN_OUT; 9754 snd_hda_codec_write(codec, 0x14, 0, 9755 AC_VERB_SET_PIN_WIDGET_CONTROL, bits); 9756} 9757 9758 9759 9760/* unsolicited event for HP jack sensing */ 9761static void alc262_toshiba_s06_unsol_event(struct hda_codec *codec, 9762 unsigned int res) 9763{ 9764 if ((res >> 26) == ALC880_HP_EVENT) 9765 alc262_toshiba_s06_speaker_automute(codec); 9766 if ((res >> 26) == ALC880_MIC_EVENT) 9767 alc262_dmic_automute(codec); 9768 9769} 9770 9771static void alc262_toshiba_s06_init_hook(struct hda_codec *codec) 9772{ 9773 alc262_toshiba_s06_speaker_automute(codec); 9774 alc262_dmic_automute(codec); 9775} 9776 9777/* mute/unmute internal speaker according to the hp jack and mute state */ 9778static void alc262_hippo_automute(struct hda_codec *codec) 9779{ 9780 struct alc_spec *spec = codec->spec; 9781 unsigned int mute; 9782 unsigned int present; 9783 9784 /* need to execute and sync at first */ 9785 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0); 9786 present = snd_hda_codec_read(codec, 0x15, 0, 9787 AC_VERB_GET_PIN_SENSE, 0); 9788 spec->jack_present = (present & 0x80000000) != 0; 9789 if (spec->jack_present) { 9790 /* mute internal speaker */ 9791 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9792 HDA_AMP_MUTE, HDA_AMP_MUTE); 9793 } else { 9794 /* unmute internal speaker if necessary */ 9795 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0); 9796 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9797 HDA_AMP_MUTE, mute); 9798 } 9799} 9800 9801/* unsolicited event for HP jack sensing */ 9802static void alc262_hippo_unsol_event(struct hda_codec *codec, 9803 unsigned int res) 9804{ 9805 if ((res >> 26) != ALC880_HP_EVENT) 9806 return; 9807 alc262_hippo_automute(codec); 9808} 9809 9810static void alc262_hippo1_automute(struct hda_codec *codec) 9811{ 9812 unsigned int mute; 9813 unsigned int present; 9814 9815 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0); 9816 present = snd_hda_codec_read(codec, 0x1b, 0, 9817 AC_VERB_GET_PIN_SENSE, 0); 9818 present = (present & 0x80000000) != 0; 9819 if (present) { 9820 /* mute internal speaker */ 9821 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9822 HDA_AMP_MUTE, HDA_AMP_MUTE); 9823 } else { 9824 /* unmute internal speaker if necessary */ 9825 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0); 9826 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9827 HDA_AMP_MUTE, mute); 9828 } 9829} 9830 9831/* unsolicited event for HP jack sensing */ 9832static void alc262_hippo1_unsol_event(struct hda_codec *codec, 9833 unsigned int res) 9834{ 9835 if ((res >> 26) != ALC880_HP_EVENT) 9836 return; 9837 alc262_hippo1_automute(codec); 9838} 9839 9840/* 9841 * nec model 9842 * 0x15 = headphone 9843 * 0x16 = internal speaker 9844 * 0x18 = external mic 9845 */ 9846 9847static struct snd_kcontrol_new alc262_nec_mixer[] = { 9848 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 9849 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT), 9850 9851 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9852 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9853 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 9854 9855 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 9856 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 9857 { } /* end */ 9858}; 9859 9860static struct hda_verb alc262_nec_verbs[] = { 9861 /* Unmute Speaker */ 9862 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 9863 9864 /* Headphone */ 9865 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 9866 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9867 9868 /* External mic to headphone */ 9869 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9870 /* External mic to speaker */ 9871 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9872 {} 9873}; 9874 9875/* 9876 * fujitsu model 9877 * 0x14 = headphone/spdif-out, 0x15 = internal speaker, 9878 * 0x1b = port replicator headphone out 9879 */ 9880 9881#define ALC_HP_EVENT 0x37 9882 9883static struct hda_verb alc262_fujitsu_unsol_verbs[] = { 9884 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT}, 9885 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9886 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT}, 9887 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9888 {} 9889}; 9890 9891static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = { 9892 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT}, 9893 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9894 {} 9895}; 9896 9897static struct hda_input_mux alc262_fujitsu_capture_source = { 9898 .num_items = 3, 9899 .items = { 9900 { "Mic", 0x0 }, 9901 { "Int Mic", 0x1 }, 9902 { "CD", 0x4 }, 9903 }, 9904}; 9905 9906static struct hda_input_mux alc262_HP_capture_source = { 9907 .num_items = 5, 9908 .items = { 9909 { "Mic", 0x0 }, 9910 { "Front Mic", 0x1 }, 9911 { "Line", 0x2 }, 9912 { "CD", 0x4 }, 9913 { "AUX IN", 0x6 }, 9914 }, 9915}; 9916 9917static struct hda_input_mux alc262_HP_D7000_capture_source = { 9918 .num_items = 4, 9919 .items = { 9920 { "Mic", 0x0 }, 9921 { "Front Mic", 0x2 }, 9922 { "Line", 0x1 }, 9923 { "CD", 0x4 }, 9924 }, 9925}; 9926 9927/* mute/unmute internal speaker according to the hp jacks and mute state */ 9928static void alc262_fujitsu_automute(struct hda_codec *codec, int force) 9929{ 9930 struct alc_spec *spec = codec->spec; 9931 unsigned int mute; 9932 9933 if (force || !spec->sense_updated) { 9934 unsigned int present; 9935 /* need to execute and sync at first */ 9936 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0); 9937 /* check laptop HP jack */ 9938 present = snd_hda_codec_read(codec, 0x14, 0, 9939 AC_VERB_GET_PIN_SENSE, 0); 9940 /* need to execute and sync at first */ 9941 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0); 9942 /* check docking HP jack */ 9943 present |= snd_hda_codec_read(codec, 0x1b, 0, 9944 AC_VERB_GET_PIN_SENSE, 0); 9945 if (present & AC_PINSENSE_PRESENCE) 9946 spec->jack_present = 1; 9947 else 9948 spec->jack_present = 0; 9949 spec->sense_updated = 1; 9950 } 9951 /* unmute internal speaker only if both HPs are unplugged and 9952 * master switch is on 9953 */ 9954 if (spec->jack_present) 9955 mute = HDA_AMP_MUTE; 9956 else 9957 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0); 9958 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 9959 HDA_AMP_MUTE, mute); 9960} 9961 9962/* unsolicited event for HP jack sensing */ 9963static void alc262_fujitsu_unsol_event(struct hda_codec *codec, 9964 unsigned int res) 9965{ 9966 if ((res >> 26) != ALC_HP_EVENT) 9967 return; 9968 alc262_fujitsu_automute(codec, 1); 9969} 9970 9971static void alc262_fujitsu_init_hook(struct hda_codec *codec) 9972{ 9973 alc262_fujitsu_automute(codec, 1); 9974} 9975 9976/* bind volumes of both NID 0x0c and 0x0d */ 9977static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = { 9978 .ops = &snd_hda_bind_vol, 9979 .values = { 9980 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT), 9981 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT), 9982 0 9983 }, 9984}; 9985 9986/* mute/unmute internal speaker according to the hp jack and mute state */ 9987static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force) 9988{ 9989 struct alc_spec *spec = codec->spec; 9990 unsigned int mute; 9991 9992 if (force || !spec->sense_updated) { 9993 unsigned int present_int_hp; 9994 /* need to execute and sync at first */ 9995 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0); 9996 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0, 9997 AC_VERB_GET_PIN_SENSE, 0); 9998 spec->jack_present = (present_int_hp & 0x80000000) != 0; 9999 spec->sense_updated = 1; 10000 } 10001 if (spec->jack_present) { 10002 /* mute internal speaker */ 10003 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 10004 HDA_AMP_MUTE, HDA_AMP_MUTE); 10005 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 10006 HDA_AMP_MUTE, HDA_AMP_MUTE); 10007 } else { 10008 /* unmute internal speaker if necessary */ 10009 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0); 10010 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 10011 HDA_AMP_MUTE, mute); 10012 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 10013 HDA_AMP_MUTE, mute); 10014 } 10015} 10016 10017/* unsolicited event for HP jack sensing */ 10018static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec, 10019 unsigned int res) 10020{ 10021 if ((res >> 26) != ALC_HP_EVENT) 10022 return; 10023 alc262_lenovo_3000_automute(codec, 1); 10024} 10025 10026/* bind hp and internal speaker mute (with plug check) */ 10027static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol, 10028 struct snd_ctl_elem_value *ucontrol) 10029{ 10030 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 10031 long *valp = ucontrol->value.integer.value; 10032 int change; 10033 10034 change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 10035 HDA_AMP_MUTE, 10036 valp ? 0 : HDA_AMP_MUTE); 10037 change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 10038 HDA_AMP_MUTE, 10039 valp ? 0 : HDA_AMP_MUTE); 10040 10041 if (change) 10042 alc262_fujitsu_automute(codec, 0); 10043 return change; 10044} 10045 10046static struct snd_kcontrol_new alc262_fujitsu_mixer[] = { 10047 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol), 10048 { 10049 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 10050 .name = "Master Playback Switch", 10051 .info = snd_hda_mixer_amp_switch_info, 10052 .get = snd_hda_mixer_amp_switch_get, 10053 .put = alc262_fujitsu_master_sw_put, 10054 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 10055 }, 10056 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 10057 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 10058 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 10059 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 10060 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 10061 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 10062 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 10063 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 10064 { } /* end */ 10065}; 10066 10067/* bind hp and internal speaker mute (with plug check) */ 10068static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol, 10069 struct snd_ctl_elem_value *ucontrol) 10070{ 10071 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 10072 long *valp = ucontrol->value.integer.value; 10073 int change; 10074 10075 change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 10076 HDA_AMP_MUTE, 10077 valp ? 0 : HDA_AMP_MUTE); 10078 10079 if (change) 10080 alc262_lenovo_3000_automute(codec, 0); 10081 return change; 10082} 10083 10084static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = { 10085 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol), 10086 { 10087 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 10088 .name = "Master Playback Switch", 10089 .info = snd_hda_mixer_amp_switch_info, 10090 .get = snd_hda_mixer_amp_switch_get, 10091 .put = alc262_lenovo_3000_master_sw_put, 10092 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT), 10093 }, 10094 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 10095 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 10096 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 10097 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 10098 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 10099 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 10100 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 10101 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 10102 { } /* end */ 10103}; 10104 10105static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = { 10106 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol), 10107 { 10108 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 10109 .name = "Master Playback Switch", 10110 .info = snd_hda_mixer_amp_switch_info, 10111 .get = snd_hda_mixer_amp_switch_get, 10112 .put = alc262_sony_master_sw_put, 10113 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT), 10114 }, 10115 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 10116 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 10117 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 10118 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 10119 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 10120 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 10121 { } /* end */ 10122}; 10123 10124/* additional init verbs for Benq laptops */ 10125static struct hda_verb alc262_EAPD_verbs[] = { 10126 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 10127 {0x20, AC_VERB_SET_PROC_COEF, 0x3070}, 10128 {} 10129}; 10130 10131static struct hda_verb alc262_benq_t31_EAPD_verbs[] = { 10132 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 10133 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 10134 10135 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 10136 {0x20, AC_VERB_SET_PROC_COEF, 0x3050}, 10137 {} 10138}; 10139 10140/* Samsung Q1 Ultra Vista model setup */ 10141static struct snd_kcontrol_new alc262_ultra_mixer[] = { 10142 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 10143 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT), 10144 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 10145 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 10146 HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT), 10147 HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT), 10148 { } /* end */ 10149}; 10150 10151static struct hda_verb alc262_ultra_verbs[] = { 10152 /* output mixer */ 10153 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 10154 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 10155 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10156 /* speaker */ 10157 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 10158 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10159 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10160 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 10161 /* HP */ 10162 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 10163 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10164 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10165 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 10166 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 10167 /* internal mic */ 10168 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 10169 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 10170 /* ADC, choose mic */ 10171 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 10172 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 10173 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10174 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 10175 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 10176 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 10177 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 10178 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 10179 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 10180 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)}, 10181 {} 10182}; 10183 10184/* mute/unmute internal speaker according to the hp jack and mute state */ 10185static void alc262_ultra_automute(struct hda_codec *codec) 10186{ 10187 struct alc_spec *spec = codec->spec; 10188 unsigned int mute; 10189 10190 mute = 0; 10191 /* auto-mute only when HP is used as HP */ 10192 if (!spec->cur_mux[0]) { 10193 unsigned int present; 10194 /* need to execute and sync at first */ 10195 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0); 10196 present = snd_hda_codec_read(codec, 0x15, 0, 10197 AC_VERB_GET_PIN_SENSE, 0); 10198 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0; 10199 if (spec->jack_present) 10200 mute = HDA_AMP_MUTE; 10201 } 10202 /* mute/unmute internal speaker */ 10203 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 10204 HDA_AMP_MUTE, mute); 10205 /* mute/unmute HP */ 10206 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 10207 HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE); 10208} 10209 10210/* unsolicited event for HP jack sensing */ 10211static void alc262_ultra_unsol_event(struct hda_codec *codec, 10212 unsigned int res) 10213{ 10214 if ((res >> 26) != ALC880_HP_EVENT) 10215 return; 10216 alc262_ultra_automute(codec); 10217} 10218 10219static struct hda_input_mux alc262_ultra_capture_source = { 10220 .num_items = 2, 10221 .items = { 10222 { "Mic", 0x1 }, 10223 { "Headphone", 0x7 }, 10224 }, 10225}; 10226 10227static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol, 10228 struct snd_ctl_elem_value *ucontrol) 10229{ 10230 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 10231 struct alc_spec *spec = codec->spec; 10232 int ret; 10233 10234 ret = alc_mux_enum_put(kcontrol, ucontrol); 10235 if (!ret) 10236 return 0; 10237 /* reprogram the HP pin as mic or HP according to the input source */ 10238 snd_hda_codec_write_cache(codec, 0x15, 0, 10239 AC_VERB_SET_PIN_WIDGET_CONTROL, 10240 spec->cur_mux[0] ? PIN_VREF80 : PIN_HP); 10241 alc262_ultra_automute(codec); /* mute/unmute HP */ 10242 return ret; 10243} 10244 10245static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = { 10246 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT), 10247 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT), 10248 { 10249 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 10250 .name = "Capture Source", 10251 .info = alc_mux_enum_info, 10252 .get = alc_mux_enum_get, 10253 .put = alc262_ultra_mux_enum_put, 10254 }, 10255 { } /* end */ 10256}; 10257 10258/* add playback controls from the parsed DAC table */ 10259static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec, 10260 const struct auto_pin_cfg *cfg) 10261{ 10262 hda_nid_t nid; 10263 int err; 10264 10265 spec->multiout.num_dacs = 1; /* only use one dac */ 10266 spec->multiout.dac_nids = spec->private_dac_nids; 10267 spec->multiout.dac_nids[0] = 2; 10268 10269 nid = cfg->line_out_pins[0]; 10270 if (nid) { 10271 err = add_control(spec, ALC_CTL_WIDGET_VOL, 10272 "Front Playback Volume", 10273 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT)); 10274 if (err < 0) 10275 return err; 10276 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 10277 "Front Playback Switch", 10278 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 10279 if (err < 0) 10280 return err; 10281 } 10282 10283 nid = cfg->speaker_pins[0]; 10284 if (nid) { 10285 if (nid == 0x16) { 10286 err = add_control(spec, ALC_CTL_WIDGET_VOL, 10287 "Speaker Playback Volume", 10288 HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, 10289 HDA_OUTPUT)); 10290 if (err < 0) 10291 return err; 10292 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 10293 "Speaker Playback Switch", 10294 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 10295 HDA_OUTPUT)); 10296 if (err < 0) 10297 return err; 10298 } else { 10299 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 10300 "Speaker Playback Switch", 10301 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 10302 HDA_OUTPUT)); 10303 if (err < 0) 10304 return err; 10305 } 10306 } 10307 nid = cfg->hp_pins[0]; 10308 if (nid) { 10309 /* spec->multiout.hp_nid = 2; */ 10310 if (nid == 0x16) { 10311 err = add_control(spec, ALC_CTL_WIDGET_VOL, 10312 "Headphone Playback Volume", 10313 HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, 10314 HDA_OUTPUT)); 10315 if (err < 0) 10316 return err; 10317 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 10318 "Headphone Playback Switch", 10319 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 10320 HDA_OUTPUT)); 10321 if (err < 0) 10322 return err; 10323 } else { 10324 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 10325 "Headphone Playback Switch", 10326 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 10327 HDA_OUTPUT)); 10328 if (err < 0) 10329 return err; 10330 } 10331 } 10332 return 0; 10333} 10334 10335/* identical with ALC880 */ 10336#define alc262_auto_create_analog_input_ctls \ 10337 alc880_auto_create_analog_input_ctls 10338 10339/* 10340 * generic initialization of ADC, input mixers and output mixers 10341 */ 10342static struct hda_verb alc262_volume_init_verbs[] = { 10343 /* 10344 * Unmute ADC0-2 and set the default input to mic-in 10345 */ 10346 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 10347 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10348 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 10349 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10350 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 10351 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10352 10353 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 10354 * mixer widget 10355 * Note: PASD motherboards uses the Line In 2 as the input for 10356 * front panel mic (mic 2) 10357 */ 10358 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 10359 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 10360 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 10361 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 10362 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 10363 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 10364 10365 /* 10366 * Set up output mixers (0x0c - 0x0f) 10367 */ 10368 /* set vol=0 to output mixers */ 10369 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10370 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10371 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10372 10373 /* set up input amps for analog loopback */ 10374 /* Amp Indices: DAC = 0, mixer = 1 */ 10375 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10376 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10377 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10378 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10379 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10380 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10381 10382 /* FIXME: use matrix-type input source selection */ 10383 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 10384 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 10385 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 10386 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 10387 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 10388 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 10389 /* Input mixer2 */ 10390 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 10391 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 10392 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 10393 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 10394 /* Input mixer3 */ 10395 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 10396 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 10397 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 10398 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 10399 10400 { } 10401}; 10402 10403static struct hda_verb alc262_HP_BPC_init_verbs[] = { 10404 /* 10405 * Unmute ADC0-2 and set the default input to mic-in 10406 */ 10407 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 10408 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10409 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 10410 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10411 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 10412 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10413 10414 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 10415 * mixer widget 10416 * Note: PASD motherboards uses the Line In 2 as the input for 10417 * front panel mic (mic 2) 10418 */ 10419 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 10420 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 10421 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 10422 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 10423 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 10424 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 10425 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 10426 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 10427 10428 /* 10429 * Set up output mixers (0x0c - 0x0e) 10430 */ 10431 /* set vol=0 to output mixers */ 10432 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10433 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10434 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10435 10436 /* set up input amps for analog loopback */ 10437 /* Amp Indices: DAC = 0, mixer = 1 */ 10438 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10439 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10440 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10441 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10442 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10443 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10444 10445 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 10446 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 10447 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 10448 10449 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 10450 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 10451 10452 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 10453 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 10454 10455 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 10456 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 10457 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 10458 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 10459 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 10460 10461 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, 10462 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 10463 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 10464 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, 10465 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 10466 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 10467 10468 10469 /* FIXME: use matrix-type input source selection */ 10470 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 10471 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 10472 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 10473 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, 10474 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, 10475 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, 10476 /* Input mixer2 */ 10477 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 10478 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, 10479 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, 10480 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, 10481 /* Input mixer3 */ 10482 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 10483 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, 10484 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, 10485 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, 10486 10487 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 10488 10489 { } 10490}; 10491 10492static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = { 10493 /* 10494 * Unmute ADC0-2 and set the default input to mic-in 10495 */ 10496 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 10497 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10498 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 10499 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10500 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 10501 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10502 10503 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 10504 * mixer widget 10505 * Note: PASD motherboards uses the Line In 2 as the input for front 10506 * panel mic (mic 2) 10507 */ 10508 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 10509 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 10510 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 10511 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 10512 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 10513 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 10514 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 10515 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 10516 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 10517 /* 10518 * Set up output mixers (0x0c - 0x0e) 10519 */ 10520 /* set vol=0 to output mixers */ 10521 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10522 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10523 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10524 10525 /* set up input amps for analog loopback */ 10526 /* Amp Indices: DAC = 0, mixer = 1 */ 10527 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10528 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10529 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10530 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10531 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10532 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10533 10534 10535 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP */ 10536 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Mono */ 10537 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* rear MIC */ 10538 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* Line in */ 10539 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Front MIC */ 10540 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Line out */ 10541 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD in */ 10542 10543 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 10544 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 10545 10546 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 10547 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 10548 10549 /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */ 10550 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 10551 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 10552 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, 10553 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 10554 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 10555 10556 /* FIXME: use matrix-type input source selection */ 10557 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 10558 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 10559 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/ 10560 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/ 10561 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/ 10562 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/ 10563 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/ 10564 /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */ 10565 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/ 10566 /* Input mixer2 */ 10567 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 10568 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 10569 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, 10570 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, 10571 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, 10572 /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */ 10573 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, 10574 /* Input mixer3 */ 10575 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 10576 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 10577 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, 10578 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, 10579 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, 10580 /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */ 10581 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, 10582 10583 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 10584 10585 { } 10586}; 10587 10588static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = { 10589 10590 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Front Speaker */ 10591 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 10592 {0x14, AC_VERB_SET_CONNECT_SEL, 0x01}, 10593 10594 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* MIC jack */ 10595 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Front MIC */ 10596 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) }, 10597 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) }, 10598 10599 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP jack */ 10600 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 10601 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 10602 {} 10603}; 10604 10605 10606#ifdef CONFIG_SND_HDA_POWER_SAVE 10607#define alc262_loopbacks alc880_loopbacks 10608#endif 10609 10610/* pcm configuration: identiacal with ALC880 */ 10611#define alc262_pcm_analog_playback alc880_pcm_analog_playback 10612#define alc262_pcm_analog_capture alc880_pcm_analog_capture 10613#define alc262_pcm_digital_playback alc880_pcm_digital_playback 10614#define alc262_pcm_digital_capture alc880_pcm_digital_capture 10615 10616/* 10617 * BIOS auto configuration 10618 */ 10619static int alc262_parse_auto_config(struct hda_codec *codec) 10620{ 10621 struct alc_spec *spec = codec->spec; 10622 int err; 10623 static hda_nid_t alc262_ignore[] = { 0x1d, 0 }; 10624 10625 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 10626 alc262_ignore); 10627 if (err < 0) 10628 return err; 10629 if (!spec->autocfg.line_outs) { 10630 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) { 10631 spec->multiout.max_channels = 2; 10632 spec->no_analog = 1; 10633 goto dig_only; 10634 } 10635 return 0; /* can't find valid BIOS pin config */ 10636 } 10637 err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg); 10638 if (err < 0) 10639 return err; 10640 err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg); 10641 if (err < 0) 10642 return err; 10643 10644 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 10645 10646 dig_only: 10647 if (spec->autocfg.dig_outs) { 10648 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID; 10649 spec->dig_out_type = spec->autocfg.dig_out_type[0]; 10650 } 10651 if (spec->autocfg.dig_in_pin) 10652 spec->dig_in_nid = ALC262_DIGIN_NID; 10653 10654 if (spec->kctls.list) 10655 add_mixer(spec, spec->kctls.list); 10656 10657 add_verb(spec, alc262_volume_init_verbs); 10658 spec->num_mux_defs = 1; 10659 spec->input_mux = &spec->private_imux[0]; 10660 10661 err = alc_auto_add_mic_boost(codec); 10662 if (err < 0) 10663 return err; 10664 10665 store_pin_configs(codec); 10666 return 1; 10667} 10668 10669#define alc262_auto_init_multi_out alc882_auto_init_multi_out 10670#define alc262_auto_init_hp_out alc882_auto_init_hp_out 10671#define alc262_auto_init_analog_input alc882_auto_init_analog_input 10672#define alc262_auto_init_input_src alc882_auto_init_input_src 10673 10674 10675/* init callback for auto-configuration model -- overriding the default init */ 10676static void alc262_auto_init(struct hda_codec *codec) 10677{ 10678 struct alc_spec *spec = codec->spec; 10679 alc262_auto_init_multi_out(codec); 10680 alc262_auto_init_hp_out(codec); 10681 alc262_auto_init_analog_input(codec); 10682 alc262_auto_init_input_src(codec); 10683 if (spec->unsol_event) 10684 alc_inithook(codec); 10685} 10686 10687/* 10688 * configuration and preset 10689 */ 10690static const char *alc262_models[ALC262_MODEL_LAST] = { 10691 [ALC262_BASIC] = "basic", 10692 [ALC262_HIPPO] = "hippo", 10693 [ALC262_HIPPO_1] = "hippo_1", 10694 [ALC262_FUJITSU] = "fujitsu", 10695 [ALC262_HP_BPC] = "hp-bpc", 10696 [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000", 10697 [ALC262_HP_TC_T5735] = "hp-tc-t5735", 10698 [ALC262_HP_RP5700] = "hp-rp5700", 10699 [ALC262_BENQ_ED8] = "benq", 10700 [ALC262_BENQ_T31] = "benq-t31", 10701 [ALC262_SONY_ASSAMD] = "sony-assamd", 10702 [ALC262_TOSHIBA_S06] = "toshiba-s06", 10703 [ALC262_TOSHIBA_RX1] = "toshiba-rx1", 10704 [ALC262_ULTRA] = "ultra", 10705 [ALC262_LENOVO_3000] = "lenovo-3000", 10706 [ALC262_NEC] = "nec", 10707 [ALC262_TYAN] = "tyan", 10708 [ALC262_AUTO] = "auto", 10709}; 10710 10711static struct snd_pci_quirk alc262_cfg_tbl[] = { 10712 SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO), 10713 SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC), 10714 SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series", 10715 ALC262_HP_BPC), 10716 SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series", 10717 ALC262_HP_BPC), 10718 SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL), 10719 SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF), 10720 SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL), 10721 SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF), 10722 SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL), 10723 SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF), 10724 SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL), 10725 SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF), 10726 SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC), 10727 SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC), 10728 SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC), 10729 SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735", 10730 ALC262_HP_TC_T5735), 10731 SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700), 10732 SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD), 10733 SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO), 10734 SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD), 10735 SND_PCI_QUIRK(0x104d, 0x900e, "Sony ASSAMD", ALC262_SONY_ASSAMD), 10736 SND_PCI_QUIRK(0x104d, 0x9015, "Sony 0x9015", ALC262_SONY_ASSAMD), 10737 SND_PCI_QUIRK(0x104d, 0x9033, "Sony VAIO VGN-SR19XN", 10738 ALC262_SONY_ASSAMD), 10739 SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1", 10740 ALC262_TOSHIBA_RX1), 10741 SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06), 10742 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU), 10743 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU), 10744 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN), 10745 SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1", 10746 ALC262_ULTRA), 10747 SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO), 10748 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000), 10749 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8), 10750 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31), 10751 SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1), 10752 {} 10753}; 10754 10755static struct alc_config_preset alc262_presets[] = { 10756 [ALC262_BASIC] = { 10757 .mixers = { alc262_base_mixer }, 10758 .init_verbs = { alc262_init_verbs }, 10759 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10760 .dac_nids = alc262_dac_nids, 10761 .hp_nid = 0x03, 10762 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10763 .channel_mode = alc262_modes, 10764 .input_mux = &alc262_capture_source, 10765 }, 10766 [ALC262_HIPPO] = { 10767 .mixers = { alc262_base_mixer }, 10768 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs}, 10769 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10770 .dac_nids = alc262_dac_nids, 10771 .hp_nid = 0x03, 10772 .dig_out_nid = ALC262_DIGOUT_NID, 10773 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10774 .channel_mode = alc262_modes, 10775 .input_mux = &alc262_capture_source, 10776 .unsol_event = alc262_hippo_unsol_event, 10777 .init_hook = alc262_hippo_automute, 10778 }, 10779 [ALC262_HIPPO_1] = { 10780 .mixers = { alc262_hippo1_mixer }, 10781 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs}, 10782 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10783 .dac_nids = alc262_dac_nids, 10784 .hp_nid = 0x02, 10785 .dig_out_nid = ALC262_DIGOUT_NID, 10786 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10787 .channel_mode = alc262_modes, 10788 .input_mux = &alc262_capture_source, 10789 .unsol_event = alc262_hippo1_unsol_event, 10790 .init_hook = alc262_hippo1_automute, 10791 }, 10792 [ALC262_FUJITSU] = { 10793 .mixers = { alc262_fujitsu_mixer }, 10794 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs, 10795 alc262_fujitsu_unsol_verbs }, 10796 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10797 .dac_nids = alc262_dac_nids, 10798 .hp_nid = 0x03, 10799 .dig_out_nid = ALC262_DIGOUT_NID, 10800 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10801 .channel_mode = alc262_modes, 10802 .input_mux = &alc262_fujitsu_capture_source, 10803 .unsol_event = alc262_fujitsu_unsol_event, 10804 .init_hook = alc262_fujitsu_init_hook, 10805 }, 10806 [ALC262_HP_BPC] = { 10807 .mixers = { alc262_HP_BPC_mixer }, 10808 .init_verbs = { alc262_HP_BPC_init_verbs }, 10809 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10810 .dac_nids = alc262_dac_nids, 10811 .hp_nid = 0x03, 10812 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10813 .channel_mode = alc262_modes, 10814 .input_mux = &alc262_HP_capture_source, 10815 .unsol_event = alc262_hp_bpc_unsol_event, 10816 .init_hook = alc262_hp_bpc_automute, 10817 }, 10818 [ALC262_HP_BPC_D7000_WF] = { 10819 .mixers = { alc262_HP_BPC_WildWest_mixer }, 10820 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs }, 10821 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10822 .dac_nids = alc262_dac_nids, 10823 .hp_nid = 0x03, 10824 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10825 .channel_mode = alc262_modes, 10826 .input_mux = &alc262_HP_D7000_capture_source, 10827 .unsol_event = alc262_hp_wildwest_unsol_event, 10828 .init_hook = alc262_hp_wildwest_automute, 10829 }, 10830 [ALC262_HP_BPC_D7000_WL] = { 10831 .mixers = { alc262_HP_BPC_WildWest_mixer, 10832 alc262_HP_BPC_WildWest_option_mixer }, 10833 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs }, 10834 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10835 .dac_nids = alc262_dac_nids, 10836 .hp_nid = 0x03, 10837 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10838 .channel_mode = alc262_modes, 10839 .input_mux = &alc262_HP_D7000_capture_source, 10840 .unsol_event = alc262_hp_wildwest_unsol_event, 10841 .init_hook = alc262_hp_wildwest_automute, 10842 }, 10843 [ALC262_HP_TC_T5735] = { 10844 .mixers = { alc262_hp_t5735_mixer }, 10845 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs }, 10846 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10847 .dac_nids = alc262_dac_nids, 10848 .hp_nid = 0x03, 10849 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10850 .channel_mode = alc262_modes, 10851 .input_mux = &alc262_capture_source, 10852 .unsol_event = alc262_hp_t5735_unsol_event, 10853 .init_hook = alc262_hp_t5735_init_hook, 10854 }, 10855 [ALC262_HP_RP5700] = { 10856 .mixers = { alc262_hp_rp5700_mixer }, 10857 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs }, 10858 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10859 .dac_nids = alc262_dac_nids, 10860 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10861 .channel_mode = alc262_modes, 10862 .input_mux = &alc262_hp_rp5700_capture_source, 10863 }, 10864 [ALC262_BENQ_ED8] = { 10865 .mixers = { alc262_base_mixer }, 10866 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs }, 10867 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10868 .dac_nids = alc262_dac_nids, 10869 .hp_nid = 0x03, 10870 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10871 .channel_mode = alc262_modes, 10872 .input_mux = &alc262_capture_source, 10873 }, 10874 [ALC262_SONY_ASSAMD] = { 10875 .mixers = { alc262_sony_mixer }, 10876 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs}, 10877 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10878 .dac_nids = alc262_dac_nids, 10879 .hp_nid = 0x02, 10880 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10881 .channel_mode = alc262_modes, 10882 .input_mux = &alc262_capture_source, 10883 .unsol_event = alc262_hippo_unsol_event, 10884 .init_hook = alc262_hippo_automute, 10885 }, 10886 [ALC262_BENQ_T31] = { 10887 .mixers = { alc262_benq_t31_mixer }, 10888 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs }, 10889 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10890 .dac_nids = alc262_dac_nids, 10891 .hp_nid = 0x03, 10892 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10893 .channel_mode = alc262_modes, 10894 .input_mux = &alc262_capture_source, 10895 .unsol_event = alc262_hippo_unsol_event, 10896 .init_hook = alc262_hippo_automute, 10897 }, 10898 [ALC262_ULTRA] = { 10899 .mixers = { alc262_ultra_mixer }, 10900 .cap_mixer = alc262_ultra_capture_mixer, 10901 .init_verbs = { alc262_ultra_verbs }, 10902 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10903 .dac_nids = alc262_dac_nids, 10904 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10905 .channel_mode = alc262_modes, 10906 .input_mux = &alc262_ultra_capture_source, 10907 .adc_nids = alc262_adc_nids, /* ADC0 */ 10908 .capsrc_nids = alc262_capsrc_nids, 10909 .num_adc_nids = 1, /* single ADC */ 10910 .unsol_event = alc262_ultra_unsol_event, 10911 .init_hook = alc262_ultra_automute, 10912 }, 10913 [ALC262_LENOVO_3000] = { 10914 .mixers = { alc262_lenovo_3000_mixer }, 10915 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs, 10916 alc262_lenovo_3000_unsol_verbs }, 10917 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10918 .dac_nids = alc262_dac_nids, 10919 .hp_nid = 0x03, 10920 .dig_out_nid = ALC262_DIGOUT_NID, 10921 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10922 .channel_mode = alc262_modes, 10923 .input_mux = &alc262_fujitsu_capture_source, 10924 .unsol_event = alc262_lenovo_3000_unsol_event, 10925 }, 10926 [ALC262_NEC] = { 10927 .mixers = { alc262_nec_mixer }, 10928 .init_verbs = { alc262_nec_verbs }, 10929 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10930 .dac_nids = alc262_dac_nids, 10931 .hp_nid = 0x03, 10932 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10933 .channel_mode = alc262_modes, 10934 .input_mux = &alc262_capture_source, 10935 }, 10936 [ALC262_TOSHIBA_S06] = { 10937 .mixers = { alc262_toshiba_s06_mixer }, 10938 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs, 10939 alc262_eapd_verbs }, 10940 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10941 .capsrc_nids = alc262_dmic_capsrc_nids, 10942 .dac_nids = alc262_dac_nids, 10943 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */ 10944 .dig_out_nid = ALC262_DIGOUT_NID, 10945 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10946 .channel_mode = alc262_modes, 10947 .input_mux = &alc262_dmic_capture_source, 10948 .unsol_event = alc262_toshiba_s06_unsol_event, 10949 .init_hook = alc262_toshiba_s06_init_hook, 10950 }, 10951 [ALC262_TOSHIBA_RX1] = { 10952 .mixers = { alc262_toshiba_rx1_mixer }, 10953 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs }, 10954 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10955 .dac_nids = alc262_dac_nids, 10956 .hp_nid = 0x03, 10957 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10958 .channel_mode = alc262_modes, 10959 .input_mux = &alc262_capture_source, 10960 .unsol_event = alc262_hippo_unsol_event, 10961 .init_hook = alc262_hippo_automute, 10962 }, 10963 [ALC262_TYAN] = { 10964 .mixers = { alc262_tyan_mixer }, 10965 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs}, 10966 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10967 .dac_nids = alc262_dac_nids, 10968 .hp_nid = 0x02, 10969 .dig_out_nid = ALC262_DIGOUT_NID, 10970 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10971 .channel_mode = alc262_modes, 10972 .input_mux = &alc262_capture_source, 10973 .unsol_event = alc262_tyan_unsol_event, 10974 .init_hook = alc262_tyan_automute, 10975 }, 10976}; 10977 10978static int patch_alc262(struct hda_codec *codec) 10979{ 10980 struct alc_spec *spec; 10981 int board_config; 10982 int err; 10983 10984 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 10985 if (spec == NULL) 10986 return -ENOMEM; 10987 10988 codec->spec = spec; 10989#if 0 10990 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is 10991 * under-run 10992 */ 10993 { 10994 int tmp; 10995 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7); 10996 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0); 10997 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7); 10998 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80); 10999 } 11000#endif 11001 11002 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 11003 11004 board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST, 11005 alc262_models, 11006 alc262_cfg_tbl); 11007 11008 if (board_config < 0) { 11009 printk(KERN_INFO "hda_codec: Unknown model for ALC262, " 11010 "trying auto-probe from BIOS...\n"); 11011 board_config = ALC262_AUTO; 11012 } 11013 11014 if (board_config == ALC262_AUTO) { 11015 /* automatic parse from the BIOS config */ 11016 err = alc262_parse_auto_config(codec); 11017 if (err < 0) { 11018 alc_free(codec); 11019 return err; 11020 } else if (!err) { 11021 printk(KERN_INFO 11022 "hda_codec: Cannot set up configuration " 11023 "from BIOS. Using base mode...\n"); 11024 board_config = ALC262_BASIC; 11025 } 11026 } 11027 11028 err = snd_hda_attach_beep_device(codec, 0x1); 11029 if (err < 0) { 11030 alc_free(codec); 11031 return err; 11032 } 11033 11034 if (board_config != ALC262_AUTO) 11035 setup_preset(spec, &alc262_presets[board_config]); 11036 11037 spec->stream_name_analog = "ALC262 Analog"; 11038 spec->stream_analog_playback = &alc262_pcm_analog_playback; 11039 spec->stream_analog_capture = &alc262_pcm_analog_capture; 11040 11041 spec->stream_name_digital = "ALC262 Digital"; 11042 spec->stream_digital_playback = &alc262_pcm_digital_playback; 11043 spec->stream_digital_capture = &alc262_pcm_digital_capture; 11044 11045 spec->capture_style = CAPT_MIX; 11046 if (!spec->adc_nids && spec->input_mux) { 11047 /* check whether NID 0x07 is valid */ 11048 unsigned int wcap = get_wcaps(codec, 0x07); 11049 11050 /* get type */ 11051 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 11052 if (wcap != AC_WID_AUD_IN) { 11053 spec->adc_nids = alc262_adc_nids_alt; 11054 spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt); 11055 spec->capsrc_nids = alc262_capsrc_nids_alt; 11056 } else { 11057 spec->adc_nids = alc262_adc_nids; 11058 spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids); 11059 spec->capsrc_nids = alc262_capsrc_nids; 11060 } 11061 } 11062 if (!spec->cap_mixer && !spec->no_analog) 11063 set_capture_mixer(spec); 11064 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 11065 11066 spec->vmaster_nid = 0x0c; 11067 11068 codec->patch_ops = alc_patch_ops; 11069 if (board_config == ALC262_AUTO) 11070 spec->init_hook = alc262_auto_init; 11071#ifdef CONFIG_SND_HDA_POWER_SAVE 11072 if (!spec->loopback.amplist) 11073 spec->loopback.amplist = alc262_loopbacks; 11074#endif 11075 codec->proc_widget_hook = print_realtek_coef; 11076 11077 return 0; 11078} 11079 11080/* 11081 * ALC268 channel source setting (2 channel) 11082 */ 11083#define ALC268_DIGOUT_NID ALC880_DIGOUT_NID 11084#define alc268_modes alc260_modes 11085 11086static hda_nid_t alc268_dac_nids[2] = { 11087 /* front, hp */ 11088 0x02, 0x03 11089}; 11090 11091static hda_nid_t alc268_adc_nids[2] = { 11092 /* ADC0-1 */ 11093 0x08, 0x07 11094}; 11095 11096static hda_nid_t alc268_adc_nids_alt[1] = { 11097 /* ADC0 */ 11098 0x08 11099}; 11100 11101static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 }; 11102 11103static struct snd_kcontrol_new alc268_base_mixer[] = { 11104 /* output mixer control */ 11105 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT), 11106 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 11107 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT), 11108 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 11109 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 11110 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 11111 HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT), 11112 { } 11113}; 11114 11115/* bind Beep switches of both NID 0x0f and 0x10 */ 11116static struct hda_bind_ctls alc268_bind_beep_sw = { 11117 .ops = &snd_hda_bind_sw, 11118 .values = { 11119 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT), 11120 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT), 11121 0 11122 }, 11123}; 11124 11125static struct snd_kcontrol_new alc268_beep_mixer[] = { 11126 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT), 11127 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw), 11128 { } 11129}; 11130 11131static struct hda_verb alc268_eapd_verbs[] = { 11132 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 11133 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 11134 { } 11135}; 11136 11137/* Toshiba specific */ 11138#define alc268_toshiba_automute alc262_hippo_automute 11139 11140static struct hda_verb alc268_toshiba_verbs[] = { 11141 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 11142 { } /* end */ 11143}; 11144 11145static struct hda_input_mux alc268_acer_lc_capture_source = { 11146 .num_items = 2, 11147 .items = { 11148 { "i-Mic", 0x6 }, 11149 { "E-Mic", 0x0 }, 11150 }, 11151}; 11152 11153/* Acer specific */ 11154/* bind volumes of both NID 0x02 and 0x03 */ 11155static struct hda_bind_ctls alc268_acer_bind_master_vol = { 11156 .ops = &snd_hda_bind_vol, 11157 .values = { 11158 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT), 11159 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT), 11160 0 11161 }, 11162}; 11163 11164/* mute/unmute internal speaker according to the hp jack and mute state */ 11165static void alc268_acer_automute(struct hda_codec *codec, int force) 11166{ 11167 struct alc_spec *spec = codec->spec; 11168 unsigned int mute; 11169 11170 if (force || !spec->sense_updated) { 11171 unsigned int present; 11172 present = snd_hda_codec_read(codec, 0x14, 0, 11173 AC_VERB_GET_PIN_SENSE, 0); 11174 spec->jack_present = (present & 0x80000000) != 0; 11175 spec->sense_updated = 1; 11176 } 11177 if (spec->jack_present) 11178 mute = HDA_AMP_MUTE; /* mute internal speaker */ 11179 else /* unmute internal speaker if necessary */ 11180 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0); 11181 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 11182 HDA_AMP_MUTE, mute); 11183} 11184 11185 11186/* bind hp and internal speaker mute (with plug check) */ 11187static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol, 11188 struct snd_ctl_elem_value *ucontrol) 11189{ 11190 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 11191 long *valp = ucontrol->value.integer.value; 11192 int change; 11193 11194 change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0, 11195 HDA_AMP_MUTE, 11196 valp[0] ? 0 : HDA_AMP_MUTE); 11197 change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0, 11198 HDA_AMP_MUTE, 11199 valp[1] ? 0 : HDA_AMP_MUTE); 11200 if (change) 11201 alc268_acer_automute(codec, 0); 11202 return change; 11203} 11204 11205static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = { 11206 /* output mixer control */ 11207 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol), 11208 { 11209 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11210 .name = "Master Playback Switch", 11211 .info = snd_hda_mixer_amp_switch_info, 11212 .get = snd_hda_mixer_amp_switch_get, 11213 .put = alc268_acer_master_sw_put, 11214 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 11215 }, 11216 HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT), 11217 { } 11218}; 11219 11220static struct snd_kcontrol_new alc268_acer_mixer[] = { 11221 /* output mixer control */ 11222 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol), 11223 { 11224 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11225 .name = "Master Playback Switch", 11226 .info = snd_hda_mixer_amp_switch_info, 11227 .get = snd_hda_mixer_amp_switch_get, 11228 .put = alc268_acer_master_sw_put, 11229 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 11230 }, 11231 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 11232 HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT), 11233 HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT), 11234 { } 11235}; 11236 11237static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = { 11238 /* output mixer control */ 11239 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol), 11240 { 11241 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11242 .name = "Master Playback Switch", 11243 .info = snd_hda_mixer_amp_switch_info, 11244 .get = snd_hda_mixer_amp_switch_get, 11245 .put = alc268_acer_master_sw_put, 11246 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 11247 }, 11248 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 11249 HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT), 11250 { } 11251}; 11252 11253static struct hda_verb alc268_acer_aspire_one_verbs[] = { 11254 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 11255 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 11256 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 11257 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 11258 {0x23, AC_VERB_SET_CONNECT_SEL, 0x06}, 11259 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017}, 11260 { } 11261}; 11262 11263static struct hda_verb alc268_acer_verbs[] = { 11264 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */ 11265 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 11266 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 11267 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 11268 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 11269 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 11270 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 11271 { } 11272}; 11273 11274/* unsolicited event for HP jack sensing */ 11275static void alc268_toshiba_unsol_event(struct hda_codec *codec, 11276 unsigned int res) 11277{ 11278 if ((res >> 26) != ALC880_HP_EVENT) 11279 return; 11280 alc268_toshiba_automute(codec); 11281} 11282 11283static void alc268_acer_unsol_event(struct hda_codec *codec, 11284 unsigned int res) 11285{ 11286 if ((res >> 26) != ALC880_HP_EVENT) 11287 return; 11288 alc268_acer_automute(codec, 1); 11289} 11290 11291static void alc268_acer_init_hook(struct hda_codec *codec) 11292{ 11293 alc268_acer_automute(codec, 1); 11294} 11295 11296/* toggle speaker-output according to the hp-jack state */ 11297static void alc268_aspire_one_speaker_automute(struct hda_codec *codec) 11298{ 11299 unsigned int present; 11300 unsigned char bits; 11301 11302 present = snd_hda_codec_read(codec, 0x15, 0, 11303 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 11304 bits = present ? AMP_IN_MUTE(0) : 0; 11305 snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0, 11306 AMP_IN_MUTE(0), bits); 11307 snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1, 11308 AMP_IN_MUTE(0), bits); 11309} 11310 11311 11312static void alc268_acer_mic_automute(struct hda_codec *codec) 11313{ 11314 unsigned int present; 11315 11316 present = snd_hda_codec_read(codec, 0x18, 0, 11317 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 11318 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL, 11319 present ? 0x0 : 0x6); 11320} 11321 11322static void alc268_acer_lc_unsol_event(struct hda_codec *codec, 11323 unsigned int res) 11324{ 11325 if ((res >> 26) == ALC880_HP_EVENT) 11326 alc268_aspire_one_speaker_automute(codec); 11327 if ((res >> 26) == ALC880_MIC_EVENT) 11328 alc268_acer_mic_automute(codec); 11329} 11330 11331static void alc268_acer_lc_init_hook(struct hda_codec *codec) 11332{ 11333 alc268_aspire_one_speaker_automute(codec); 11334 alc268_acer_mic_automute(codec); 11335} 11336 11337static struct snd_kcontrol_new alc268_dell_mixer[] = { 11338 /* output mixer control */ 11339 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 11340 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 11341 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 11342 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 11343 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 11344 HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT), 11345 { } 11346}; 11347 11348static struct hda_verb alc268_dell_verbs[] = { 11349 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 11350 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 11351 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 11352 { } 11353}; 11354 11355/* mute/unmute internal speaker according to the hp jack and mute state */ 11356static void alc268_dell_automute(struct hda_codec *codec) 11357{ 11358 unsigned int present; 11359 unsigned int mute; 11360 11361 present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0); 11362 if (present & 0x80000000) 11363 mute = HDA_AMP_MUTE; 11364 else 11365 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0); 11366 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 11367 HDA_AMP_MUTE, mute); 11368} 11369 11370static void alc268_dell_unsol_event(struct hda_codec *codec, 11371 unsigned int res) 11372{ 11373 if ((res >> 26) != ALC880_HP_EVENT) 11374 return; 11375 alc268_dell_automute(codec); 11376} 11377 11378#define alc268_dell_init_hook alc268_dell_automute 11379 11380static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = { 11381 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT), 11382 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 11383 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT), 11384 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 11385 HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT), 11386 HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT), 11387 HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT), 11388 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 11389 { } 11390}; 11391 11392static struct hda_verb alc267_quanta_il1_verbs[] = { 11393 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 11394 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, 11395 { } 11396}; 11397 11398static void alc267_quanta_il1_hp_automute(struct hda_codec *codec) 11399{ 11400 unsigned int present; 11401 11402 present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0) 11403 & AC_PINSENSE_PRESENCE; 11404 snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 11405 present ? 0 : PIN_OUT); 11406} 11407 11408static void alc267_quanta_il1_mic_automute(struct hda_codec *codec) 11409{ 11410 unsigned int present; 11411 11412 present = snd_hda_codec_read(codec, 0x18, 0, 11413 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 11414 snd_hda_codec_write(codec, 0x23, 0, 11415 AC_VERB_SET_CONNECT_SEL, 11416 present ? 0x00 : 0x01); 11417} 11418 11419static void alc267_quanta_il1_automute(struct hda_codec *codec) 11420{ 11421 alc267_quanta_il1_hp_automute(codec); 11422 alc267_quanta_il1_mic_automute(codec); 11423} 11424 11425static void alc267_quanta_il1_unsol_event(struct hda_codec *codec, 11426 unsigned int res) 11427{ 11428 switch (res >> 26) { 11429 case ALC880_HP_EVENT: 11430 alc267_quanta_il1_hp_automute(codec); 11431 break; 11432 case ALC880_MIC_EVENT: 11433 alc267_quanta_il1_mic_automute(codec); 11434 break; 11435 } 11436} 11437 11438/* 11439 * generic initialization of ADC, input mixers and output mixers 11440 */ 11441static struct hda_verb alc268_base_init_verbs[] = { 11442 /* Unmute DAC0-1 and set vol = 0 */ 11443 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 11444 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 11445 11446 /* 11447 * Set up output mixers (0x0c - 0x0e) 11448 */ 11449 /* set vol=0 to output mixers */ 11450 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11451 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00}, 11452 11453 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11454 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11455 11456 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 11457 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 11458 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 11459 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 11460 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 11461 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 11462 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 11463 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 11464 11465 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11466 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11467 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11468 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11469 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11470 11471 /* set PCBEEP vol = 0, mute connections */ 11472 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11473 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 11474 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 11475 11476 /* Unmute Selector 23h,24h and set the default input to mic-in */ 11477 11478 {0x23, AC_VERB_SET_CONNECT_SEL, 0x00}, 11479 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11480 {0x24, AC_VERB_SET_CONNECT_SEL, 0x00}, 11481 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11482 11483 { } 11484}; 11485 11486/* 11487 * generic initialization of ADC, input mixers and output mixers 11488 */ 11489static struct hda_verb alc268_volume_init_verbs[] = { 11490 /* set output DAC */ 11491 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 11492 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 11493 11494 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 11495 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 11496 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 11497 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 11498 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 11499 11500 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11501 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11502 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11503 11504 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11505 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11506 11507 /* set PCBEEP vol = 0, mute connections */ 11508 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11509 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 11510 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 11511 11512 { } 11513}; 11514 11515static struct snd_kcontrol_new alc268_capture_alt_mixer[] = { 11516 HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT), 11517 HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT), 11518 { 11519 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11520 /* The multiple "Capture Source" controls confuse alsamixer 11521 * So call somewhat different.. 11522 */ 11523 /* .name = "Capture Source", */ 11524 .name = "Input Source", 11525 .count = 1, 11526 .info = alc_mux_enum_info, 11527 .get = alc_mux_enum_get, 11528 .put = alc_mux_enum_put, 11529 }, 11530 { } /* end */ 11531}; 11532 11533static struct snd_kcontrol_new alc268_capture_mixer[] = { 11534 HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT), 11535 HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT), 11536 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT), 11537 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT), 11538 { 11539 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11540 /* The multiple "Capture Source" controls confuse alsamixer 11541 * So call somewhat different.. 11542 */ 11543 /* .name = "Capture Source", */ 11544 .name = "Input Source", 11545 .count = 2, 11546 .info = alc_mux_enum_info, 11547 .get = alc_mux_enum_get, 11548 .put = alc_mux_enum_put, 11549 }, 11550 { } /* end */ 11551}; 11552 11553static struct hda_input_mux alc268_capture_source = { 11554 .num_items = 4, 11555 .items = { 11556 { "Mic", 0x0 }, 11557 { "Front Mic", 0x1 }, 11558 { "Line", 0x2 }, 11559 { "CD", 0x3 }, 11560 }, 11561}; 11562 11563static struct hda_input_mux alc268_acer_capture_source = { 11564 .num_items = 3, 11565 .items = { 11566 { "Mic", 0x0 }, 11567 { "Internal Mic", 0x1 }, 11568 { "Line", 0x2 }, 11569 }, 11570}; 11571 11572static struct hda_input_mux alc268_acer_dmic_capture_source = { 11573 .num_items = 3, 11574 .items = { 11575 { "Mic", 0x0 }, 11576 { "Internal Mic", 0x6 }, 11577 { "Line", 0x2 }, 11578 }, 11579}; 11580 11581#ifdef CONFIG_SND_DEBUG 11582static struct snd_kcontrol_new alc268_test_mixer[] = { 11583 /* Volume widgets */ 11584 HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT), 11585 HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT), 11586 HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT), 11587 HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT), 11588 HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT), 11589 HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT), 11590 HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT), 11591 HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT), 11592 HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT), 11593 HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT), 11594 HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT), 11595 HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT), 11596 HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT), 11597 /* The below appears problematic on some hardwares */ 11598 /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/ 11599 HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT), 11600 HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT), 11601 HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT), 11602 HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT), 11603 11604 /* Modes for retasking pin widgets */ 11605 ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT), 11606 ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT), 11607 ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT), 11608 ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT), 11609 11610 /* Controls for GPIO pins, assuming they are configured as outputs */ 11611 ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01), 11612 ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02), 11613 ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04), 11614 ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08), 11615 11616 /* Switches to allow the digital SPDIF output pin to be enabled. 11617 * The ALC268 does not have an SPDIF input. 11618 */ 11619 ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01), 11620 11621 /* A switch allowing EAPD to be enabled. Some laptops seem to use 11622 * this output to turn on an external amplifier. 11623 */ 11624 ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02), 11625 ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02), 11626 11627 { } /* end */ 11628}; 11629#endif 11630 11631/* create input playback/capture controls for the given pin */ 11632static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid, 11633 const char *ctlname, int idx) 11634{ 11635 char name[32]; 11636 int err; 11637 11638 sprintf(name, "%s Playback Volume", ctlname); 11639 if (nid == 0x14) { 11640 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 11641 HDA_COMPOSE_AMP_VAL(0x02, 3, idx, 11642 HDA_OUTPUT)); 11643 if (err < 0) 11644 return err; 11645 } else if (nid == 0x15) { 11646 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 11647 HDA_COMPOSE_AMP_VAL(0x03, 3, idx, 11648 HDA_OUTPUT)); 11649 if (err < 0) 11650 return err; 11651 } else 11652 return -1; 11653 sprintf(name, "%s Playback Switch", ctlname); 11654 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 11655 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT)); 11656 if (err < 0) 11657 return err; 11658 return 0; 11659} 11660 11661/* add playback controls from the parsed DAC table */ 11662static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec, 11663 const struct auto_pin_cfg *cfg) 11664{ 11665 hda_nid_t nid; 11666 int err; 11667 11668 spec->multiout.num_dacs = 2; /* only use one dac */ 11669 spec->multiout.dac_nids = spec->private_dac_nids; 11670 spec->multiout.dac_nids[0] = 2; 11671 spec->multiout.dac_nids[1] = 3; 11672 11673 nid = cfg->line_out_pins[0]; 11674 if (nid) 11675 alc268_new_analog_output(spec, nid, "Front", 0); 11676 11677 nid = cfg->speaker_pins[0]; 11678 if (nid == 0x1d) { 11679 err = add_control(spec, ALC_CTL_WIDGET_VOL, 11680 "Speaker Playback Volume", 11681 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT)); 11682 if (err < 0) 11683 return err; 11684 } 11685 nid = cfg->hp_pins[0]; 11686 if (nid) 11687 alc268_new_analog_output(spec, nid, "Headphone", 0); 11688 11689 nid = cfg->line_out_pins[1] | cfg->line_out_pins[2]; 11690 if (nid == 0x16) { 11691 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 11692 "Mono Playback Switch", 11693 HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT)); 11694 if (err < 0) 11695 return err; 11696 } 11697 return 0; 11698} 11699 11700/* create playback/capture controls for input pins */ 11701static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec, 11702 const struct auto_pin_cfg *cfg) 11703{ 11704 struct hda_input_mux *imux = &spec->private_imux[0]; 11705 int i, idx1; 11706 11707 for (i = 0; i < AUTO_PIN_LAST; i++) { 11708 switch(cfg->input_pins[i]) { 11709 case 0x18: 11710 idx1 = 0; /* Mic 1 */ 11711 break; 11712 case 0x19: 11713 idx1 = 1; /* Mic 2 */ 11714 break; 11715 case 0x1a: 11716 idx1 = 2; /* Line In */ 11717 break; 11718 case 0x1c: 11719 idx1 = 3; /* CD */ 11720 break; 11721 case 0x12: 11722 case 0x13: 11723 idx1 = 6; /* digital mics */ 11724 break; 11725 default: 11726 continue; 11727 } 11728 imux->items[imux->num_items].label = auto_pin_cfg_labels[i]; 11729 imux->items[imux->num_items].index = idx1; 11730 imux->num_items++; 11731 } 11732 return 0; 11733} 11734 11735static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec) 11736{ 11737 struct alc_spec *spec = codec->spec; 11738 hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0]; 11739 hda_nid_t hp_nid = spec->autocfg.hp_pins[0]; 11740 hda_nid_t line_nid = spec->autocfg.line_out_pins[0]; 11741 unsigned int dac_vol1, dac_vol2; 11742 11743 if (speaker_nid) { 11744 snd_hda_codec_write(codec, speaker_nid, 0, 11745 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 11746 snd_hda_codec_write(codec, 0x0f, 0, 11747 AC_VERB_SET_AMP_GAIN_MUTE, 11748 AMP_IN_UNMUTE(1)); 11749 snd_hda_codec_write(codec, 0x10, 0, 11750 AC_VERB_SET_AMP_GAIN_MUTE, 11751 AMP_IN_UNMUTE(1)); 11752 } else { 11753 snd_hda_codec_write(codec, 0x0f, 0, 11754 AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)); 11755 snd_hda_codec_write(codec, 0x10, 0, 11756 AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)); 11757 } 11758 11759 dac_vol1 = dac_vol2 = 0xb000 | 0x40; /* set max volume */ 11760 if (line_nid == 0x14) 11761 dac_vol2 = AMP_OUT_ZERO; 11762 else if (line_nid == 0x15) 11763 dac_vol1 = AMP_OUT_ZERO; 11764 if (hp_nid == 0x14) 11765 dac_vol2 = AMP_OUT_ZERO; 11766 else if (hp_nid == 0x15) 11767 dac_vol1 = AMP_OUT_ZERO; 11768 if (line_nid != 0x16 || hp_nid != 0x16 || 11769 spec->autocfg.line_out_pins[1] != 0x16 || 11770 spec->autocfg.line_out_pins[2] != 0x16) 11771 dac_vol1 = dac_vol2 = AMP_OUT_ZERO; 11772 11773 snd_hda_codec_write(codec, 0x02, 0, 11774 AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1); 11775 snd_hda_codec_write(codec, 0x03, 0, 11776 AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2); 11777} 11778 11779/* pcm configuration: identiacal with ALC880 */ 11780#define alc268_pcm_analog_playback alc880_pcm_analog_playback 11781#define alc268_pcm_analog_capture alc880_pcm_analog_capture 11782#define alc268_pcm_analog_alt_capture alc880_pcm_analog_alt_capture 11783#define alc268_pcm_digital_playback alc880_pcm_digital_playback 11784 11785/* 11786 * BIOS auto configuration 11787 */ 11788static int alc268_parse_auto_config(struct hda_codec *codec) 11789{ 11790 struct alc_spec *spec = codec->spec; 11791 int err; 11792 static hda_nid_t alc268_ignore[] = { 0 }; 11793 11794 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 11795 alc268_ignore); 11796 if (err < 0) 11797 return err; 11798 if (!spec->autocfg.line_outs) 11799 return 0; /* can't find valid BIOS pin config */ 11800 11801 err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg); 11802 if (err < 0) 11803 return err; 11804 err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg); 11805 if (err < 0) 11806 return err; 11807 11808 spec->multiout.max_channels = 2; 11809 11810 /* digital only support output */ 11811 if (spec->autocfg.dig_outs) 11812 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID; 11813 11814 if (spec->kctls.list) 11815 add_mixer(spec, spec->kctls.list); 11816 11817 if (spec->autocfg.speaker_pins[0] != 0x1d) 11818 add_mixer(spec, alc268_beep_mixer); 11819 11820 add_verb(spec, alc268_volume_init_verbs); 11821 spec->num_mux_defs = 1; 11822 spec->input_mux = &spec->private_imux[0]; 11823 11824 err = alc_auto_add_mic_boost(codec); 11825 if (err < 0) 11826 return err; 11827 11828 store_pin_configs(codec); 11829 return 1; 11830} 11831 11832#define alc268_auto_init_multi_out alc882_auto_init_multi_out 11833#define alc268_auto_init_hp_out alc882_auto_init_hp_out 11834#define alc268_auto_init_analog_input alc882_auto_init_analog_input 11835 11836/* init callback for auto-configuration model -- overriding the default init */ 11837static void alc268_auto_init(struct hda_codec *codec) 11838{ 11839 struct alc_spec *spec = codec->spec; 11840 alc268_auto_init_multi_out(codec); 11841 alc268_auto_init_hp_out(codec); 11842 alc268_auto_init_mono_speaker_out(codec); 11843 alc268_auto_init_analog_input(codec); 11844 if (spec->unsol_event) 11845 alc_inithook(codec); 11846} 11847 11848/* 11849 * configuration and preset 11850 */ 11851static const char *alc268_models[ALC268_MODEL_LAST] = { 11852 [ALC267_QUANTA_IL1] = "quanta-il1", 11853 [ALC268_3ST] = "3stack", 11854 [ALC268_TOSHIBA] = "toshiba", 11855 [ALC268_ACER] = "acer", 11856 [ALC268_ACER_DMIC] = "acer-dmic", 11857 [ALC268_ACER_ASPIRE_ONE] = "acer-aspire", 11858 [ALC268_DELL] = "dell", 11859 [ALC268_ZEPTO] = "zepto", 11860#ifdef CONFIG_SND_DEBUG 11861 [ALC268_TEST] = "test", 11862#endif 11863 [ALC268_AUTO] = "auto", 11864}; 11865 11866static struct snd_pci_quirk alc268_cfg_tbl[] = { 11867 SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER), 11868 SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER), 11869 SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER), 11870 SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER), 11871 SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER), 11872 SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One", 11873 ALC268_ACER_ASPIRE_ONE), 11874 SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL), 11875 SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron Mini9", ALC268_DELL), 11876 SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA), 11877 SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST), 11878 SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA), 11879 SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA), 11880 SND_PCI_QUIRK(0x1179, 0xff64, "TOSHIBA L305", ALC268_TOSHIBA), 11881 SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA), 11882 SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER), 11883 SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1), 11884 SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO), 11885 {} 11886}; 11887 11888static struct alc_config_preset alc268_presets[] = { 11889 [ALC267_QUANTA_IL1] = { 11890 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer }, 11891 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 11892 alc267_quanta_il1_verbs }, 11893 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 11894 .dac_nids = alc268_dac_nids, 11895 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 11896 .adc_nids = alc268_adc_nids_alt, 11897 .hp_nid = 0x03, 11898 .num_channel_mode = ARRAY_SIZE(alc268_modes), 11899 .channel_mode = alc268_modes, 11900 .input_mux = &alc268_capture_source, 11901 .unsol_event = alc267_quanta_il1_unsol_event, 11902 .init_hook = alc267_quanta_il1_automute, 11903 }, 11904 [ALC268_3ST] = { 11905 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer, 11906 alc268_beep_mixer }, 11907 .init_verbs = { alc268_base_init_verbs }, 11908 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 11909 .dac_nids = alc268_dac_nids, 11910 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 11911 .adc_nids = alc268_adc_nids_alt, 11912 .capsrc_nids = alc268_capsrc_nids, 11913 .hp_nid = 0x03, 11914 .dig_out_nid = ALC268_DIGOUT_NID, 11915 .num_channel_mode = ARRAY_SIZE(alc268_modes), 11916 .channel_mode = alc268_modes, 11917 .input_mux = &alc268_capture_source, 11918 }, 11919 [ALC268_TOSHIBA] = { 11920 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer, 11921 alc268_beep_mixer }, 11922 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 11923 alc268_toshiba_verbs }, 11924 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 11925 .dac_nids = alc268_dac_nids, 11926 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 11927 .adc_nids = alc268_adc_nids_alt, 11928 .capsrc_nids = alc268_capsrc_nids, 11929 .hp_nid = 0x03, 11930 .num_channel_mode = ARRAY_SIZE(alc268_modes), 11931 .channel_mode = alc268_modes, 11932 .input_mux = &alc268_capture_source, 11933 .unsol_event = alc268_toshiba_unsol_event, 11934 .init_hook = alc268_toshiba_automute, 11935 }, 11936 [ALC268_ACER] = { 11937 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer, 11938 alc268_beep_mixer }, 11939 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 11940 alc268_acer_verbs }, 11941 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 11942 .dac_nids = alc268_dac_nids, 11943 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 11944 .adc_nids = alc268_adc_nids_alt, 11945 .capsrc_nids = alc268_capsrc_nids, 11946 .hp_nid = 0x02, 11947 .num_channel_mode = ARRAY_SIZE(alc268_modes), 11948 .channel_mode = alc268_modes, 11949 .input_mux = &alc268_acer_capture_source, 11950 .unsol_event = alc268_acer_unsol_event, 11951 .init_hook = alc268_acer_init_hook, 11952 }, 11953 [ALC268_ACER_DMIC] = { 11954 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer, 11955 alc268_beep_mixer }, 11956 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 11957 alc268_acer_verbs }, 11958 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 11959 .dac_nids = alc268_dac_nids, 11960 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 11961 .adc_nids = alc268_adc_nids_alt, 11962 .capsrc_nids = alc268_capsrc_nids, 11963 .hp_nid = 0x02, 11964 .num_channel_mode = ARRAY_SIZE(alc268_modes), 11965 .channel_mode = alc268_modes, 11966 .input_mux = &alc268_acer_dmic_capture_source, 11967 .unsol_event = alc268_acer_unsol_event, 11968 .init_hook = alc268_acer_init_hook, 11969 }, 11970 [ALC268_ACER_ASPIRE_ONE] = { 11971 .mixers = { alc268_acer_aspire_one_mixer, 11972 alc268_beep_mixer, 11973 alc268_capture_alt_mixer }, 11974 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 11975 alc268_acer_aspire_one_verbs }, 11976 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 11977 .dac_nids = alc268_dac_nids, 11978 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 11979 .adc_nids = alc268_adc_nids_alt, 11980 .capsrc_nids = alc268_capsrc_nids, 11981 .hp_nid = 0x03, 11982 .num_channel_mode = ARRAY_SIZE(alc268_modes), 11983 .channel_mode = alc268_modes, 11984 .input_mux = &alc268_acer_lc_capture_source, 11985 .unsol_event = alc268_acer_lc_unsol_event, 11986 .init_hook = alc268_acer_lc_init_hook, 11987 }, 11988 [ALC268_DELL] = { 11989 .mixers = { alc268_dell_mixer, alc268_beep_mixer }, 11990 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 11991 alc268_dell_verbs }, 11992 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 11993 .dac_nids = alc268_dac_nids, 11994 .hp_nid = 0x02, 11995 .num_channel_mode = ARRAY_SIZE(alc268_modes), 11996 .channel_mode = alc268_modes, 11997 .unsol_event = alc268_dell_unsol_event, 11998 .init_hook = alc268_dell_init_hook, 11999 .input_mux = &alc268_capture_source, 12000 }, 12001 [ALC268_ZEPTO] = { 12002 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer, 12003 alc268_beep_mixer }, 12004 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 12005 alc268_toshiba_verbs }, 12006 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 12007 .dac_nids = alc268_dac_nids, 12008 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 12009 .adc_nids = alc268_adc_nids_alt, 12010 .capsrc_nids = alc268_capsrc_nids, 12011 .hp_nid = 0x03, 12012 .dig_out_nid = ALC268_DIGOUT_NID, 12013 .num_channel_mode = ARRAY_SIZE(alc268_modes), 12014 .channel_mode = alc268_modes, 12015 .input_mux = &alc268_capture_source, 12016 .unsol_event = alc268_toshiba_unsol_event, 12017 .init_hook = alc268_toshiba_automute 12018 }, 12019#ifdef CONFIG_SND_DEBUG 12020 [ALC268_TEST] = { 12021 .mixers = { alc268_test_mixer, alc268_capture_mixer }, 12022 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 12023 alc268_volume_init_verbs }, 12024 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 12025 .dac_nids = alc268_dac_nids, 12026 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 12027 .adc_nids = alc268_adc_nids_alt, 12028 .capsrc_nids = alc268_capsrc_nids, 12029 .hp_nid = 0x03, 12030 .dig_out_nid = ALC268_DIGOUT_NID, 12031 .num_channel_mode = ARRAY_SIZE(alc268_modes), 12032 .channel_mode = alc268_modes, 12033 .input_mux = &alc268_capture_source, 12034 }, 12035#endif 12036}; 12037 12038static int patch_alc268(struct hda_codec *codec) 12039{ 12040 struct alc_spec *spec; 12041 int board_config; 12042 int i, has_beep, err; 12043 12044 spec = kcalloc(1, sizeof(*spec), GFP_KERNEL); 12045 if (spec == NULL) 12046 return -ENOMEM; 12047 12048 codec->spec = spec; 12049 12050 board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST, 12051 alc268_models, 12052 alc268_cfg_tbl); 12053 12054 if (board_config < 0 || board_config >= ALC268_MODEL_LAST) { 12055 printk(KERN_INFO "hda_codec: Unknown model for ALC268, " 12056 "trying auto-probe from BIOS...\n"); 12057 board_config = ALC268_AUTO; 12058 } 12059 12060 if (board_config == ALC268_AUTO) { 12061 /* automatic parse from the BIOS config */ 12062 err = alc268_parse_auto_config(codec); 12063 if (err < 0) { 12064 alc_free(codec); 12065 return err; 12066 } else if (!err) { 12067 printk(KERN_INFO 12068 "hda_codec: Cannot set up configuration " 12069 "from BIOS. Using base mode...\n"); 12070 board_config = ALC268_3ST; 12071 } 12072 } 12073 12074 err = snd_hda_attach_beep_device(codec, 0x1); 12075 if (err < 0) { 12076 alc_free(codec); 12077 return err; 12078 } 12079 12080 if (board_config != ALC268_AUTO) 12081 setup_preset(spec, &alc268_presets[board_config]); 12082 12083 if (codec->vendor_id == 0x10ec0267) { 12084 spec->stream_name_analog = "ALC267 Analog"; 12085 spec->stream_name_digital = "ALC267 Digital"; 12086 } else { 12087 spec->stream_name_analog = "ALC268 Analog"; 12088 spec->stream_name_digital = "ALC268 Digital"; 12089 } 12090 12091 spec->stream_analog_playback = &alc268_pcm_analog_playback; 12092 spec->stream_analog_capture = &alc268_pcm_analog_capture; 12093 spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture; 12094 12095 spec->stream_digital_playback = &alc268_pcm_digital_playback; 12096 12097 has_beep = 0; 12098 for (i = 0; i < spec->num_mixers; i++) { 12099 if (spec->mixers[i] == alc268_beep_mixer) { 12100 has_beep = 1; 12101 break; 12102 } 12103 } 12104 12105 if (has_beep) { 12106 err = snd_hda_attach_beep_device(codec, 0x1); 12107 if (err < 0) { 12108 alc_free(codec); 12109 return err; 12110 } 12111 if (!query_amp_caps(codec, 0x1d, HDA_INPUT)) 12112 /* override the amp caps for beep generator */ 12113 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT, 12114 (0x0c << AC_AMPCAP_OFFSET_SHIFT) | 12115 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) | 12116 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) | 12117 (0 << AC_AMPCAP_MUTE_SHIFT)); 12118 } 12119 12120 if (!spec->adc_nids && spec->input_mux) { 12121 /* check whether NID 0x07 is valid */ 12122 unsigned int wcap = get_wcaps(codec, 0x07); 12123 int i; 12124 12125 /* get type */ 12126 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 12127 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) { 12128 spec->adc_nids = alc268_adc_nids_alt; 12129 spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt); 12130 add_mixer(spec, alc268_capture_alt_mixer); 12131 } else { 12132 spec->adc_nids = alc268_adc_nids; 12133 spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids); 12134 add_mixer(spec, alc268_capture_mixer); 12135 } 12136 spec->capsrc_nids = alc268_capsrc_nids; 12137 /* set default input source */ 12138 for (i = 0; i < spec->num_adc_nids; i++) 12139 snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i], 12140 0, AC_VERB_SET_CONNECT_SEL, 12141 spec->input_mux->items[0].index); 12142 } 12143 12144 spec->vmaster_nid = 0x02; 12145 12146 codec->patch_ops = alc_patch_ops; 12147 if (board_config == ALC268_AUTO) 12148 spec->init_hook = alc268_auto_init; 12149 12150 codec->proc_widget_hook = print_realtek_coef; 12151 12152 return 0; 12153} 12154 12155/* 12156 * ALC269 channel source setting (2 channel) 12157 */ 12158#define ALC269_DIGOUT_NID ALC880_DIGOUT_NID 12159 12160#define alc269_dac_nids alc260_dac_nids 12161 12162static hda_nid_t alc269_adc_nids[1] = { 12163 /* ADC1 */ 12164 0x08, 12165}; 12166 12167static hda_nid_t alc269_capsrc_nids[1] = { 12168 0x23, 12169}; 12170 12171/* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24), 12172 * not a mux! 12173 */ 12174 12175static struct hda_input_mux alc269_eeepc_dmic_capture_source = { 12176 .num_items = 2, 12177 .items = { 12178 { "i-Mic", 0x5 }, 12179 { "e-Mic", 0x0 }, 12180 }, 12181}; 12182 12183static struct hda_input_mux alc269_eeepc_amic_capture_source = { 12184 .num_items = 2, 12185 .items = { 12186 { "i-Mic", 0x1 }, 12187 { "e-Mic", 0x0 }, 12188 }, 12189}; 12190 12191#define alc269_modes alc260_modes 12192#define alc269_capture_source alc880_lg_lw_capture_source 12193 12194static struct snd_kcontrol_new alc269_base_mixer[] = { 12195 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 12196 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 12197 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 12198 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 12199 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 12200 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 12201 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 12202 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 12203 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 12204 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 12205 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 12206 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT), 12207 { } /* end */ 12208}; 12209 12210static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = { 12211 /* output mixer control */ 12212 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol), 12213 { 12214 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 12215 .name = "Master Playback Switch", 12216 .info = snd_hda_mixer_amp_switch_info, 12217 .get = snd_hda_mixer_amp_switch_get, 12218 .put = alc268_acer_master_sw_put, 12219 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 12220 }, 12221 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 12222 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 12223 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 12224 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 12225 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 12226 HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT), 12227 { } 12228}; 12229 12230static struct snd_kcontrol_new alc269_lifebook_mixer[] = { 12231 /* output mixer control */ 12232 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol), 12233 { 12234 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 12235 .name = "Master Playback Switch", 12236 .info = snd_hda_mixer_amp_switch_info, 12237 .get = snd_hda_mixer_amp_switch_get, 12238 .put = alc268_acer_master_sw_put, 12239 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 12240 }, 12241 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 12242 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 12243 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 12244 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 12245 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 12246 HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT), 12247 HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT), 12248 HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT), 12249 HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT), 12250 { } 12251}; 12252 12253/* bind volumes of both NID 0x0c and 0x0d */ 12254static struct hda_bind_ctls alc269_epc_bind_vol = { 12255 .ops = &snd_hda_bind_vol, 12256 .values = { 12257 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT), 12258 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT), 12259 0 12260 }, 12261}; 12262 12263static struct snd_kcontrol_new alc269_eeepc_mixer[] = { 12264 HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 12265 HDA_BIND_VOL("LineOut Playback Volume", &alc269_epc_bind_vol), 12266 HDA_CODEC_MUTE("LineOut Playback Switch", 0x15, 0x0, HDA_OUTPUT), 12267 { } /* end */ 12268}; 12269 12270/* capture mixer elements */ 12271static struct snd_kcontrol_new alc269_epc_capture_mixer[] = { 12272 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 12273 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 12274 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 12275 { } /* end */ 12276}; 12277 12278/* FSC amilo */ 12279static struct snd_kcontrol_new alc269_fujitsu_mixer[] = { 12280 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 12281 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 12282 HDA_BIND_VOL("PCM Playback Volume", &alc269_epc_bind_vol), 12283 { } /* end */ 12284}; 12285 12286static struct hda_verb alc269_quanta_fl1_verbs[] = { 12287 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 12288 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 12289 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 12290 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 12291 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 12292 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 12293 { } 12294}; 12295 12296static struct hda_verb alc269_lifebook_verbs[] = { 12297 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 12298 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, 12299 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 12300 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 12301 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 12302 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12303 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 12304 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 12305 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 12306 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 12307 { } 12308}; 12309 12310/* toggle speaker-output according to the hp-jack state */ 12311static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec) 12312{ 12313 unsigned int present; 12314 unsigned char bits; 12315 12316 present = snd_hda_codec_read(codec, 0x15, 0, 12317 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 12318 bits = present ? AMP_IN_MUTE(0) : 0; 12319 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 12320 AMP_IN_MUTE(0), bits); 12321 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 12322 AMP_IN_MUTE(0), bits); 12323 12324 snd_hda_codec_write(codec, 0x20, 0, 12325 AC_VERB_SET_COEF_INDEX, 0x0c); 12326 snd_hda_codec_write(codec, 0x20, 0, 12327 AC_VERB_SET_PROC_COEF, 0x680); 12328 12329 snd_hda_codec_write(codec, 0x20, 0, 12330 AC_VERB_SET_COEF_INDEX, 0x0c); 12331 snd_hda_codec_write(codec, 0x20, 0, 12332 AC_VERB_SET_PROC_COEF, 0x480); 12333} 12334 12335/* toggle speaker-output according to the hp-jacks state */ 12336static void alc269_lifebook_speaker_automute(struct hda_codec *codec) 12337{ 12338 unsigned int present; 12339 unsigned char bits; 12340 12341 /* Check laptop headphone socket */ 12342 present = snd_hda_codec_read(codec, 0x15, 0, 12343 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 12344 12345 /* Check port replicator headphone socket */ 12346 present |= snd_hda_codec_read(codec, 0x1a, 0, 12347 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 12348 12349 bits = present ? AMP_IN_MUTE(0) : 0; 12350 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 12351 AMP_IN_MUTE(0), bits); 12352 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 12353 AMP_IN_MUTE(0), bits); 12354 12355 snd_hda_codec_write(codec, 0x20, 0, 12356 AC_VERB_SET_COEF_INDEX, 0x0c); 12357 snd_hda_codec_write(codec, 0x20, 0, 12358 AC_VERB_SET_PROC_COEF, 0x680); 12359 12360 snd_hda_codec_write(codec, 0x20, 0, 12361 AC_VERB_SET_COEF_INDEX, 0x0c); 12362 snd_hda_codec_write(codec, 0x20, 0, 12363 AC_VERB_SET_PROC_COEF, 0x480); 12364} 12365 12366static void alc269_quanta_fl1_mic_automute(struct hda_codec *codec) 12367{ 12368 unsigned int present; 12369 12370 present = snd_hda_codec_read(codec, 0x18, 0, 12371 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 12372 snd_hda_codec_write(codec, 0x23, 0, 12373 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x1); 12374} 12375 12376static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec) 12377{ 12378 unsigned int present_laptop; 12379 unsigned int present_dock; 12380 12381 present_laptop = snd_hda_codec_read(codec, 0x18, 0, 12382 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 12383 12384 present_dock = snd_hda_codec_read(codec, 0x1b, 0, 12385 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 12386 12387 /* Laptop mic port overrides dock mic port, design decision */ 12388 if (present_dock) 12389 snd_hda_codec_write(codec, 0x23, 0, 12390 AC_VERB_SET_CONNECT_SEL, 0x3); 12391 if (present_laptop) 12392 snd_hda_codec_write(codec, 0x23, 0, 12393 AC_VERB_SET_CONNECT_SEL, 0x0); 12394 if (!present_dock && !present_laptop) 12395 snd_hda_codec_write(codec, 0x23, 0, 12396 AC_VERB_SET_CONNECT_SEL, 0x1); 12397} 12398 12399static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec, 12400 unsigned int res) 12401{ 12402 if ((res >> 26) == ALC880_HP_EVENT) 12403 alc269_quanta_fl1_speaker_automute(codec); 12404 if ((res >> 26) == ALC880_MIC_EVENT) 12405 alc269_quanta_fl1_mic_automute(codec); 12406} 12407 12408static void alc269_lifebook_unsol_event(struct hda_codec *codec, 12409 unsigned int res) 12410{ 12411 if ((res >> 26) == ALC880_HP_EVENT) 12412 alc269_lifebook_speaker_automute(codec); 12413 if ((res >> 26) == ALC880_MIC_EVENT) 12414 alc269_lifebook_mic_autoswitch(codec); 12415} 12416 12417static void alc269_quanta_fl1_init_hook(struct hda_codec *codec) 12418{ 12419 alc269_quanta_fl1_speaker_automute(codec); 12420 alc269_quanta_fl1_mic_automute(codec); 12421} 12422 12423static void alc269_lifebook_init_hook(struct hda_codec *codec) 12424{ 12425 alc269_lifebook_speaker_automute(codec); 12426 alc269_lifebook_mic_autoswitch(codec); 12427} 12428 12429static struct hda_verb alc269_eeepc_dmic_init_verbs[] = { 12430 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 12431 {0x23, AC_VERB_SET_CONNECT_SEL, 0x05}, 12432 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 }, 12433 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))}, 12434 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 12435 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 12436 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 12437 {} 12438}; 12439 12440static struct hda_verb alc269_eeepc_amic_init_verbs[] = { 12441 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 12442 {0x23, AC_VERB_SET_CONNECT_SEL, 0x01}, 12443 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 }, 12444 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))}, 12445 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 12446 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 12447 {} 12448}; 12449 12450/* toggle speaker-output according to the hp-jack state */ 12451static void alc269_speaker_automute(struct hda_codec *codec) 12452{ 12453 unsigned int present; 12454 unsigned char bits; 12455 12456 present = snd_hda_codec_read(codec, 0x15, 0, 12457 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 12458 bits = present ? AMP_IN_MUTE(0) : 0; 12459 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 12460 AMP_IN_MUTE(0), bits); 12461 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 12462 AMP_IN_MUTE(0), bits); 12463} 12464 12465static void alc269_eeepc_dmic_automute(struct hda_codec *codec) 12466{ 12467 unsigned int present; 12468 12469 present = snd_hda_codec_read(codec, 0x18, 0, 12470 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 12471 snd_hda_codec_write(codec, 0x23, 0, 12472 AC_VERB_SET_CONNECT_SEL, (present ? 0 : 5)); 12473} 12474 12475static void alc269_eeepc_amic_automute(struct hda_codec *codec) 12476{ 12477 unsigned int present; 12478 12479 present = snd_hda_codec_read(codec, 0x18, 0, 12480 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 12481 snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE, 12482 0x7000 | (0x00 << 8) | (present ? 0 : 0x80)); 12483 snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE, 12484 0x7000 | (0x01 << 8) | (present ? 0x80 : 0)); 12485} 12486 12487/* unsolicited event for HP jack sensing */ 12488static void alc269_eeepc_dmic_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_dmic_automute(codec); 12496} 12497 12498static void alc269_eeepc_dmic_inithook(struct hda_codec *codec) 12499{ 12500 alc269_speaker_automute(codec); 12501 alc269_eeepc_dmic_automute(codec); 12502} 12503 12504/* unsolicited event for HP jack sensing */ 12505static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec, 12506 unsigned int res) 12507{ 12508 if ((res >> 26) == ALC880_HP_EVENT) 12509 alc269_speaker_automute(codec); 12510 12511 if ((res >> 26) == ALC880_MIC_EVENT) 12512 alc269_eeepc_amic_automute(codec); 12513} 12514 12515static void alc269_eeepc_amic_inithook(struct hda_codec *codec) 12516{ 12517 alc269_speaker_automute(codec); 12518 alc269_eeepc_amic_automute(codec); 12519} 12520 12521/* 12522 * generic initialization of ADC, input mixers and output mixers 12523 */ 12524static struct hda_verb alc269_init_verbs[] = { 12525 /* 12526 * Unmute ADC0 and set the default input to mic-in 12527 */ 12528 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12529 12530 /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the 12531 * analog-loopback mixer widget 12532 * Note: PASD motherboards uses the Line In 2 as the input for 12533 * front panel mic (mic 2) 12534 */ 12535 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 12536 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 12537 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 12538 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 12539 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 12540 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 12541 12542 /* 12543 * Set up output mixers (0x0c - 0x0e) 12544 */ 12545 /* set vol=0 to output mixers */ 12546 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 12547 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 12548 12549 /* set up input amps for analog loopback */ 12550 /* Amp Indices: DAC = 0, mixer = 1 */ 12551 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12552 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12553 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12554 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12555 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12556 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12557 12558 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 12559 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 12560 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 12561 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 12562 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 12563 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 12564 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 12565 12566 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12567 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12568 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12569 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12570 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12571 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12572 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12573 12574 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 12575 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 12576 12577 /* FIXME: use matrix-type input source selection */ 12578 /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */ 12579 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 12580 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 12581 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12582 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 12583 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 12584 12585 /* set EAPD */ 12586 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 12587 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 12588 { } 12589}; 12590 12591/* add playback controls from the parsed DAC table */ 12592static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec, 12593 const struct auto_pin_cfg *cfg) 12594{ 12595 hda_nid_t nid; 12596 int err; 12597 12598 spec->multiout.num_dacs = 1; /* only use one dac */ 12599 spec->multiout.dac_nids = spec->private_dac_nids; 12600 spec->multiout.dac_nids[0] = 2; 12601 12602 nid = cfg->line_out_pins[0]; 12603 if (nid) { 12604 err = add_control(spec, ALC_CTL_WIDGET_VOL, 12605 "Front Playback Volume", 12606 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT)); 12607 if (err < 0) 12608 return err; 12609 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 12610 "Front Playback Switch", 12611 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 12612 if (err < 0) 12613 return err; 12614 } 12615 12616 nid = cfg->speaker_pins[0]; 12617 if (nid) { 12618 if (!cfg->line_out_pins[0]) { 12619 err = add_control(spec, ALC_CTL_WIDGET_VOL, 12620 "Speaker Playback Volume", 12621 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, 12622 HDA_OUTPUT)); 12623 if (err < 0) 12624 return err; 12625 } 12626 if (nid == 0x16) { 12627 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 12628 "Speaker Playback Switch", 12629 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 12630 HDA_OUTPUT)); 12631 if (err < 0) 12632 return err; 12633 } else { 12634 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 12635 "Speaker Playback Switch", 12636 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 12637 HDA_OUTPUT)); 12638 if (err < 0) 12639 return err; 12640 } 12641 } 12642 nid = cfg->hp_pins[0]; 12643 if (nid) { 12644 /* spec->multiout.hp_nid = 2; */ 12645 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) { 12646 err = add_control(spec, ALC_CTL_WIDGET_VOL, 12647 "Headphone Playback Volume", 12648 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, 12649 HDA_OUTPUT)); 12650 if (err < 0) 12651 return err; 12652 } 12653 if (nid == 0x16) { 12654 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 12655 "Headphone Playback Switch", 12656 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 12657 HDA_OUTPUT)); 12658 if (err < 0) 12659 return err; 12660 } else { 12661 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 12662 "Headphone Playback Switch", 12663 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 12664 HDA_OUTPUT)); 12665 if (err < 0) 12666 return err; 12667 } 12668 } 12669 return 0; 12670} 12671 12672static int alc269_auto_create_analog_input_ctls(struct alc_spec *spec, 12673 const struct auto_pin_cfg *cfg) 12674{ 12675 int err; 12676 12677 err = alc880_auto_create_analog_input_ctls(spec, cfg); 12678 if (err < 0) 12679 return err; 12680 /* digital-mic input pin is excluded in alc880_auto_create..() 12681 * because it's under 0x18 12682 */ 12683 if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 || 12684 cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) { 12685 struct hda_input_mux *imux = &spec->private_imux[0]; 12686 imux->items[imux->num_items].label = "Int Mic"; 12687 imux->items[imux->num_items].index = 0x05; 12688 imux->num_items++; 12689 } 12690 return 0; 12691} 12692 12693#ifdef CONFIG_SND_HDA_POWER_SAVE 12694#define alc269_loopbacks alc880_loopbacks 12695#endif 12696 12697/* pcm configuration: identiacal with ALC880 */ 12698#define alc269_pcm_analog_playback alc880_pcm_analog_playback 12699#define alc269_pcm_analog_capture alc880_pcm_analog_capture 12700#define alc269_pcm_digital_playback alc880_pcm_digital_playback 12701#define alc269_pcm_digital_capture alc880_pcm_digital_capture 12702 12703/* 12704 * BIOS auto configuration 12705 */ 12706static int alc269_parse_auto_config(struct hda_codec *codec) 12707{ 12708 struct alc_spec *spec = codec->spec; 12709 int err; 12710 static hda_nid_t alc269_ignore[] = { 0x1d, 0 }; 12711 12712 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 12713 alc269_ignore); 12714 if (err < 0) 12715 return err; 12716 12717 err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg); 12718 if (err < 0) 12719 return err; 12720 err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg); 12721 if (err < 0) 12722 return err; 12723 12724 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 12725 12726 if (spec->autocfg.dig_outs) 12727 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID; 12728 12729 if (spec->kctls.list) 12730 add_mixer(spec, spec->kctls.list); 12731 12732 add_verb(spec, alc269_init_verbs); 12733 spec->num_mux_defs = 1; 12734 spec->input_mux = &spec->private_imux[0]; 12735 /* set default input source */ 12736 snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0], 12737 0, AC_VERB_SET_CONNECT_SEL, 12738 spec->input_mux->items[0].index); 12739 12740 err = alc_auto_add_mic_boost(codec); 12741 if (err < 0) 12742 return err; 12743 12744 if (!spec->cap_mixer) 12745 set_capture_mixer(spec); 12746 12747 store_pin_configs(codec); 12748 return 1; 12749} 12750 12751#define alc269_auto_init_multi_out alc882_auto_init_multi_out 12752#define alc269_auto_init_hp_out alc882_auto_init_hp_out 12753#define alc269_auto_init_analog_input alc882_auto_init_analog_input 12754 12755 12756/* init callback for auto-configuration model -- overriding the default init */ 12757static void alc269_auto_init(struct hda_codec *codec) 12758{ 12759 struct alc_spec *spec = codec->spec; 12760 alc269_auto_init_multi_out(codec); 12761 alc269_auto_init_hp_out(codec); 12762 alc269_auto_init_analog_input(codec); 12763 if (spec->unsol_event) 12764 alc_inithook(codec); 12765} 12766 12767/* 12768 * configuration and preset 12769 */ 12770static const char *alc269_models[ALC269_MODEL_LAST] = { 12771 [ALC269_BASIC] = "basic", 12772 [ALC269_QUANTA_FL1] = "quanta", 12773 [ALC269_ASUS_EEEPC_P703] = "eeepc-p703", 12774 [ALC269_ASUS_EEEPC_P901] = "eeepc-p901", 12775 [ALC269_FUJITSU] = "fujitsu", 12776 [ALC269_LIFEBOOK] = "lifebook" 12777}; 12778 12779static struct snd_pci_quirk alc269_cfg_tbl[] = { 12780 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1), 12781 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A", 12782 ALC269_ASUS_EEEPC_P703), 12783 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901", 12784 ALC269_ASUS_EEEPC_P901), 12785 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101", 12786 ALC269_ASUS_EEEPC_P901), 12787 SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU), 12788 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK), 12789 {} 12790}; 12791 12792static struct alc_config_preset alc269_presets[] = { 12793 [ALC269_BASIC] = { 12794 .mixers = { alc269_base_mixer }, 12795 .init_verbs = { alc269_init_verbs }, 12796 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 12797 .dac_nids = alc269_dac_nids, 12798 .hp_nid = 0x03, 12799 .num_channel_mode = ARRAY_SIZE(alc269_modes), 12800 .channel_mode = alc269_modes, 12801 .input_mux = &alc269_capture_source, 12802 }, 12803 [ALC269_QUANTA_FL1] = { 12804 .mixers = { alc269_quanta_fl1_mixer }, 12805 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs }, 12806 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 12807 .dac_nids = alc269_dac_nids, 12808 .hp_nid = 0x03, 12809 .num_channel_mode = ARRAY_SIZE(alc269_modes), 12810 .channel_mode = alc269_modes, 12811 .input_mux = &alc269_capture_source, 12812 .unsol_event = alc269_quanta_fl1_unsol_event, 12813 .init_hook = alc269_quanta_fl1_init_hook, 12814 }, 12815 [ALC269_ASUS_EEEPC_P703] = { 12816 .mixers = { alc269_eeepc_mixer }, 12817 .cap_mixer = alc269_epc_capture_mixer, 12818 .init_verbs = { alc269_init_verbs, 12819 alc269_eeepc_amic_init_verbs }, 12820 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 12821 .dac_nids = alc269_dac_nids, 12822 .hp_nid = 0x03, 12823 .num_channel_mode = ARRAY_SIZE(alc269_modes), 12824 .channel_mode = alc269_modes, 12825 .input_mux = &alc269_eeepc_amic_capture_source, 12826 .unsol_event = alc269_eeepc_amic_unsol_event, 12827 .init_hook = alc269_eeepc_amic_inithook, 12828 }, 12829 [ALC269_ASUS_EEEPC_P901] = { 12830 .mixers = { alc269_eeepc_mixer }, 12831 .cap_mixer = alc269_epc_capture_mixer, 12832 .init_verbs = { alc269_init_verbs, 12833 alc269_eeepc_dmic_init_verbs }, 12834 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 12835 .dac_nids = alc269_dac_nids, 12836 .hp_nid = 0x03, 12837 .num_channel_mode = ARRAY_SIZE(alc269_modes), 12838 .channel_mode = alc269_modes, 12839 .input_mux = &alc269_eeepc_dmic_capture_source, 12840 .unsol_event = alc269_eeepc_dmic_unsol_event, 12841 .init_hook = alc269_eeepc_dmic_inithook, 12842 }, 12843 [ALC269_FUJITSU] = { 12844 .mixers = { alc269_fujitsu_mixer }, 12845 .cap_mixer = alc269_epc_capture_mixer, 12846 .init_verbs = { alc269_init_verbs, 12847 alc269_eeepc_dmic_init_verbs }, 12848 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 12849 .dac_nids = alc269_dac_nids, 12850 .hp_nid = 0x03, 12851 .num_channel_mode = ARRAY_SIZE(alc269_modes), 12852 .channel_mode = alc269_modes, 12853 .input_mux = &alc269_eeepc_dmic_capture_source, 12854 .unsol_event = alc269_eeepc_dmic_unsol_event, 12855 .init_hook = alc269_eeepc_dmic_inithook, 12856 }, 12857 [ALC269_LIFEBOOK] = { 12858 .mixers = { alc269_lifebook_mixer }, 12859 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs }, 12860 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 12861 .dac_nids = alc269_dac_nids, 12862 .hp_nid = 0x03, 12863 .num_channel_mode = ARRAY_SIZE(alc269_modes), 12864 .channel_mode = alc269_modes, 12865 .input_mux = &alc269_capture_source, 12866 .unsol_event = alc269_lifebook_unsol_event, 12867 .init_hook = alc269_lifebook_init_hook, 12868 }, 12869}; 12870 12871static int patch_alc269(struct hda_codec *codec) 12872{ 12873 struct alc_spec *spec; 12874 int board_config; 12875 int err; 12876 12877 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 12878 if (spec == NULL) 12879 return -ENOMEM; 12880 12881 codec->spec = spec; 12882 12883 alc_fix_pll_init(codec, 0x20, 0x04, 15); 12884 12885 board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST, 12886 alc269_models, 12887 alc269_cfg_tbl); 12888 12889 if (board_config < 0) { 12890 printk(KERN_INFO "hda_codec: Unknown model for ALC269, " 12891 "trying auto-probe from BIOS...\n"); 12892 board_config = ALC269_AUTO; 12893 } 12894 12895 if (board_config == ALC269_AUTO) { 12896 /* automatic parse from the BIOS config */ 12897 err = alc269_parse_auto_config(codec); 12898 if (err < 0) { 12899 alc_free(codec); 12900 return err; 12901 } else if (!err) { 12902 printk(KERN_INFO 12903 "hda_codec: Cannot set up configuration " 12904 "from BIOS. Using base mode...\n"); 12905 board_config = ALC269_BASIC; 12906 } 12907 } 12908 12909 err = snd_hda_attach_beep_device(codec, 0x1); 12910 if (err < 0) { 12911 alc_free(codec); 12912 return err; 12913 } 12914 12915 if (board_config != ALC269_AUTO) 12916 setup_preset(spec, &alc269_presets[board_config]); 12917 12918 spec->stream_name_analog = "ALC269 Analog"; 12919 spec->stream_analog_playback = &alc269_pcm_analog_playback; 12920 spec->stream_analog_capture = &alc269_pcm_analog_capture; 12921 12922 spec->stream_name_digital = "ALC269 Digital"; 12923 spec->stream_digital_playback = &alc269_pcm_digital_playback; 12924 spec->stream_digital_capture = &alc269_pcm_digital_capture; 12925 12926 spec->adc_nids = alc269_adc_nids; 12927 spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids); 12928 spec->capsrc_nids = alc269_capsrc_nids; 12929 if (!spec->cap_mixer) 12930 set_capture_mixer(spec); 12931 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT); 12932 12933 codec->patch_ops = alc_patch_ops; 12934 if (board_config == ALC269_AUTO) 12935 spec->init_hook = alc269_auto_init; 12936#ifdef CONFIG_SND_HDA_POWER_SAVE 12937 if (!spec->loopback.amplist) 12938 spec->loopback.amplist = alc269_loopbacks; 12939#endif 12940 codec->proc_widget_hook = print_realtek_coef; 12941 12942 return 0; 12943} 12944 12945/* 12946 * ALC861 channel source setting (2/6 channel selection for 3-stack) 12947 */ 12948 12949/* 12950 * set the path ways for 2 channel output 12951 * need to set the codec line out and mic 1 pin widgets to inputs 12952 */ 12953static struct hda_verb alc861_threestack_ch2_init[] = { 12954 /* set pin widget 1Ah (line in) for input */ 12955 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 12956 /* set pin widget 18h (mic1/2) for input, for mic also enable 12957 * the vref 12958 */ 12959 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 12960 12961 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c }, 12962#if 0 12963 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/ 12964 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/ 12965#endif 12966 { } /* end */ 12967}; 12968/* 12969 * 6ch mode 12970 * need to set the codec line out and mic 1 pin widgets to outputs 12971 */ 12972static struct hda_verb alc861_threestack_ch6_init[] = { 12973 /* set pin widget 1Ah (line in) for output (Back Surround)*/ 12974 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 12975 /* set pin widget 18h (mic1) for output (CLFE)*/ 12976 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 12977 12978 { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 }, 12979 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 }, 12980 12981 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 }, 12982#if 0 12983 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/ 12984 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/ 12985#endif 12986 { } /* end */ 12987}; 12988 12989static struct hda_channel_mode alc861_threestack_modes[2] = { 12990 { 2, alc861_threestack_ch2_init }, 12991 { 6, alc861_threestack_ch6_init }, 12992}; 12993/* Set mic1 as input and unmute the mixer */ 12994static struct hda_verb alc861_uniwill_m31_ch2_init[] = { 12995 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 12996 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/ 12997 { } /* end */ 12998}; 12999/* Set mic1 as output and mute mixer */ 13000static struct hda_verb alc861_uniwill_m31_ch4_init[] = { 13001 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13002 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/ 13003 { } /* end */ 13004}; 13005 13006static struct hda_channel_mode alc861_uniwill_m31_modes[2] = { 13007 { 2, alc861_uniwill_m31_ch2_init }, 13008 { 4, alc861_uniwill_m31_ch4_init }, 13009}; 13010 13011/* Set mic1 and line-in as input and unmute the mixer */ 13012static struct hda_verb alc861_asus_ch2_init[] = { 13013 /* set pin widget 1Ah (line in) for input */ 13014 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 13015 /* set pin widget 18h (mic1/2) for input, for mic also enable 13016 * the vref 13017 */ 13018 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 13019 13020 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c }, 13021#if 0 13022 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/ 13023 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/ 13024#endif 13025 { } /* end */ 13026}; 13027/* Set mic1 nad line-in as output and mute mixer */ 13028static struct hda_verb alc861_asus_ch6_init[] = { 13029 /* set pin widget 1Ah (line in) for output (Back Surround)*/ 13030 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13031 /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */ 13032 /* set pin widget 18h (mic1) for output (CLFE)*/ 13033 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13034 /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */ 13035 { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13036 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13037 13038 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 }, 13039#if 0 13040 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/ 13041 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/ 13042#endif 13043 { } /* end */ 13044}; 13045 13046static struct hda_channel_mode alc861_asus_modes[2] = { 13047 { 2, alc861_asus_ch2_init }, 13048 { 6, alc861_asus_ch6_init }, 13049}; 13050 13051/* patch-ALC861 */ 13052 13053static struct snd_kcontrol_new alc861_base_mixer[] = { 13054 /* output mixer control */ 13055 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT), 13056 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT), 13057 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT), 13058 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT), 13059 HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), 13060 13061 /*Input mixer control */ 13062 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT), 13063 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */ 13064 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 13065 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 13066 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT), 13067 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT), 13068 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 13069 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 13070 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT), 13071 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT), 13072 13073 { } /* end */ 13074}; 13075 13076static struct snd_kcontrol_new alc861_3ST_mixer[] = { 13077 /* output mixer control */ 13078 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT), 13079 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT), 13080 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT), 13081 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT), 13082 /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */ 13083 13084 /* Input mixer control */ 13085 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT), 13086 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */ 13087 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 13088 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 13089 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT), 13090 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT), 13091 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 13092 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 13093 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT), 13094 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT), 13095 13096 { 13097 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 13098 .name = "Channel Mode", 13099 .info = alc_ch_mode_info, 13100 .get = alc_ch_mode_get, 13101 .put = alc_ch_mode_put, 13102 .private_value = ARRAY_SIZE(alc861_threestack_modes), 13103 }, 13104 { } /* end */ 13105}; 13106 13107static struct snd_kcontrol_new alc861_toshiba_mixer[] = { 13108 /* output mixer control */ 13109 HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT), 13110 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 13111 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 13112 13113 { } /* end */ 13114}; 13115 13116static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = { 13117 /* output mixer control */ 13118 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT), 13119 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT), 13120 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT), 13121 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT), 13122 /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */ 13123 13124 /* Input mixer control */ 13125 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT), 13126 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */ 13127 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 13128 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 13129 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT), 13130 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT), 13131 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 13132 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 13133 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT), 13134 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT), 13135 13136 { 13137 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 13138 .name = "Channel Mode", 13139 .info = alc_ch_mode_info, 13140 .get = alc_ch_mode_get, 13141 .put = alc_ch_mode_put, 13142 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes), 13143 }, 13144 { } /* end */ 13145}; 13146 13147static struct snd_kcontrol_new alc861_asus_mixer[] = { 13148 /* output mixer control */ 13149 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT), 13150 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT), 13151 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT), 13152 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT), 13153 HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), 13154 13155 /* Input mixer control */ 13156 HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT), 13157 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), 13158 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 13159 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 13160 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT), 13161 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT), 13162 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 13163 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 13164 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT), 13165 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT), 13166 13167 { 13168 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 13169 .name = "Channel Mode", 13170 .info = alc_ch_mode_info, 13171 .get = alc_ch_mode_get, 13172 .put = alc_ch_mode_put, 13173 .private_value = ARRAY_SIZE(alc861_asus_modes), 13174 }, 13175 { } 13176}; 13177 13178/* additional mixer */ 13179static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = { 13180 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 13181 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 13182 { } 13183}; 13184 13185/* 13186 * generic initialization of ADC, input mixers and output mixers 13187 */ 13188static struct hda_verb alc861_base_init_verbs[] = { 13189 /* 13190 * Unmute ADC0 and set the default input to mic-in 13191 */ 13192 /* port-A for surround (rear panel) */ 13193 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13194 { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13195 /* port-B for mic-in (rear panel) with vref */ 13196 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 13197 /* port-C for line-in (rear panel) */ 13198 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 13199 /* port-D for Front */ 13200 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13201 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13202 /* port-E for HP out (front panel) */ 13203 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 13204 /* route front PCM to HP */ 13205 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13206 /* port-F for mic-in (front panel) with vref */ 13207 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 13208 /* port-G for CLFE (rear panel) */ 13209 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13210 { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13211 /* port-H for side (rear panel) */ 13212 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13213 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13214 /* CD-in */ 13215 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 13216 /* route front mic to ADC1*/ 13217 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 13218 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13219 13220 /* Unmute DAC0~3 & spdif out*/ 13221 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13222 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13223 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13224 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13225 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13226 13227 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 13228 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13229 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13230 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13231 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13232 13233 /* Unmute Stereo Mixer 15 */ 13234 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13235 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13236 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13237 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */ 13238 13239 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13240 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13241 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13242 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13243 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13244 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13245 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13246 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13247 /* hp used DAC 3 (Front) */ 13248 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 13249 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13250 13251 { } 13252}; 13253 13254static struct hda_verb alc861_threestack_init_verbs[] = { 13255 /* 13256 * Unmute ADC0 and set the default input to mic-in 13257 */ 13258 /* port-A for surround (rear panel) */ 13259 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 13260 /* port-B for mic-in (rear panel) with vref */ 13261 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 13262 /* port-C for line-in (rear panel) */ 13263 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 13264 /* port-D for Front */ 13265 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13266 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13267 /* port-E for HP out (front panel) */ 13268 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 13269 /* route front PCM to HP */ 13270 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13271 /* port-F for mic-in (front panel) with vref */ 13272 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 13273 /* port-G for CLFE (rear panel) */ 13274 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 13275 /* port-H for side (rear panel) */ 13276 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 13277 /* CD-in */ 13278 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 13279 /* route front mic to ADC1*/ 13280 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 13281 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13282 /* Unmute DAC0~3 & spdif out*/ 13283 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13284 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13285 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13286 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13287 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13288 13289 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 13290 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13291 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13292 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13293 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13294 13295 /* Unmute Stereo Mixer 15 */ 13296 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13297 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13298 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13299 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */ 13300 13301 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13302 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13303 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13304 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13305 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13306 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13307 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13308 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13309 /* hp used DAC 3 (Front) */ 13310 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 13311 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13312 { } 13313}; 13314 13315static struct hda_verb alc861_uniwill_m31_init_verbs[] = { 13316 /* 13317 * Unmute ADC0 and set the default input to mic-in 13318 */ 13319 /* port-A for surround (rear panel) */ 13320 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 13321 /* port-B for mic-in (rear panel) with vref */ 13322 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 13323 /* port-C for line-in (rear panel) */ 13324 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 13325 /* port-D for Front */ 13326 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13327 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13328 /* port-E for HP out (front panel) */ 13329 /* this has to be set to VREF80 */ 13330 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 13331 /* route front PCM to HP */ 13332 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13333 /* port-F for mic-in (front panel) with vref */ 13334 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 13335 /* port-G for CLFE (rear panel) */ 13336 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 13337 /* port-H for side (rear panel) */ 13338 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 13339 /* CD-in */ 13340 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 13341 /* route front mic to ADC1*/ 13342 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 13343 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13344 /* Unmute DAC0~3 & spdif out*/ 13345 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13346 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13347 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13348 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13349 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13350 13351 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 13352 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13353 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13354 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13355 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13356 13357 /* Unmute Stereo Mixer 15 */ 13358 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13359 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13360 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13361 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */ 13362 13363 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13364 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13365 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13366 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13367 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13368 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13369 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13370 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13371 /* hp used DAC 3 (Front) */ 13372 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 13373 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13374 { } 13375}; 13376 13377static struct hda_verb alc861_asus_init_verbs[] = { 13378 /* 13379 * Unmute ADC0 and set the default input to mic-in 13380 */ 13381 /* port-A for surround (rear panel) 13382 * according to codec#0 this is the HP jack 13383 */ 13384 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */ 13385 /* route front PCM to HP */ 13386 { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 }, 13387 /* port-B for mic-in (rear panel) with vref */ 13388 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 13389 /* port-C for line-in (rear panel) */ 13390 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 13391 /* port-D for Front */ 13392 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13393 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13394 /* port-E for HP out (front panel) */ 13395 /* this has to be set to VREF80 */ 13396 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 13397 /* route front PCM to HP */ 13398 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 13399 /* port-F for mic-in (front panel) with vref */ 13400 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 13401 /* port-G for CLFE (rear panel) */ 13402 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13403 /* port-H for side (rear panel) */ 13404 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 13405 /* CD-in */ 13406 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 13407 /* route front mic to ADC1*/ 13408 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 13409 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13410 /* Unmute DAC0~3 & spdif out*/ 13411 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13412 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13413 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13414 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13415 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13416 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 13417 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13418 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13419 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13420 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13421 13422 /* Unmute Stereo Mixer 15 */ 13423 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13424 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13425 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13426 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */ 13427 13428 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13429 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13430 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13431 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13432 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13433 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13434 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13435 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13436 /* hp used DAC 3 (Front) */ 13437 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 13438 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13439 { } 13440}; 13441 13442/* additional init verbs for ASUS laptops */ 13443static struct hda_verb alc861_asus_laptop_init_verbs[] = { 13444 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */ 13445 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */ 13446 { } 13447}; 13448 13449/* 13450 * generic initialization of ADC, input mixers and output mixers 13451 */ 13452static struct hda_verb alc861_auto_init_verbs[] = { 13453 /* 13454 * Unmute ADC0 and set the default input to mic-in 13455 */ 13456 /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */ 13457 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13458 13459 /* Unmute DAC0~3 & spdif out*/ 13460 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13461 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13462 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13463 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13464 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13465 13466 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 13467 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13468 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13469 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13470 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13471 13472 /* Unmute Stereo Mixer 15 */ 13473 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13474 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13475 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13476 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, 13477 13478 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13479 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13480 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13481 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13482 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13483 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13484 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13485 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13486 13487 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 13488 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 13489 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13490 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 13491 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 13492 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 13493 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13494 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 13495 13496 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, /* set Mic 1 */ 13497 13498 { } 13499}; 13500 13501static struct hda_verb alc861_toshiba_init_verbs[] = { 13502 {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 13503 13504 { } 13505}; 13506 13507/* toggle speaker-output according to the hp-jack state */ 13508static void alc861_toshiba_automute(struct hda_codec *codec) 13509{ 13510 unsigned int present; 13511 13512 present = snd_hda_codec_read(codec, 0x0f, 0, 13513 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 13514 snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0, 13515 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 13516 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3, 13517 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE); 13518} 13519 13520static void alc861_toshiba_unsol_event(struct hda_codec *codec, 13521 unsigned int res) 13522{ 13523 if ((res >> 26) == ALC880_HP_EVENT) 13524 alc861_toshiba_automute(codec); 13525} 13526 13527/* pcm configuration: identiacal with ALC880 */ 13528#define alc861_pcm_analog_playback alc880_pcm_analog_playback 13529#define alc861_pcm_analog_capture alc880_pcm_analog_capture 13530#define alc861_pcm_digital_playback alc880_pcm_digital_playback 13531#define alc861_pcm_digital_capture alc880_pcm_digital_capture 13532 13533 13534#define ALC861_DIGOUT_NID 0x07 13535 13536static struct hda_channel_mode alc861_8ch_modes[1] = { 13537 { 8, NULL } 13538}; 13539 13540static hda_nid_t alc861_dac_nids[4] = { 13541 /* front, surround, clfe, side */ 13542 0x03, 0x06, 0x05, 0x04 13543}; 13544 13545static hda_nid_t alc660_dac_nids[3] = { 13546 /* front, clfe, surround */ 13547 0x03, 0x05, 0x06 13548}; 13549 13550static hda_nid_t alc861_adc_nids[1] = { 13551 /* ADC0-2 */ 13552 0x08, 13553}; 13554 13555static struct hda_input_mux alc861_capture_source = { 13556 .num_items = 5, 13557 .items = { 13558 { "Mic", 0x0 }, 13559 { "Front Mic", 0x3 }, 13560 { "Line", 0x1 }, 13561 { "CD", 0x4 }, 13562 { "Mixer", 0x5 }, 13563 }, 13564}; 13565 13566/* fill in the dac_nids table from the parsed pin configuration */ 13567static int alc861_auto_fill_dac_nids(struct alc_spec *spec, 13568 const struct auto_pin_cfg *cfg) 13569{ 13570 int i; 13571 hda_nid_t nid; 13572 13573 spec->multiout.dac_nids = spec->private_dac_nids; 13574 for (i = 0; i < cfg->line_outs; i++) { 13575 nid = cfg->line_out_pins[i]; 13576 if (nid) { 13577 if (i >= ARRAY_SIZE(alc861_dac_nids)) 13578 continue; 13579 spec->multiout.dac_nids[i] = alc861_dac_nids[i]; 13580 } 13581 } 13582 spec->multiout.num_dacs = cfg->line_outs; 13583 return 0; 13584} 13585 13586/* add playback controls from the parsed DAC table */ 13587static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec, 13588 const struct auto_pin_cfg *cfg) 13589{ 13590 char name[32]; 13591 static const char *chname[4] = { 13592 "Front", "Surround", NULL /*CLFE*/, "Side" 13593 }; 13594 hda_nid_t nid; 13595 int i, idx, err; 13596 13597 for (i = 0; i < cfg->line_outs; i++) { 13598 nid = spec->multiout.dac_nids[i]; 13599 if (!nid) 13600 continue; 13601 if (nid == 0x05) { 13602 /* Center/LFE */ 13603 err = add_control(spec, ALC_CTL_BIND_MUTE, 13604 "Center Playback Switch", 13605 HDA_COMPOSE_AMP_VAL(nid, 1, 0, 13606 HDA_OUTPUT)); 13607 if (err < 0) 13608 return err; 13609 err = add_control(spec, ALC_CTL_BIND_MUTE, 13610 "LFE Playback Switch", 13611 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 13612 HDA_OUTPUT)); 13613 if (err < 0) 13614 return err; 13615 } else { 13616 for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1; 13617 idx++) 13618 if (nid == alc861_dac_nids[idx]) 13619 break; 13620 sprintf(name, "%s Playback Switch", chname[idx]); 13621 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 13622 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 13623 HDA_OUTPUT)); 13624 if (err < 0) 13625 return err; 13626 } 13627 } 13628 return 0; 13629} 13630 13631static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin) 13632{ 13633 int err; 13634 hda_nid_t nid; 13635 13636 if (!pin) 13637 return 0; 13638 13639 if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) { 13640 nid = 0x03; 13641 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 13642 "Headphone Playback Switch", 13643 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 13644 if (err < 0) 13645 return err; 13646 spec->multiout.hp_nid = nid; 13647 } 13648 return 0; 13649} 13650 13651/* create playback/capture controls for input pins */ 13652static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec, 13653 const struct auto_pin_cfg *cfg) 13654{ 13655 struct hda_input_mux *imux = &spec->private_imux[0]; 13656 int i, err, idx, idx1; 13657 13658 for (i = 0; i < AUTO_PIN_LAST; i++) { 13659 switch (cfg->input_pins[i]) { 13660 case 0x0c: 13661 idx1 = 1; 13662 idx = 2; /* Line In */ 13663 break; 13664 case 0x0f: 13665 idx1 = 2; 13666 idx = 2; /* Line In */ 13667 break; 13668 case 0x0d: 13669 idx1 = 0; 13670 idx = 1; /* Mic In */ 13671 break; 13672 case 0x10: 13673 idx1 = 3; 13674 idx = 1; /* Mic In */ 13675 break; 13676 case 0x11: 13677 idx1 = 4; 13678 idx = 0; /* CD */ 13679 break; 13680 default: 13681 continue; 13682 } 13683 13684 err = new_analog_input(spec, cfg->input_pins[i], 13685 auto_pin_cfg_labels[i], idx, 0x15); 13686 if (err < 0) 13687 return err; 13688 13689 imux->items[imux->num_items].label = auto_pin_cfg_labels[i]; 13690 imux->items[imux->num_items].index = idx1; 13691 imux->num_items++; 13692 } 13693 return 0; 13694} 13695 13696static void alc861_auto_set_output_and_unmute(struct hda_codec *codec, 13697 hda_nid_t nid, 13698 int pin_type, int dac_idx) 13699{ 13700 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 13701 pin_type); 13702 snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE, 13703 AMP_OUT_UNMUTE); 13704} 13705 13706static void alc861_auto_init_multi_out(struct hda_codec *codec) 13707{ 13708 struct alc_spec *spec = codec->spec; 13709 int i; 13710 13711 alc_subsystem_id(codec, 0x0e, 0x0f, 0x0b); 13712 for (i = 0; i < spec->autocfg.line_outs; i++) { 13713 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 13714 int pin_type = get_pin_type(spec->autocfg.line_out_type); 13715 if (nid) 13716 alc861_auto_set_output_and_unmute(codec, nid, pin_type, 13717 spec->multiout.dac_nids[i]); 13718 } 13719} 13720 13721static void alc861_auto_init_hp_out(struct hda_codec *codec) 13722{ 13723 struct alc_spec *spec = codec->spec; 13724 hda_nid_t pin; 13725 13726 pin = spec->autocfg.hp_pins[0]; 13727 if (pin) /* connect to front */ 13728 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP, 13729 spec->multiout.dac_nids[0]); 13730 pin = spec->autocfg.speaker_pins[0]; 13731 if (pin) 13732 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 13733} 13734 13735static void alc861_auto_init_analog_input(struct hda_codec *codec) 13736{ 13737 struct alc_spec *spec = codec->spec; 13738 int i; 13739 13740 for (i = 0; i < AUTO_PIN_LAST; i++) { 13741 hda_nid_t nid = spec->autocfg.input_pins[i]; 13742 if (nid >= 0x0c && nid <= 0x11) { 13743 snd_hda_codec_write(codec, nid, 0, 13744 AC_VERB_SET_PIN_WIDGET_CONTROL, 13745 i <= AUTO_PIN_FRONT_MIC ? 13746 PIN_VREF80 : PIN_IN); 13747 } 13748 } 13749} 13750 13751/* parse the BIOS configuration and set up the alc_spec */ 13752/* return 1 if successful, 0 if the proper config is not found, 13753 * or a negative error code 13754 */ 13755static int alc861_parse_auto_config(struct hda_codec *codec) 13756{ 13757 struct alc_spec *spec = codec->spec; 13758 int err; 13759 static hda_nid_t alc861_ignore[] = { 0x1d, 0 }; 13760 13761 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 13762 alc861_ignore); 13763 if (err < 0) 13764 return err; 13765 if (!spec->autocfg.line_outs) 13766 return 0; /* can't find valid BIOS pin config */ 13767 13768 err = alc861_auto_fill_dac_nids(spec, &spec->autocfg); 13769 if (err < 0) 13770 return err; 13771 err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg); 13772 if (err < 0) 13773 return err; 13774 err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); 13775 if (err < 0) 13776 return err; 13777 err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg); 13778 if (err < 0) 13779 return err; 13780 13781 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 13782 13783 if (spec->autocfg.dig_outs) 13784 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID; 13785 13786 if (spec->kctls.list) 13787 add_mixer(spec, spec->kctls.list); 13788 13789 add_verb(spec, alc861_auto_init_verbs); 13790 13791 spec->num_mux_defs = 1; 13792 spec->input_mux = &spec->private_imux[0]; 13793 13794 spec->adc_nids = alc861_adc_nids; 13795 spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids); 13796 set_capture_mixer(spec); 13797 13798 store_pin_configs(codec); 13799 return 1; 13800} 13801 13802/* additional initialization for auto-configuration model */ 13803static void alc861_auto_init(struct hda_codec *codec) 13804{ 13805 struct alc_spec *spec = codec->spec; 13806 alc861_auto_init_multi_out(codec); 13807 alc861_auto_init_hp_out(codec); 13808 alc861_auto_init_analog_input(codec); 13809 if (spec->unsol_event) 13810 alc_inithook(codec); 13811} 13812 13813#ifdef CONFIG_SND_HDA_POWER_SAVE 13814static struct hda_amp_list alc861_loopbacks[] = { 13815 { 0x15, HDA_INPUT, 0 }, 13816 { 0x15, HDA_INPUT, 1 }, 13817 { 0x15, HDA_INPUT, 2 }, 13818 { 0x15, HDA_INPUT, 3 }, 13819 { } /* end */ 13820}; 13821#endif 13822 13823 13824/* 13825 * configuration and preset 13826 */ 13827static const char *alc861_models[ALC861_MODEL_LAST] = { 13828 [ALC861_3ST] = "3stack", 13829 [ALC660_3ST] = "3stack-660", 13830 [ALC861_3ST_DIG] = "3stack-dig", 13831 [ALC861_6ST_DIG] = "6stack-dig", 13832 [ALC861_UNIWILL_M31] = "uniwill-m31", 13833 [ALC861_TOSHIBA] = "toshiba", 13834 [ALC861_ASUS] = "asus", 13835 [ALC861_ASUS_LAPTOP] = "asus-laptop", 13836 [ALC861_AUTO] = "auto", 13837}; 13838 13839static struct snd_pci_quirk alc861_cfg_tbl[] = { 13840 SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST), 13841 SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP), 13842 SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP), 13843 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS), 13844 SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP), 13845 SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG), 13846 SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA), 13847 /* FIXME: the entry below breaks Toshiba A100 (model=auto works!) 13848 * Any other models that need this preset? 13849 */ 13850 /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */ 13851 SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST), 13852 SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST), 13853 SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31), 13854 SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31), 13855 SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP), 13856 /* FIXME: the below seems conflict */ 13857 /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */ 13858 SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST), 13859 SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST), 13860 {} 13861}; 13862 13863static struct alc_config_preset alc861_presets[] = { 13864 [ALC861_3ST] = { 13865 .mixers = { alc861_3ST_mixer }, 13866 .init_verbs = { alc861_threestack_init_verbs }, 13867 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 13868 .dac_nids = alc861_dac_nids, 13869 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes), 13870 .channel_mode = alc861_threestack_modes, 13871 .need_dac_fix = 1, 13872 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 13873 .adc_nids = alc861_adc_nids, 13874 .input_mux = &alc861_capture_source, 13875 }, 13876 [ALC861_3ST_DIG] = { 13877 .mixers = { alc861_base_mixer }, 13878 .init_verbs = { alc861_threestack_init_verbs }, 13879 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 13880 .dac_nids = alc861_dac_nids, 13881 .dig_out_nid = ALC861_DIGOUT_NID, 13882 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes), 13883 .channel_mode = alc861_threestack_modes, 13884 .need_dac_fix = 1, 13885 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 13886 .adc_nids = alc861_adc_nids, 13887 .input_mux = &alc861_capture_source, 13888 }, 13889 [ALC861_6ST_DIG] = { 13890 .mixers = { alc861_base_mixer }, 13891 .init_verbs = { alc861_base_init_verbs }, 13892 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 13893 .dac_nids = alc861_dac_nids, 13894 .dig_out_nid = ALC861_DIGOUT_NID, 13895 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes), 13896 .channel_mode = alc861_8ch_modes, 13897 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 13898 .adc_nids = alc861_adc_nids, 13899 .input_mux = &alc861_capture_source, 13900 }, 13901 [ALC660_3ST] = { 13902 .mixers = { alc861_3ST_mixer }, 13903 .init_verbs = { alc861_threestack_init_verbs }, 13904 .num_dacs = ARRAY_SIZE(alc660_dac_nids), 13905 .dac_nids = alc660_dac_nids, 13906 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes), 13907 .channel_mode = alc861_threestack_modes, 13908 .need_dac_fix = 1, 13909 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 13910 .adc_nids = alc861_adc_nids, 13911 .input_mux = &alc861_capture_source, 13912 }, 13913 [ALC861_UNIWILL_M31] = { 13914 .mixers = { alc861_uniwill_m31_mixer }, 13915 .init_verbs = { alc861_uniwill_m31_init_verbs }, 13916 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 13917 .dac_nids = alc861_dac_nids, 13918 .dig_out_nid = ALC861_DIGOUT_NID, 13919 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes), 13920 .channel_mode = alc861_uniwill_m31_modes, 13921 .need_dac_fix = 1, 13922 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 13923 .adc_nids = alc861_adc_nids, 13924 .input_mux = &alc861_capture_source, 13925 }, 13926 [ALC861_TOSHIBA] = { 13927 .mixers = { alc861_toshiba_mixer }, 13928 .init_verbs = { alc861_base_init_verbs, 13929 alc861_toshiba_init_verbs }, 13930 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 13931 .dac_nids = alc861_dac_nids, 13932 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 13933 .channel_mode = alc883_3ST_2ch_modes, 13934 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 13935 .adc_nids = alc861_adc_nids, 13936 .input_mux = &alc861_capture_source, 13937 .unsol_event = alc861_toshiba_unsol_event, 13938 .init_hook = alc861_toshiba_automute, 13939 }, 13940 [ALC861_ASUS] = { 13941 .mixers = { alc861_asus_mixer }, 13942 .init_verbs = { alc861_asus_init_verbs }, 13943 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 13944 .dac_nids = alc861_dac_nids, 13945 .dig_out_nid = ALC861_DIGOUT_NID, 13946 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes), 13947 .channel_mode = alc861_asus_modes, 13948 .need_dac_fix = 1, 13949 .hp_nid = 0x06, 13950 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 13951 .adc_nids = alc861_adc_nids, 13952 .input_mux = &alc861_capture_source, 13953 }, 13954 [ALC861_ASUS_LAPTOP] = { 13955 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer }, 13956 .init_verbs = { alc861_asus_init_verbs, 13957 alc861_asus_laptop_init_verbs }, 13958 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 13959 .dac_nids = alc861_dac_nids, 13960 .dig_out_nid = ALC861_DIGOUT_NID, 13961 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 13962 .channel_mode = alc883_3ST_2ch_modes, 13963 .need_dac_fix = 1, 13964 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 13965 .adc_nids = alc861_adc_nids, 13966 .input_mux = &alc861_capture_source, 13967 }, 13968}; 13969 13970 13971static int patch_alc861(struct hda_codec *codec) 13972{ 13973 struct alc_spec *spec; 13974 int board_config; 13975 int err; 13976 13977 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 13978 if (spec == NULL) 13979 return -ENOMEM; 13980 13981 codec->spec = spec; 13982 13983 board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST, 13984 alc861_models, 13985 alc861_cfg_tbl); 13986 13987 if (board_config < 0) { 13988 printk(KERN_INFO "hda_codec: Unknown model for ALC861, " 13989 "trying auto-probe from BIOS...\n"); 13990 board_config = ALC861_AUTO; 13991 } 13992 13993 if (board_config == ALC861_AUTO) { 13994 /* automatic parse from the BIOS config */ 13995 err = alc861_parse_auto_config(codec); 13996 if (err < 0) { 13997 alc_free(codec); 13998 return err; 13999 } else if (!err) { 14000 printk(KERN_INFO 14001 "hda_codec: Cannot set up configuration " 14002 "from BIOS. Using base mode...\n"); 14003 board_config = ALC861_3ST_DIG; 14004 } 14005 } 14006 14007 err = snd_hda_attach_beep_device(codec, 0x23); 14008 if (err < 0) { 14009 alc_free(codec); 14010 return err; 14011 } 14012 14013 if (board_config != ALC861_AUTO) 14014 setup_preset(spec, &alc861_presets[board_config]); 14015 14016 spec->stream_name_analog = "ALC861 Analog"; 14017 spec->stream_analog_playback = &alc861_pcm_analog_playback; 14018 spec->stream_analog_capture = &alc861_pcm_analog_capture; 14019 14020 spec->stream_name_digital = "ALC861 Digital"; 14021 spec->stream_digital_playback = &alc861_pcm_digital_playback; 14022 spec->stream_digital_capture = &alc861_pcm_digital_capture; 14023 14024 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT); 14025 14026 spec->vmaster_nid = 0x03; 14027 14028 codec->patch_ops = alc_patch_ops; 14029 if (board_config == ALC861_AUTO) 14030 spec->init_hook = alc861_auto_init; 14031#ifdef CONFIG_SND_HDA_POWER_SAVE 14032 if (!spec->loopback.amplist) 14033 spec->loopback.amplist = alc861_loopbacks; 14034#endif 14035 codec->proc_widget_hook = print_realtek_coef; 14036 14037 return 0; 14038} 14039 14040/* 14041 * ALC861-VD support 14042 * 14043 * Based on ALC882 14044 * 14045 * In addition, an independent DAC 14046 */ 14047#define ALC861VD_DIGOUT_NID 0x06 14048 14049static hda_nid_t alc861vd_dac_nids[4] = { 14050 /* front, surr, clfe, side surr */ 14051 0x02, 0x03, 0x04, 0x05 14052}; 14053 14054/* dac_nids for ALC660vd are in a different order - according to 14055 * Realtek's driver. 14056 * This should probably tesult in a different mixer for 6stack models 14057 * of ALC660vd codecs, but for now there is only 3stack mixer 14058 * - and it is the same as in 861vd. 14059 * adc_nids in ALC660vd are (is) the same as in 861vd 14060 */ 14061static hda_nid_t alc660vd_dac_nids[3] = { 14062 /* front, rear, clfe, rear_surr */ 14063 0x02, 0x04, 0x03 14064}; 14065 14066static hda_nid_t alc861vd_adc_nids[1] = { 14067 /* ADC0 */ 14068 0x09, 14069}; 14070 14071static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 }; 14072 14073/* input MUX */ 14074/* FIXME: should be a matrix-type input source selection */ 14075static struct hda_input_mux alc861vd_capture_source = { 14076 .num_items = 4, 14077 .items = { 14078 { "Mic", 0x0 }, 14079 { "Front Mic", 0x1 }, 14080 { "Line", 0x2 }, 14081 { "CD", 0x4 }, 14082 }, 14083}; 14084 14085static struct hda_input_mux alc861vd_dallas_capture_source = { 14086 .num_items = 2, 14087 .items = { 14088 { "Ext Mic", 0x0 }, 14089 { "Int Mic", 0x1 }, 14090 }, 14091}; 14092 14093static struct hda_input_mux alc861vd_hp_capture_source = { 14094 .num_items = 2, 14095 .items = { 14096 { "Front Mic", 0x0 }, 14097 { "ATAPI Mic", 0x1 }, 14098 }, 14099}; 14100 14101/* 14102 * 2ch mode 14103 */ 14104static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = { 14105 { 2, NULL } 14106}; 14107 14108/* 14109 * 6ch mode 14110 */ 14111static struct hda_verb alc861vd_6stack_ch6_init[] = { 14112 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 14113 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 14114 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 14115 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 14116 { } /* end */ 14117}; 14118 14119/* 14120 * 8ch mode 14121 */ 14122static struct hda_verb alc861vd_6stack_ch8_init[] = { 14123 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 14124 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 14125 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 14126 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 14127 { } /* end */ 14128}; 14129 14130static struct hda_channel_mode alc861vd_6stack_modes[2] = { 14131 { 6, alc861vd_6stack_ch6_init }, 14132 { 8, alc861vd_6stack_ch8_init }, 14133}; 14134 14135static struct snd_kcontrol_new alc861vd_chmode_mixer[] = { 14136 { 14137 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 14138 .name = "Channel Mode", 14139 .info = alc_ch_mode_info, 14140 .get = alc_ch_mode_get, 14141 .put = alc_ch_mode_put, 14142 }, 14143 { } /* end */ 14144}; 14145 14146/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17 14147 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b 14148 */ 14149static struct snd_kcontrol_new alc861vd_6st_mixer[] = { 14150 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 14151 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 14152 14153 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT), 14154 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 14155 14156 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, 14157 HDA_OUTPUT), 14158 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, 14159 HDA_OUTPUT), 14160 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 14161 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 14162 14163 HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT), 14164 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 14165 14166 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 14167 14168 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 14169 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 14170 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 14171 14172 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 14173 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 14174 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 14175 14176 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 14177 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 14178 14179 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 14180 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 14181 14182 { } /* end */ 14183}; 14184 14185static struct snd_kcontrol_new alc861vd_3st_mixer[] = { 14186 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 14187 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 14188 14189 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 14190 14191 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 14192 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 14193 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 14194 14195 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 14196 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 14197 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 14198 14199 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 14200 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 14201 14202 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 14203 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 14204 14205 { } /* end */ 14206}; 14207 14208static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = { 14209 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 14210 /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/ 14211 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 14212 14213 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 14214 14215 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 14216 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 14217 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 14218 14219 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 14220 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 14221 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 14222 14223 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 14224 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 14225 14226 { } /* end */ 14227}; 14228 14229/* Pin assignment: Speaker=0x14, HP = 0x15, 14230 * Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d 14231 */ 14232static struct snd_kcontrol_new alc861vd_dallas_mixer[] = { 14233 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 14234 HDA_BIND_MUTE("Speaker 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("Ext Mic Boost", 0x18, 0, HDA_INPUT), 14238 HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 14239 HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 14240 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 14241 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 14242 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 14243 { } /* end */ 14244}; 14245 14246/* Pin assignment: Speaker=0x14, Line-out = 0x15, 14247 * Front Mic=0x18, ATAPI Mic = 0x19, 14248 */ 14249static struct snd_kcontrol_new alc861vd_hp_mixer[] = { 14250 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 14251 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 14252 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 14253 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT), 14254 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 14255 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 14256 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 14257 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 14258 14259 { } /* end */ 14260}; 14261 14262/* 14263 * generic initialization of ADC, input mixers and output mixers 14264 */ 14265static struct hda_verb alc861vd_volume_init_verbs[] = { 14266 /* 14267 * Unmute ADC0 and set the default input to mic-in 14268 */ 14269 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 14270 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14271 14272 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of 14273 * the analog-loopback mixer widget 14274 */ 14275 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 14276 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 14277 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 14278 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 14279 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 14280 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 14281 14282 /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */ 14283 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14284 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14285 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 14286 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 14287 14288 /* 14289 * Set up output mixers (0x02 - 0x05) 14290 */ 14291 /* set vol=0 to output mixers */ 14292 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14293 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14294 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14295 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14296 14297 /* set up input amps for analog loopback */ 14298 /* Amp Indices: DAC = 0, mixer = 1 */ 14299 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 14300 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 14301 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 14302 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 14303 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 14304 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 14305 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 14306 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 14307 14308 { } 14309}; 14310 14311/* 14312 * 3-stack pin configuration: 14313 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b 14314 */ 14315static struct hda_verb alc861vd_3stack_init_verbs[] = { 14316 /* 14317 * Set pin mode and muting 14318 */ 14319 /* set front pin widgets 0x14 for output */ 14320 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14321 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14322 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 14323 14324 /* Mic (rear) pin: input vref at 80% */ 14325 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 14326 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 14327 /* Front Mic pin: input vref at 80% */ 14328 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 14329 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 14330 /* Line In pin: input */ 14331 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14332 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 14333 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 14334 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 14335 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14336 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 14337 /* CD pin widget for input */ 14338 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14339 14340 { } 14341}; 14342 14343/* 14344 * 6-stack pin configuration: 14345 */ 14346static struct hda_verb alc861vd_6stack_init_verbs[] = { 14347 /* 14348 * Set pin mode and muting 14349 */ 14350 /* set front pin widgets 0x14 for output */ 14351 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14352 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14353 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 14354 14355 /* Rear Pin: output 1 (0x0d) */ 14356 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14357 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14358 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 14359 /* CLFE Pin: output 2 (0x0e) */ 14360 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14361 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14362 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02}, 14363 /* Side Pin: output 3 (0x0f) */ 14364 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14365 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14366 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 14367 14368 /* Mic (rear) pin: input vref at 80% */ 14369 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 14370 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 14371 /* Front Mic pin: input vref at 80% */ 14372 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 14373 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 14374 /* Line In pin: input */ 14375 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14376 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 14377 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 14378 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 14379 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14380 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 14381 /* CD pin widget for input */ 14382 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14383 14384 { } 14385}; 14386 14387static struct hda_verb alc861vd_eapd_verbs[] = { 14388 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 14389 { } 14390}; 14391 14392static struct hda_verb alc660vd_eapd_verbs[] = { 14393 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 14394 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 14395 { } 14396}; 14397 14398static struct hda_verb alc861vd_lenovo_unsol_verbs[] = { 14399 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14400 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14401 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 14402 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 14403 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 14404 {} 14405}; 14406 14407/* toggle speaker-output according to the hp-jack state */ 14408static void alc861vd_lenovo_hp_automute(struct hda_codec *codec) 14409{ 14410 unsigned int present; 14411 unsigned char bits; 14412 14413 present = snd_hda_codec_read(codec, 0x1b, 0, 14414 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 14415 bits = present ? HDA_AMP_MUTE : 0; 14416 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 14417 HDA_AMP_MUTE, bits); 14418} 14419 14420static void alc861vd_lenovo_mic_automute(struct hda_codec *codec) 14421{ 14422 unsigned int present; 14423 unsigned char bits; 14424 14425 present = snd_hda_codec_read(codec, 0x18, 0, 14426 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 14427 bits = present ? HDA_AMP_MUTE : 0; 14428 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, 14429 HDA_AMP_MUTE, bits); 14430} 14431 14432static void alc861vd_lenovo_automute(struct hda_codec *codec) 14433{ 14434 alc861vd_lenovo_hp_automute(codec); 14435 alc861vd_lenovo_mic_automute(codec); 14436} 14437 14438static void alc861vd_lenovo_unsol_event(struct hda_codec *codec, 14439 unsigned int res) 14440{ 14441 switch (res >> 26) { 14442 case ALC880_HP_EVENT: 14443 alc861vd_lenovo_hp_automute(codec); 14444 break; 14445 case ALC880_MIC_EVENT: 14446 alc861vd_lenovo_mic_automute(codec); 14447 break; 14448 } 14449} 14450 14451static struct hda_verb alc861vd_dallas_verbs[] = { 14452 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14453 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14454 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14455 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14456 14457 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14458 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14459 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 14460 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 14461 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 14462 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 14463 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 14464 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 14465 14466 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14467 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14468 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14469 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14470 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14471 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14472 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14473 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14474 14475 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50}, 14476 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 14477 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50}, 14478 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 14479 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14480 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14481 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14482 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14483 14484 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14485 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 14486 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 14487 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 14488 14489 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 14490 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 14491 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 14492 14493 { } /* end */ 14494}; 14495 14496/* toggle speaker-output according to the hp-jack state */ 14497static void alc861vd_dallas_automute(struct hda_codec *codec) 14498{ 14499 unsigned int present; 14500 14501 present = snd_hda_codec_read(codec, 0x15, 0, 14502 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 14503 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 14504 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 14505} 14506 14507static void alc861vd_dallas_unsol_event(struct hda_codec *codec, unsigned int res) 14508{ 14509 if ((res >> 26) == ALC880_HP_EVENT) 14510 alc861vd_dallas_automute(codec); 14511} 14512 14513#ifdef CONFIG_SND_HDA_POWER_SAVE 14514#define alc861vd_loopbacks alc880_loopbacks 14515#endif 14516 14517/* pcm configuration: identiacal with ALC880 */ 14518#define alc861vd_pcm_analog_playback alc880_pcm_analog_playback 14519#define alc861vd_pcm_analog_capture alc880_pcm_analog_capture 14520#define alc861vd_pcm_digital_playback alc880_pcm_digital_playback 14521#define alc861vd_pcm_digital_capture alc880_pcm_digital_capture 14522 14523/* 14524 * configuration and preset 14525 */ 14526static const char *alc861vd_models[ALC861VD_MODEL_LAST] = { 14527 [ALC660VD_3ST] = "3stack-660", 14528 [ALC660VD_3ST_DIG] = "3stack-660-digout", 14529 [ALC660VD_ASUS_V1S] = "asus-v1s", 14530 [ALC861VD_3ST] = "3stack", 14531 [ALC861VD_3ST_DIG] = "3stack-digout", 14532 [ALC861VD_6ST_DIG] = "6stack-digout", 14533 [ALC861VD_LENOVO] = "lenovo", 14534 [ALC861VD_DALLAS] = "dallas", 14535 [ALC861VD_HP] = "hp", 14536 [ALC861VD_AUTO] = "auto", 14537}; 14538 14539static struct snd_pci_quirk alc861vd_cfg_tbl[] = { 14540 SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST), 14541 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP), 14542 SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST), 14543 SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST), 14544 SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S), 14545 SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG), 14546 SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST), 14547 SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO), 14548 /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/ 14549 SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS), 14550 SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO), 14551 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS), 14552 SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG), 14553 SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO), 14554 SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG), 14555 {} 14556}; 14557 14558static struct alc_config_preset alc861vd_presets[] = { 14559 [ALC660VD_3ST] = { 14560 .mixers = { alc861vd_3st_mixer }, 14561 .init_verbs = { alc861vd_volume_init_verbs, 14562 alc861vd_3stack_init_verbs }, 14563 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids), 14564 .dac_nids = alc660vd_dac_nids, 14565 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 14566 .channel_mode = alc861vd_3stack_2ch_modes, 14567 .input_mux = &alc861vd_capture_source, 14568 }, 14569 [ALC660VD_3ST_DIG] = { 14570 .mixers = { alc861vd_3st_mixer }, 14571 .init_verbs = { alc861vd_volume_init_verbs, 14572 alc861vd_3stack_init_verbs }, 14573 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids), 14574 .dac_nids = alc660vd_dac_nids, 14575 .dig_out_nid = ALC861VD_DIGOUT_NID, 14576 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 14577 .channel_mode = alc861vd_3stack_2ch_modes, 14578 .input_mux = &alc861vd_capture_source, 14579 }, 14580 [ALC861VD_3ST] = { 14581 .mixers = { alc861vd_3st_mixer }, 14582 .init_verbs = { alc861vd_volume_init_verbs, 14583 alc861vd_3stack_init_verbs }, 14584 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 14585 .dac_nids = alc861vd_dac_nids, 14586 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 14587 .channel_mode = alc861vd_3stack_2ch_modes, 14588 .input_mux = &alc861vd_capture_source, 14589 }, 14590 [ALC861VD_3ST_DIG] = { 14591 .mixers = { alc861vd_3st_mixer }, 14592 .init_verbs = { alc861vd_volume_init_verbs, 14593 alc861vd_3stack_init_verbs }, 14594 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 14595 .dac_nids = alc861vd_dac_nids, 14596 .dig_out_nid = ALC861VD_DIGOUT_NID, 14597 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 14598 .channel_mode = alc861vd_3stack_2ch_modes, 14599 .input_mux = &alc861vd_capture_source, 14600 }, 14601 [ALC861VD_6ST_DIG] = { 14602 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer }, 14603 .init_verbs = { alc861vd_volume_init_verbs, 14604 alc861vd_6stack_init_verbs }, 14605 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 14606 .dac_nids = alc861vd_dac_nids, 14607 .dig_out_nid = ALC861VD_DIGOUT_NID, 14608 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes), 14609 .channel_mode = alc861vd_6stack_modes, 14610 .input_mux = &alc861vd_capture_source, 14611 }, 14612 [ALC861VD_LENOVO] = { 14613 .mixers = { alc861vd_lenovo_mixer }, 14614 .init_verbs = { alc861vd_volume_init_verbs, 14615 alc861vd_3stack_init_verbs, 14616 alc861vd_eapd_verbs, 14617 alc861vd_lenovo_unsol_verbs }, 14618 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids), 14619 .dac_nids = alc660vd_dac_nids, 14620 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 14621 .channel_mode = alc861vd_3stack_2ch_modes, 14622 .input_mux = &alc861vd_capture_source, 14623 .unsol_event = alc861vd_lenovo_unsol_event, 14624 .init_hook = alc861vd_lenovo_automute, 14625 }, 14626 [ALC861VD_DALLAS] = { 14627 .mixers = { alc861vd_dallas_mixer }, 14628 .init_verbs = { alc861vd_dallas_verbs }, 14629 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 14630 .dac_nids = alc861vd_dac_nids, 14631 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 14632 .channel_mode = alc861vd_3stack_2ch_modes, 14633 .input_mux = &alc861vd_dallas_capture_source, 14634 .unsol_event = alc861vd_dallas_unsol_event, 14635 .init_hook = alc861vd_dallas_automute, 14636 }, 14637 [ALC861VD_HP] = { 14638 .mixers = { alc861vd_hp_mixer }, 14639 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs }, 14640 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 14641 .dac_nids = alc861vd_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_hp_capture_source, 14646 .unsol_event = alc861vd_dallas_unsol_event, 14647 .init_hook = alc861vd_dallas_automute, 14648 }, 14649 [ALC660VD_ASUS_V1S] = { 14650 .mixers = { alc861vd_lenovo_mixer }, 14651 .init_verbs = { alc861vd_volume_init_verbs, 14652 alc861vd_3stack_init_verbs, 14653 alc861vd_eapd_verbs, 14654 alc861vd_lenovo_unsol_verbs }, 14655 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids), 14656 .dac_nids = alc660vd_dac_nids, 14657 .dig_out_nid = ALC861VD_DIGOUT_NID, 14658 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 14659 .channel_mode = alc861vd_3stack_2ch_modes, 14660 .input_mux = &alc861vd_capture_source, 14661 .unsol_event = alc861vd_lenovo_unsol_event, 14662 .init_hook = alc861vd_lenovo_automute, 14663 }, 14664}; 14665 14666/* 14667 * BIOS auto configuration 14668 */ 14669static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec, 14670 hda_nid_t nid, int pin_type, int dac_idx) 14671{ 14672 alc_set_pin_output(codec, nid, pin_type); 14673} 14674 14675static void alc861vd_auto_init_multi_out(struct hda_codec *codec) 14676{ 14677 struct alc_spec *spec = codec->spec; 14678 int i; 14679 14680 alc_subsystem_id(codec, 0x15, 0x1b, 0x14); 14681 for (i = 0; i <= HDA_SIDE; i++) { 14682 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 14683 int pin_type = get_pin_type(spec->autocfg.line_out_type); 14684 if (nid) 14685 alc861vd_auto_set_output_and_unmute(codec, nid, 14686 pin_type, i); 14687 } 14688} 14689 14690 14691static void alc861vd_auto_init_hp_out(struct hda_codec *codec) 14692{ 14693 struct alc_spec *spec = codec->spec; 14694 hda_nid_t pin; 14695 14696 pin = spec->autocfg.hp_pins[0]; 14697 if (pin) /* connect to front and use dac 0 */ 14698 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 14699 pin = spec->autocfg.speaker_pins[0]; 14700 if (pin) 14701 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 14702} 14703 14704#define alc861vd_is_input_pin(nid) alc880_is_input_pin(nid) 14705#define ALC861VD_PIN_CD_NID ALC880_PIN_CD_NID 14706 14707static void alc861vd_auto_init_analog_input(struct hda_codec *codec) 14708{ 14709 struct alc_spec *spec = codec->spec; 14710 int i; 14711 14712 for (i = 0; i < AUTO_PIN_LAST; i++) { 14713 hda_nid_t nid = spec->autocfg.input_pins[i]; 14714 if (alc861vd_is_input_pin(nid)) { 14715 snd_hda_codec_write(codec, nid, 0, 14716 AC_VERB_SET_PIN_WIDGET_CONTROL, 14717 i <= AUTO_PIN_FRONT_MIC ? 14718 PIN_VREF80 : PIN_IN); 14719 if (nid != ALC861VD_PIN_CD_NID) 14720 snd_hda_codec_write(codec, nid, 0, 14721 AC_VERB_SET_AMP_GAIN_MUTE, 14722 AMP_OUT_MUTE); 14723 } 14724 } 14725} 14726 14727#define alc861vd_auto_init_input_src alc882_auto_init_input_src 14728 14729#define alc861vd_idx_to_mixer_vol(nid) ((nid) + 0x02) 14730#define alc861vd_idx_to_mixer_switch(nid) ((nid) + 0x0c) 14731 14732/* add playback controls from the parsed DAC table */ 14733/* Based on ALC880 version. But ALC861VD has separate, 14734 * different NIDs for mute/unmute switch and volume control */ 14735static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec, 14736 const struct auto_pin_cfg *cfg) 14737{ 14738 char name[32]; 14739 static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"}; 14740 hda_nid_t nid_v, nid_s; 14741 int i, err; 14742 14743 for (i = 0; i < cfg->line_outs; i++) { 14744 if (!spec->multiout.dac_nids[i]) 14745 continue; 14746 nid_v = alc861vd_idx_to_mixer_vol( 14747 alc880_dac_to_idx( 14748 spec->multiout.dac_nids[i])); 14749 nid_s = alc861vd_idx_to_mixer_switch( 14750 alc880_dac_to_idx( 14751 spec->multiout.dac_nids[i])); 14752 14753 if (i == 2) { 14754 /* Center/LFE */ 14755 err = add_control(spec, ALC_CTL_WIDGET_VOL, 14756 "Center Playback Volume", 14757 HDA_COMPOSE_AMP_VAL(nid_v, 1, 0, 14758 HDA_OUTPUT)); 14759 if (err < 0) 14760 return err; 14761 err = add_control(spec, ALC_CTL_WIDGET_VOL, 14762 "LFE Playback Volume", 14763 HDA_COMPOSE_AMP_VAL(nid_v, 2, 0, 14764 HDA_OUTPUT)); 14765 if (err < 0) 14766 return err; 14767 err = add_control(spec, ALC_CTL_BIND_MUTE, 14768 "Center Playback Switch", 14769 HDA_COMPOSE_AMP_VAL(nid_s, 1, 2, 14770 HDA_INPUT)); 14771 if (err < 0) 14772 return err; 14773 err = add_control(spec, ALC_CTL_BIND_MUTE, 14774 "LFE Playback Switch", 14775 HDA_COMPOSE_AMP_VAL(nid_s, 2, 2, 14776 HDA_INPUT)); 14777 if (err < 0) 14778 return err; 14779 } else { 14780 sprintf(name, "%s Playback Volume", chname[i]); 14781 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 14782 HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, 14783 HDA_OUTPUT)); 14784 if (err < 0) 14785 return err; 14786 sprintf(name, "%s Playback Switch", chname[i]); 14787 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 14788 HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, 14789 HDA_INPUT)); 14790 if (err < 0) 14791 return err; 14792 } 14793 } 14794 return 0; 14795} 14796 14797/* add playback controls for speaker and HP outputs */ 14798/* Based on ALC880 version. But ALC861VD has separate, 14799 * different NIDs for mute/unmute switch and volume control */ 14800static int alc861vd_auto_create_extra_out(struct alc_spec *spec, 14801 hda_nid_t pin, const char *pfx) 14802{ 14803 hda_nid_t nid_v, nid_s; 14804 int err; 14805 char name[32]; 14806 14807 if (!pin) 14808 return 0; 14809 14810 if (alc880_is_fixed_pin(pin)) { 14811 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin)); 14812 /* specify the DAC as the extra output */ 14813 if (!spec->multiout.hp_nid) 14814 spec->multiout.hp_nid = nid_v; 14815 else 14816 spec->multiout.extra_out_nid[0] = nid_v; 14817 /* control HP volume/switch on the output mixer amp */ 14818 nid_v = alc861vd_idx_to_mixer_vol( 14819 alc880_fixed_pin_idx(pin)); 14820 nid_s = alc861vd_idx_to_mixer_switch( 14821 alc880_fixed_pin_idx(pin)); 14822 14823 sprintf(name, "%s Playback Volume", pfx); 14824 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 14825 HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT)); 14826 if (err < 0) 14827 return err; 14828 sprintf(name, "%s Playback Switch", pfx); 14829 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 14830 HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT)); 14831 if (err < 0) 14832 return err; 14833 } else if (alc880_is_multi_pin(pin)) { 14834 /* set manual connection */ 14835 /* we have only a switch on HP-out PIN */ 14836 sprintf(name, "%s Playback Switch", pfx); 14837 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 14838 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 14839 if (err < 0) 14840 return err; 14841 } 14842 return 0; 14843} 14844 14845/* parse the BIOS configuration and set up the alc_spec 14846 * return 1 if successful, 0 if the proper config is not found, 14847 * or a negative error code 14848 * Based on ALC880 version - had to change it to override 14849 * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */ 14850static int alc861vd_parse_auto_config(struct hda_codec *codec) 14851{ 14852 struct alc_spec *spec = codec->spec; 14853 int err; 14854 static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 }; 14855 14856 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 14857 alc861vd_ignore); 14858 if (err < 0) 14859 return err; 14860 if (!spec->autocfg.line_outs) 14861 return 0; /* can't find valid BIOS pin config */ 14862 14863 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg); 14864 if (err < 0) 14865 return err; 14866 err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg); 14867 if (err < 0) 14868 return err; 14869 err = alc861vd_auto_create_extra_out(spec, 14870 spec->autocfg.speaker_pins[0], 14871 "Speaker"); 14872 if (err < 0) 14873 return err; 14874 err = alc861vd_auto_create_extra_out(spec, 14875 spec->autocfg.hp_pins[0], 14876 "Headphone"); 14877 if (err < 0) 14878 return err; 14879 err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg); 14880 if (err < 0) 14881 return err; 14882 14883 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 14884 14885 if (spec->autocfg.dig_outs) 14886 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID; 14887 14888 if (spec->kctls.list) 14889 add_mixer(spec, spec->kctls.list); 14890 14891 add_verb(spec, alc861vd_volume_init_verbs); 14892 14893 spec->num_mux_defs = 1; 14894 spec->input_mux = &spec->private_imux[0]; 14895 14896 err = alc_auto_add_mic_boost(codec); 14897 if (err < 0) 14898 return err; 14899 14900 store_pin_configs(codec); 14901 return 1; 14902} 14903 14904/* additional initialization for auto-configuration model */ 14905static void alc861vd_auto_init(struct hda_codec *codec) 14906{ 14907 struct alc_spec *spec = codec->spec; 14908 alc861vd_auto_init_multi_out(codec); 14909 alc861vd_auto_init_hp_out(codec); 14910 alc861vd_auto_init_analog_input(codec); 14911 alc861vd_auto_init_input_src(codec); 14912 if (spec->unsol_event) 14913 alc_inithook(codec); 14914} 14915 14916static int patch_alc861vd(struct hda_codec *codec) 14917{ 14918 struct alc_spec *spec; 14919 int err, board_config; 14920 14921 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 14922 if (spec == NULL) 14923 return -ENOMEM; 14924 14925 codec->spec = spec; 14926 14927 board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST, 14928 alc861vd_models, 14929 alc861vd_cfg_tbl); 14930 14931 if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) { 14932 printk(KERN_INFO "hda_codec: Unknown model for ALC660VD/" 14933 "ALC861VD, trying auto-probe from BIOS...\n"); 14934 board_config = ALC861VD_AUTO; 14935 } 14936 14937 if (board_config == ALC861VD_AUTO) { 14938 /* automatic parse from the BIOS config */ 14939 err = alc861vd_parse_auto_config(codec); 14940 if (err < 0) { 14941 alc_free(codec); 14942 return err; 14943 } else if (!err) { 14944 printk(KERN_INFO 14945 "hda_codec: Cannot set up configuration " 14946 "from BIOS. Using base mode...\n"); 14947 board_config = ALC861VD_3ST; 14948 } 14949 } 14950 14951 err = snd_hda_attach_beep_device(codec, 0x23); 14952 if (err < 0) { 14953 alc_free(codec); 14954 return err; 14955 } 14956 14957 if (board_config != ALC861VD_AUTO) 14958 setup_preset(spec, &alc861vd_presets[board_config]); 14959 14960 if (codec->vendor_id == 0x10ec0660) { 14961 spec->stream_name_analog = "ALC660-VD Analog"; 14962 spec->stream_name_digital = "ALC660-VD Digital"; 14963 /* always turn on EAPD */ 14964 add_verb(spec, alc660vd_eapd_verbs); 14965 } else { 14966 spec->stream_name_analog = "ALC861VD Analog"; 14967 spec->stream_name_digital = "ALC861VD Digital"; 14968 } 14969 14970 spec->stream_analog_playback = &alc861vd_pcm_analog_playback; 14971 spec->stream_analog_capture = &alc861vd_pcm_analog_capture; 14972 14973 spec->stream_digital_playback = &alc861vd_pcm_digital_playback; 14974 spec->stream_digital_capture = &alc861vd_pcm_digital_capture; 14975 14976 spec->adc_nids = alc861vd_adc_nids; 14977 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids); 14978 spec->capsrc_nids = alc861vd_capsrc_nids; 14979 spec->capture_style = CAPT_MIX; 14980 14981 set_capture_mixer(spec); 14982 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 14983 14984 spec->vmaster_nid = 0x02; 14985 14986 codec->patch_ops = alc_patch_ops; 14987 14988 if (board_config == ALC861VD_AUTO) 14989 spec->init_hook = alc861vd_auto_init; 14990#ifdef CONFIG_SND_HDA_POWER_SAVE 14991 if (!spec->loopback.amplist) 14992 spec->loopback.amplist = alc861vd_loopbacks; 14993#endif 14994 codec->proc_widget_hook = print_realtek_coef; 14995 14996 return 0; 14997} 14998 14999/* 15000 * ALC662 support 15001 * 15002 * ALC662 is almost identical with ALC880 but has cleaner and more flexible 15003 * configuration. Each pin widget can choose any input DACs and a mixer. 15004 * Each ADC is connected from a mixer of all inputs. This makes possible 15005 * 6-channel independent captures. 15006 * 15007 * In addition, an independent DAC for the multi-playback (not used in this 15008 * driver yet). 15009 */ 15010#define ALC662_DIGOUT_NID 0x06 15011#define ALC662_DIGIN_NID 0x0a 15012 15013static hda_nid_t alc662_dac_nids[4] = { 15014 /* front, rear, clfe, rear_surr */ 15015 0x02, 0x03, 0x04 15016}; 15017 15018static hda_nid_t alc662_adc_nids[1] = { 15019 /* ADC1-2 */ 15020 0x09, 15021}; 15022 15023static hda_nid_t alc662_capsrc_nids[1] = { 0x22 }; 15024 15025/* input MUX */ 15026/* FIXME: should be a matrix-type input source selection */ 15027static struct hda_input_mux alc662_capture_source = { 15028 .num_items = 4, 15029 .items = { 15030 { "Mic", 0x0 }, 15031 { "Front Mic", 0x1 }, 15032 { "Line", 0x2 }, 15033 { "CD", 0x4 }, 15034 }, 15035}; 15036 15037static struct hda_input_mux alc662_lenovo_101e_capture_source = { 15038 .num_items = 2, 15039 .items = { 15040 { "Mic", 0x1 }, 15041 { "Line", 0x2 }, 15042 }, 15043}; 15044 15045static struct hda_input_mux alc662_eeepc_capture_source = { 15046 .num_items = 2, 15047 .items = { 15048 { "i-Mic", 0x1 }, 15049 { "e-Mic", 0x0 }, 15050 }, 15051}; 15052 15053static struct hda_input_mux alc663_capture_source = { 15054 .num_items = 3, 15055 .items = { 15056 { "Mic", 0x0 }, 15057 { "Front Mic", 0x1 }, 15058 { "Line", 0x2 }, 15059 }, 15060}; 15061 15062static struct hda_input_mux alc663_m51va_capture_source = { 15063 .num_items = 2, 15064 .items = { 15065 { "Ext-Mic", 0x0 }, 15066 { "D-Mic", 0x9 }, 15067 }, 15068}; 15069 15070/* 15071 * 2ch mode 15072 */ 15073static struct hda_channel_mode alc662_3ST_2ch_modes[1] = { 15074 { 2, NULL } 15075}; 15076 15077/* 15078 * 2ch mode 15079 */ 15080static struct hda_verb alc662_3ST_ch2_init[] = { 15081 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 15082 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 15083 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 15084 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 15085 { } /* end */ 15086}; 15087 15088/* 15089 * 6ch mode 15090 */ 15091static struct hda_verb alc662_3ST_ch6_init[] = { 15092 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 15093 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 15094 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 }, 15095 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 15096 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 15097 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 15098 { } /* end */ 15099}; 15100 15101static struct hda_channel_mode alc662_3ST_6ch_modes[2] = { 15102 { 2, alc662_3ST_ch2_init }, 15103 { 6, alc662_3ST_ch6_init }, 15104}; 15105 15106/* 15107 * 2ch mode 15108 */ 15109static struct hda_verb alc662_sixstack_ch6_init[] = { 15110 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 15111 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 15112 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 15113 { } /* end */ 15114}; 15115 15116/* 15117 * 6ch mode 15118 */ 15119static struct hda_verb alc662_sixstack_ch8_init[] = { 15120 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 15121 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 15122 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 15123 { } /* end */ 15124}; 15125 15126static struct hda_channel_mode alc662_5stack_modes[2] = { 15127 { 2, alc662_sixstack_ch6_init }, 15128 { 6, alc662_sixstack_ch8_init }, 15129}; 15130 15131/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17 15132 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b 15133 */ 15134 15135static struct snd_kcontrol_new alc662_base_mixer[] = { 15136 /* output mixer control */ 15137 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT), 15138 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT), 15139 HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT), 15140 HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT), 15141 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT), 15142 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT), 15143 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT), 15144 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT), 15145 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 15146 15147 /*Input mixer control */ 15148 HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT), 15149 HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT), 15150 HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT), 15151 HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT), 15152 HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT), 15153 HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT), 15154 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT), 15155 HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT), 15156 { } /* end */ 15157}; 15158 15159static struct snd_kcontrol_new alc662_3ST_2ch_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_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 15163 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 15164 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 15165 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 15166 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 15167 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15168 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15169 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 15170 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 15171 { } /* end */ 15172}; 15173 15174static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = { 15175 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 15176 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT), 15177 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT), 15178 HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT), 15179 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT), 15180 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT), 15181 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT), 15182 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT), 15183 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 15184 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 15185 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 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, 0x0, HDA_INPUT), 15189 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15190 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 15191 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 15192 { } /* end */ 15193}; 15194 15195static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = { 15196 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 15197 HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT), 15198 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT), 15199 HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT), 15200 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 15201 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 15202 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 15203 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 15204 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 15205 { } /* end */ 15206}; 15207 15208static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = { 15209 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 15210 15211 HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT), 15212 HDA_CODEC_MUTE("Line-Out Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 15213 15214 HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT), 15215 HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15216 HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15217 15218 HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT), 15219 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 15220 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 15221 { } /* end */ 15222}; 15223 15224static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = { 15225 HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT), 15226 HDA_CODEC_MUTE("Line-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT), 15227 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT), 15228 HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT), 15229 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT), 15230 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT), 15231 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT), 15232 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT), 15233 HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 15234 HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT), 15235 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 15236 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 15237 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15238 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15239 { } /* end */ 15240}; 15241 15242static struct hda_bind_ctls alc663_asus_bind_master_vol = { 15243 .ops = &snd_hda_bind_vol, 15244 .values = { 15245 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT), 15246 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT), 15247 0 15248 }, 15249}; 15250 15251static struct hda_bind_ctls alc663_asus_one_bind_switch = { 15252 .ops = &snd_hda_bind_sw, 15253 .values = { 15254 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 15255 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT), 15256 0 15257 }, 15258}; 15259 15260static struct snd_kcontrol_new alc663_m51va_mixer[] = { 15261 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol), 15262 HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch), 15263 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15264 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15265 { } /* end */ 15266}; 15267 15268static struct hda_bind_ctls alc663_asus_tree_bind_switch = { 15269 .ops = &snd_hda_bind_sw, 15270 .values = { 15271 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 15272 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT), 15273 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT), 15274 0 15275 }, 15276}; 15277 15278static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = { 15279 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol), 15280 HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch), 15281 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15282 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15283 HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 15284 HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 15285 15286 { } /* end */ 15287}; 15288 15289static struct hda_bind_ctls alc663_asus_four_bind_switch = { 15290 .ops = &snd_hda_bind_sw, 15291 .values = { 15292 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 15293 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT), 15294 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT), 15295 0 15296 }, 15297}; 15298 15299static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = { 15300 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol), 15301 HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch), 15302 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15303 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15304 HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 15305 HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 15306 { } /* end */ 15307}; 15308 15309static struct snd_kcontrol_new alc662_1bjd_mixer[] = { 15310 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 15311 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 15312 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 15313 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15314 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15315 HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 15316 HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 15317 { } /* end */ 15318}; 15319 15320static struct hda_bind_ctls alc663_asus_two_bind_master_vol = { 15321 .ops = &snd_hda_bind_vol, 15322 .values = { 15323 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT), 15324 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT), 15325 0 15326 }, 15327}; 15328 15329static struct hda_bind_ctls alc663_asus_two_bind_switch = { 15330 .ops = &snd_hda_bind_sw, 15331 .values = { 15332 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 15333 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT), 15334 0 15335 }, 15336}; 15337 15338static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = { 15339 HDA_BIND_VOL("Master Playback Volume", 15340 &alc663_asus_two_bind_master_vol), 15341 HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch), 15342 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 15343 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT), 15344 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15345 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15346 { } /* end */ 15347}; 15348 15349static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = { 15350 HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol), 15351 HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch), 15352 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 15353 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 15354 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15355 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15356 { } /* end */ 15357}; 15358 15359static struct snd_kcontrol_new alc663_g71v_mixer[] = { 15360 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 15361 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 15362 HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT), 15363 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT), 15364 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT), 15365 15366 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15367 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15368 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 15369 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 15370 { } /* end */ 15371}; 15372 15373static struct snd_kcontrol_new alc663_g50v_mixer[] = { 15374 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 15375 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 15376 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT), 15377 15378 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 15379 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 15380 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 15381 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 15382 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 15383 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 15384 { } /* end */ 15385}; 15386 15387static struct snd_kcontrol_new alc662_chmode_mixer[] = { 15388 { 15389 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 15390 .name = "Channel Mode", 15391 .info = alc_ch_mode_info, 15392 .get = alc_ch_mode_get, 15393 .put = alc_ch_mode_put, 15394 }, 15395 { } /* end */ 15396}; 15397 15398static struct hda_verb alc662_init_verbs[] = { 15399 /* ADC: mute amp left and right */ 15400 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15401 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 15402 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 15403 15404 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15405 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 15406 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 15407 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 15408 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 15409 15410 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15411 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15412 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15413 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15414 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15415 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15416 15417 /* Front Pin: output 0 (0x0c) */ 15418 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 15419 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15420 15421 /* Rear Pin: output 1 (0x0d) */ 15422 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 15423 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15424 15425 /* CLFE Pin: output 2 (0x0e) */ 15426 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 15427 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15428 15429 /* Mic (rear) pin: input vref at 80% */ 15430 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 15431 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 15432 /* Front Mic pin: input vref at 80% */ 15433 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 15434 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 15435 /* Line In pin: input */ 15436 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 15437 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 15438 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 15439 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15440 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15441 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 15442 /* CD pin widget for input */ 15443 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 15444 15445 /* FIXME: use matrix-type input source selection */ 15446 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 15447 /* Input mixer */ 15448 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15449 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15450 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 15451 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 15452 15453 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15454 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15455 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 15456 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 15457 15458 /* always trun on EAPD */ 15459 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 15460 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 15461 15462 { } 15463}; 15464 15465static struct hda_verb alc662_sue_init_verbs[] = { 15466 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT}, 15467 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT}, 15468 {} 15469}; 15470 15471static struct hda_verb alc662_eeepc_sue_init_verbs[] = { 15472 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 15473 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15474 {} 15475}; 15476 15477/* Set Unsolicited Event*/ 15478static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = { 15479 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 15480 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15481 {} 15482}; 15483 15484/* 15485 * generic initialization of ADC, input mixers and output mixers 15486 */ 15487static struct hda_verb alc662_auto_init_verbs[] = { 15488 /* 15489 * Unmute ADC and set the default input to mic-in 15490 */ 15491 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 15492 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15493 15494 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 15495 * mixer widget 15496 * Note: PASD motherboards uses the Line In 2 as the input for front 15497 * panel mic (mic 2) 15498 */ 15499 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 15500 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15501 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 15502 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 15503 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 15504 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 15505 15506 /* 15507 * Set up output mixers (0x0c - 0x0f) 15508 */ 15509 /* set vol=0 to output mixers */ 15510 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 15511 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 15512 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 15513 15514 /* set up input amps for analog loopback */ 15515 /* Amp Indices: DAC = 0, mixer = 1 */ 15516 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15517 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15518 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15519 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15520 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15521 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15522 15523 15524 /* FIXME: use matrix-type input source selection */ 15525 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 15526 /* Input mixer */ 15527 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15528 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15529 { } 15530}; 15531 15532/* additional verbs for ALC663 */ 15533static struct hda_verb alc663_auto_init_verbs[] = { 15534 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 15535 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15536 { } 15537}; 15538 15539static struct hda_verb alc663_m51va_init_verbs[] = { 15540 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 15541 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 15542 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15543 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15544 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */ 15545 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15546 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)}, 15547 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 15548 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15549 {} 15550}; 15551 15552static struct hda_verb alc663_21jd_amic_init_verbs[] = { 15553 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15554 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15555 {0x21, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */ 15556 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15557 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15558 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 15559 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15560 {} 15561}; 15562 15563static struct hda_verb alc662_1bjd_amic_init_verbs[] = { 15564 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 15565 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15566 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15567 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */ 15568 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15569 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15570 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 15571 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15572 {} 15573}; 15574 15575static struct hda_verb alc663_15jd_amic_init_verbs[] = { 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, 0x01}, /* 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 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15583 {} 15584}; 15585 15586static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = { 15587 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 15588 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15589 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15590 {0x21, AC_VERB_SET_CONNECT_SEL, 0x0}, /* Headphone */ 15591 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15592 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15593 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0}, /* Headphone */ 15594 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15595 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15596 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 15597 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15598 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15599 {} 15600}; 15601 15602static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = { 15603 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 15604 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15605 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15606 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */ 15607 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15608 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15609 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Headphone */ 15610 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15611 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 15612 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 15613 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15614 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15615 {} 15616}; 15617 15618static struct hda_verb alc663_g71v_init_verbs[] = { 15619 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15620 /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */ 15621 /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */ 15622 15623 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15624 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15625 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */ 15626 15627 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT}, 15628 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT}, 15629 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT}, 15630 {} 15631}; 15632 15633static struct hda_verb alc663_g50v_init_verbs[] = { 15634 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 15635 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 15636 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */ 15637 15638 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 15639 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15640 {} 15641}; 15642 15643static struct hda_verb alc662_ecs_init_verbs[] = { 15644 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f}, 15645 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 15646 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 15647 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 15648 {} 15649}; 15650 15651static struct snd_kcontrol_new alc662_auto_capture_mixer[] = { 15652 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT), 15653 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT), 15654 { } /* end */ 15655}; 15656 15657static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec) 15658{ 15659 unsigned int present; 15660 unsigned char bits; 15661 15662 present = snd_hda_codec_read(codec, 0x14, 0, 15663 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 15664 bits = present ? HDA_AMP_MUTE : 0; 15665 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 15666 HDA_AMP_MUTE, bits); 15667} 15668 15669static void alc662_lenovo_101e_all_automute(struct hda_codec *codec) 15670{ 15671 unsigned int present; 15672 unsigned char bits; 15673 15674 present = snd_hda_codec_read(codec, 0x1b, 0, 15675 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 15676 bits = present ? HDA_AMP_MUTE : 0; 15677 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 15678 HDA_AMP_MUTE, bits); 15679 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 15680 HDA_AMP_MUTE, bits); 15681} 15682 15683static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec, 15684 unsigned int res) 15685{ 15686 if ((res >> 26) == ALC880_HP_EVENT) 15687 alc662_lenovo_101e_all_automute(codec); 15688 if ((res >> 26) == ALC880_FRONT_EVENT) 15689 alc662_lenovo_101e_ispeaker_automute(codec); 15690} 15691 15692static void alc662_eeepc_mic_automute(struct hda_codec *codec) 15693{ 15694 unsigned int present; 15695 15696 present = snd_hda_codec_read(codec, 0x18, 0, 15697 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 15698 snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE, 15699 0x7000 | (0x00 << 8) | (present ? 0 : 0x80)); 15700 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE, 15701 0x7000 | (0x00 << 8) | (present ? 0 : 0x80)); 15702 snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE, 15703 0x7000 | (0x01 << 8) | (present ? 0x80 : 0)); 15704 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE, 15705 0x7000 | (0x01 << 8) | (present ? 0x80 : 0)); 15706} 15707 15708/* unsolicited event for HP jack sensing */ 15709static void alc662_eeepc_unsol_event(struct hda_codec *codec, 15710 unsigned int res) 15711{ 15712 if ((res >> 26) == ALC880_HP_EVENT) 15713 alc262_hippo1_automute( codec ); 15714 15715 if ((res >> 26) == ALC880_MIC_EVENT) 15716 alc662_eeepc_mic_automute(codec); 15717} 15718 15719static void alc662_eeepc_inithook(struct hda_codec *codec) 15720{ 15721 alc262_hippo1_automute( codec ); 15722 alc662_eeepc_mic_automute(codec); 15723} 15724 15725static void alc662_eeepc_ep20_automute(struct hda_codec *codec) 15726{ 15727 unsigned int mute; 15728 unsigned int present; 15729 15730 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0); 15731 present = snd_hda_codec_read(codec, 0x14, 0, 15732 AC_VERB_GET_PIN_SENSE, 0); 15733 present = (present & 0x80000000) != 0; 15734 if (present) { 15735 /* mute internal speaker */ 15736 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 15737 HDA_AMP_MUTE, HDA_AMP_MUTE); 15738 } else { 15739 /* unmute internal speaker if necessary */ 15740 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0); 15741 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 15742 HDA_AMP_MUTE, mute); 15743 } 15744} 15745 15746/* unsolicited event for HP jack sensing */ 15747static void alc662_eeepc_ep20_unsol_event(struct hda_codec *codec, 15748 unsigned int res) 15749{ 15750 if ((res >> 26) == ALC880_HP_EVENT) 15751 alc662_eeepc_ep20_automute(codec); 15752} 15753 15754static void alc662_eeepc_ep20_inithook(struct hda_codec *codec) 15755{ 15756 alc662_eeepc_ep20_automute(codec); 15757} 15758 15759static void alc663_m51va_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} 15773 15774static void alc663_21jd_two_speaker_automute(struct hda_codec *codec) 15775{ 15776 unsigned int present; 15777 unsigned char bits; 15778 15779 present = snd_hda_codec_read(codec, 0x21, 0, 15780 AC_VERB_GET_PIN_SENSE, 0) 15781 & AC_PINSENSE_PRESENCE; 15782 bits = present ? HDA_AMP_MUTE : 0; 15783 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 15784 AMP_IN_MUTE(0), bits); 15785 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 15786 AMP_IN_MUTE(0), bits); 15787 snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0, 15788 AMP_IN_MUTE(0), bits); 15789 snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1, 15790 AMP_IN_MUTE(0), bits); 15791} 15792 15793static void alc663_15jd_two_speaker_automute(struct hda_codec *codec) 15794{ 15795 unsigned int present; 15796 unsigned char bits; 15797 15798 present = snd_hda_codec_read(codec, 0x15, 0, 15799 AC_VERB_GET_PIN_SENSE, 0) 15800 & AC_PINSENSE_PRESENCE; 15801 bits = present ? HDA_AMP_MUTE : 0; 15802 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 15803 AMP_IN_MUTE(0), bits); 15804 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 15805 AMP_IN_MUTE(0), bits); 15806 snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0, 15807 AMP_IN_MUTE(0), bits); 15808 snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1, 15809 AMP_IN_MUTE(0), bits); 15810} 15811 15812static void alc662_f5z_speaker_automute(struct hda_codec *codec) 15813{ 15814 unsigned int present; 15815 unsigned char bits; 15816 15817 present = snd_hda_codec_read(codec, 0x1b, 0, 15818 AC_VERB_GET_PIN_SENSE, 0) 15819 & AC_PINSENSE_PRESENCE; 15820 bits = present ? 0 : PIN_OUT; 15821 snd_hda_codec_write(codec, 0x14, 0, 15822 AC_VERB_SET_PIN_WIDGET_CONTROL, bits); 15823} 15824 15825static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec) 15826{ 15827 unsigned int present1, present2; 15828 15829 present1 = snd_hda_codec_read(codec, 0x21, 0, 15830 AC_VERB_GET_PIN_SENSE, 0) 15831 & AC_PINSENSE_PRESENCE; 15832 present2 = snd_hda_codec_read(codec, 0x15, 0, 15833 AC_VERB_GET_PIN_SENSE, 0) 15834 & AC_PINSENSE_PRESENCE; 15835 15836 if (present1 || present2) { 15837 snd_hda_codec_write_cache(codec, 0x14, 0, 15838 AC_VERB_SET_PIN_WIDGET_CONTROL, 0); 15839 } else { 15840 snd_hda_codec_write_cache(codec, 0x14, 0, 15841 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 15842 } 15843} 15844 15845static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec) 15846{ 15847 unsigned int present1, present2; 15848 15849 present1 = snd_hda_codec_read(codec, 0x1b, 0, 15850 AC_VERB_GET_PIN_SENSE, 0) 15851 & AC_PINSENSE_PRESENCE; 15852 present2 = snd_hda_codec_read(codec, 0x15, 0, 15853 AC_VERB_GET_PIN_SENSE, 0) 15854 & AC_PINSENSE_PRESENCE; 15855 15856 if (present1 || present2) { 15857 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 15858 AMP_IN_MUTE(0), AMP_IN_MUTE(0)); 15859 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 15860 AMP_IN_MUTE(0), AMP_IN_MUTE(0)); 15861 } else { 15862 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 15863 AMP_IN_MUTE(0), 0); 15864 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 15865 AMP_IN_MUTE(0), 0); 15866 } 15867} 15868 15869static void alc663_m51va_mic_automute(struct hda_codec *codec) 15870{ 15871 unsigned int present; 15872 15873 present = snd_hda_codec_read(codec, 0x18, 0, 15874 AC_VERB_GET_PIN_SENSE, 0) 15875 & AC_PINSENSE_PRESENCE; 15876 snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE, 15877 0x7000 | (0x00 << 8) | (present ? 0 : 0x80)); 15878 snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE, 15879 0x7000 | (0x00 << 8) | (present ? 0 : 0x80)); 15880 snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE, 15881 0x7000 | (0x09 << 8) | (present ? 0x80 : 0)); 15882 snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE, 15883 0x7000 | (0x09 << 8) | (present ? 0x80 : 0)); 15884} 15885 15886static void alc663_m51va_unsol_event(struct hda_codec *codec, 15887 unsigned int res) 15888{ 15889 switch (res >> 26) { 15890 case ALC880_HP_EVENT: 15891 alc663_m51va_speaker_automute(codec); 15892 break; 15893 case ALC880_MIC_EVENT: 15894 alc663_m51va_mic_automute(codec); 15895 break; 15896 } 15897} 15898 15899static void alc663_m51va_inithook(struct hda_codec *codec) 15900{ 15901 alc663_m51va_speaker_automute(codec); 15902 alc663_m51va_mic_automute(codec); 15903} 15904 15905/* ***************** Mode1 ******************************/ 15906static void alc663_mode1_unsol_event(struct hda_codec *codec, 15907 unsigned int res) 15908{ 15909 switch (res >> 26) { 15910 case ALC880_HP_EVENT: 15911 alc663_m51va_speaker_automute(codec); 15912 break; 15913 case ALC880_MIC_EVENT: 15914 alc662_eeepc_mic_automute(codec); 15915 break; 15916 } 15917} 15918 15919static void alc663_mode1_inithook(struct hda_codec *codec) 15920{ 15921 alc663_m51va_speaker_automute(codec); 15922 alc662_eeepc_mic_automute(codec); 15923} 15924/* ***************** Mode2 ******************************/ 15925static void alc662_mode2_unsol_event(struct hda_codec *codec, 15926 unsigned int res) 15927{ 15928 switch (res >> 26) { 15929 case ALC880_HP_EVENT: 15930 alc662_f5z_speaker_automute(codec); 15931 break; 15932 case ALC880_MIC_EVENT: 15933 alc662_eeepc_mic_automute(codec); 15934 break; 15935 } 15936} 15937 15938static void alc662_mode2_inithook(struct hda_codec *codec) 15939{ 15940 alc662_f5z_speaker_automute(codec); 15941 alc662_eeepc_mic_automute(codec); 15942} 15943/* ***************** Mode3 ******************************/ 15944static void alc663_mode3_unsol_event(struct hda_codec *codec, 15945 unsigned int res) 15946{ 15947 switch (res >> 26) { 15948 case ALC880_HP_EVENT: 15949 alc663_two_hp_m1_speaker_automute(codec); 15950 break; 15951 case ALC880_MIC_EVENT: 15952 alc662_eeepc_mic_automute(codec); 15953 break; 15954 } 15955} 15956 15957static void alc663_mode3_inithook(struct hda_codec *codec) 15958{ 15959 alc663_two_hp_m1_speaker_automute(codec); 15960 alc662_eeepc_mic_automute(codec); 15961} 15962/* ***************** Mode4 ******************************/ 15963static void alc663_mode4_unsol_event(struct hda_codec *codec, 15964 unsigned int res) 15965{ 15966 switch (res >> 26) { 15967 case ALC880_HP_EVENT: 15968 alc663_21jd_two_speaker_automute(codec); 15969 break; 15970 case ALC880_MIC_EVENT: 15971 alc662_eeepc_mic_automute(codec); 15972 break; 15973 } 15974} 15975 15976static void alc663_mode4_inithook(struct hda_codec *codec) 15977{ 15978 alc663_21jd_two_speaker_automute(codec); 15979 alc662_eeepc_mic_automute(codec); 15980} 15981/* ***************** Mode5 ******************************/ 15982static void alc663_mode5_unsol_event(struct hda_codec *codec, 15983 unsigned int res) 15984{ 15985 switch (res >> 26) { 15986 case ALC880_HP_EVENT: 15987 alc663_15jd_two_speaker_automute(codec); 15988 break; 15989 case ALC880_MIC_EVENT: 15990 alc662_eeepc_mic_automute(codec); 15991 break; 15992 } 15993} 15994 15995static void alc663_mode5_inithook(struct hda_codec *codec) 15996{ 15997 alc663_15jd_two_speaker_automute(codec); 15998 alc662_eeepc_mic_automute(codec); 15999} 16000/* ***************** Mode6 ******************************/ 16001static void alc663_mode6_unsol_event(struct hda_codec *codec, 16002 unsigned int res) 16003{ 16004 switch (res >> 26) { 16005 case ALC880_HP_EVENT: 16006 alc663_two_hp_m2_speaker_automute(codec); 16007 break; 16008 case ALC880_MIC_EVENT: 16009 alc662_eeepc_mic_automute(codec); 16010 break; 16011 } 16012} 16013 16014static void alc663_mode6_inithook(struct hda_codec *codec) 16015{ 16016 alc663_two_hp_m2_speaker_automute(codec); 16017 alc662_eeepc_mic_automute(codec); 16018} 16019 16020static void alc663_g71v_hp_automute(struct hda_codec *codec) 16021{ 16022 unsigned int present; 16023 unsigned char bits; 16024 16025 present = snd_hda_codec_read(codec, 0x21, 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, 0x15, HDA_OUTPUT, 0, 16030 HDA_AMP_MUTE, bits); 16031 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 16032 HDA_AMP_MUTE, bits); 16033} 16034 16035static void alc663_g71v_front_automute(struct hda_codec *codec) 16036{ 16037 unsigned int present; 16038 unsigned char bits; 16039 16040 present = snd_hda_codec_read(codec, 0x15, 0, 16041 AC_VERB_GET_PIN_SENSE, 0) 16042 & AC_PINSENSE_PRESENCE; 16043 bits = present ? HDA_AMP_MUTE : 0; 16044 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 16045 HDA_AMP_MUTE, bits); 16046} 16047 16048static void alc663_g71v_unsol_event(struct hda_codec *codec, 16049 unsigned int res) 16050{ 16051 switch (res >> 26) { 16052 case ALC880_HP_EVENT: 16053 alc663_g71v_hp_automute(codec); 16054 break; 16055 case ALC880_FRONT_EVENT: 16056 alc663_g71v_front_automute(codec); 16057 break; 16058 case ALC880_MIC_EVENT: 16059 alc662_eeepc_mic_automute(codec); 16060 break; 16061 } 16062} 16063 16064static void alc663_g71v_inithook(struct hda_codec *codec) 16065{ 16066 alc663_g71v_front_automute(codec); 16067 alc663_g71v_hp_automute(codec); 16068 alc662_eeepc_mic_automute(codec); 16069} 16070 16071static void alc663_g50v_unsol_event(struct hda_codec *codec, 16072 unsigned int res) 16073{ 16074 switch (res >> 26) { 16075 case ALC880_HP_EVENT: 16076 alc663_m51va_speaker_automute(codec); 16077 break; 16078 case ALC880_MIC_EVENT: 16079 alc662_eeepc_mic_automute(codec); 16080 break; 16081 } 16082} 16083 16084static void alc663_g50v_inithook(struct hda_codec *codec) 16085{ 16086 alc663_m51va_speaker_automute(codec); 16087 alc662_eeepc_mic_automute(codec); 16088} 16089 16090/* bind hp and internal speaker mute (with plug check) */ 16091static int alc662_ecs_master_sw_put(struct snd_kcontrol *kcontrol, 16092 struct snd_ctl_elem_value *ucontrol) 16093{ 16094 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 16095 long *valp = ucontrol->value.integer.value; 16096 int change; 16097 16098 change = snd_hda_codec_amp_update(codec, 0x1b, 0, HDA_OUTPUT, 0, 16099 HDA_AMP_MUTE, 16100 valp[0] ? 0 : HDA_AMP_MUTE); 16101 change |= snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0, 16102 HDA_AMP_MUTE, 16103 valp[1] ? 0 : HDA_AMP_MUTE); 16104 if (change) 16105 alc262_hippo1_automute(codec); 16106 return change; 16107} 16108 16109static struct snd_kcontrol_new alc662_ecs_mixer[] = { 16110 HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT), 16111 { 16112 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 16113 .name = "Master Playback Switch", 16114 .info = snd_hda_mixer_amp_switch_info, 16115 .get = snd_hda_mixer_amp_switch_get, 16116 .put = alc662_ecs_master_sw_put, 16117 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT), 16118 }, 16119 16120 HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT), 16121 HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT), 16122 HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT), 16123 16124 HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT), 16125 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 16126 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 16127 { } /* end */ 16128}; 16129 16130#ifdef CONFIG_SND_HDA_POWER_SAVE 16131#define alc662_loopbacks alc880_loopbacks 16132#endif 16133 16134 16135/* pcm configuration: identiacal with ALC880 */ 16136#define alc662_pcm_analog_playback alc880_pcm_analog_playback 16137#define alc662_pcm_analog_capture alc880_pcm_analog_capture 16138#define alc662_pcm_digital_playback alc880_pcm_digital_playback 16139#define alc662_pcm_digital_capture alc880_pcm_digital_capture 16140 16141/* 16142 * configuration and preset 16143 */ 16144static const char *alc662_models[ALC662_MODEL_LAST] = { 16145 [ALC662_3ST_2ch_DIG] = "3stack-dig", 16146 [ALC662_3ST_6ch_DIG] = "3stack-6ch-dig", 16147 [ALC662_3ST_6ch] = "3stack-6ch", 16148 [ALC662_5ST_DIG] = "6stack-dig", 16149 [ALC662_LENOVO_101E] = "lenovo-101e", 16150 [ALC662_ASUS_EEEPC_P701] = "eeepc-p701", 16151 [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20", 16152 [ALC662_ECS] = "ecs", 16153 [ALC663_ASUS_M51VA] = "m51va", 16154 [ALC663_ASUS_G71V] = "g71v", 16155 [ALC663_ASUS_H13] = "h13", 16156 [ALC663_ASUS_G50V] = "g50v", 16157 [ALC663_ASUS_MODE1] = "asus-mode1", 16158 [ALC662_ASUS_MODE2] = "asus-mode2", 16159 [ALC663_ASUS_MODE3] = "asus-mode3", 16160 [ALC663_ASUS_MODE4] = "asus-mode4", 16161 [ALC663_ASUS_MODE5] = "asus-mode5", 16162 [ALC663_ASUS_MODE6] = "asus-mode6", 16163 [ALC662_AUTO] = "auto", 16164}; 16165 16166static struct snd_pci_quirk alc662_cfg_tbl[] = { 16167 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS), 16168 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1), 16169 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3), 16170 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3), 16171 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1), 16172 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2), 16173 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1), 16174 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2), 16175 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2), 16176 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2), 16177 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6), 16178 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6), 16179 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2), 16180 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2), 16181 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5), 16182 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6), 16183 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2), 16184 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2), 16185 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2), 16186 SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA), 16187 /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/ 16188 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3), 16189 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3), 16190 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1), 16191 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2), 16192 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2), 16193 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1), 16194 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3), 16195 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1), 16196 SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V), 16197 /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/ 16198 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1), 16199 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2), 16200 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1), 16201 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4), 16202 SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG), 16203 SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701), 16204 SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20), 16205 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS), 16206 SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K", 16207 ALC662_3ST_6ch_DIG), 16208 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L", 16209 ALC662_3ST_6ch_DIG), 16210 SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG), 16211 SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E), 16212 SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0", 16213 ALC662_3ST_6ch_DIG), 16214 SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x", 16215 ALC663_ASUS_H13), 16216 {} 16217}; 16218 16219static struct alc_config_preset alc662_presets[] = { 16220 [ALC662_3ST_2ch_DIG] = { 16221 .mixers = { alc662_3ST_2ch_mixer }, 16222 .init_verbs = { alc662_init_verbs }, 16223 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16224 .dac_nids = alc662_dac_nids, 16225 .dig_out_nid = ALC662_DIGOUT_NID, 16226 .dig_in_nid = ALC662_DIGIN_NID, 16227 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16228 .channel_mode = alc662_3ST_2ch_modes, 16229 .input_mux = &alc662_capture_source, 16230 }, 16231 [ALC662_3ST_6ch_DIG] = { 16232 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer }, 16233 .init_verbs = { alc662_init_verbs }, 16234 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16235 .dac_nids = alc662_dac_nids, 16236 .dig_out_nid = ALC662_DIGOUT_NID, 16237 .dig_in_nid = ALC662_DIGIN_NID, 16238 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes), 16239 .channel_mode = alc662_3ST_6ch_modes, 16240 .need_dac_fix = 1, 16241 .input_mux = &alc662_capture_source, 16242 }, 16243 [ALC662_3ST_6ch] = { 16244 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer }, 16245 .init_verbs = { alc662_init_verbs }, 16246 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16247 .dac_nids = alc662_dac_nids, 16248 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes), 16249 .channel_mode = alc662_3ST_6ch_modes, 16250 .need_dac_fix = 1, 16251 .input_mux = &alc662_capture_source, 16252 }, 16253 [ALC662_5ST_DIG] = { 16254 .mixers = { alc662_base_mixer, alc662_chmode_mixer }, 16255 .init_verbs = { alc662_init_verbs }, 16256 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16257 .dac_nids = alc662_dac_nids, 16258 .dig_out_nid = ALC662_DIGOUT_NID, 16259 .dig_in_nid = ALC662_DIGIN_NID, 16260 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes), 16261 .channel_mode = alc662_5stack_modes, 16262 .input_mux = &alc662_capture_source, 16263 }, 16264 [ALC662_LENOVO_101E] = { 16265 .mixers = { alc662_lenovo_101e_mixer }, 16266 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs }, 16267 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16268 .dac_nids = alc662_dac_nids, 16269 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16270 .channel_mode = alc662_3ST_2ch_modes, 16271 .input_mux = &alc662_lenovo_101e_capture_source, 16272 .unsol_event = alc662_lenovo_101e_unsol_event, 16273 .init_hook = alc662_lenovo_101e_all_automute, 16274 }, 16275 [ALC662_ASUS_EEEPC_P701] = { 16276 .mixers = { alc662_eeepc_p701_mixer }, 16277 .init_verbs = { alc662_init_verbs, 16278 alc662_eeepc_sue_init_verbs }, 16279 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16280 .dac_nids = alc662_dac_nids, 16281 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16282 .channel_mode = alc662_3ST_2ch_modes, 16283 .input_mux = &alc662_eeepc_capture_source, 16284 .unsol_event = alc662_eeepc_unsol_event, 16285 .init_hook = alc662_eeepc_inithook, 16286 }, 16287 [ALC662_ASUS_EEEPC_EP20] = { 16288 .mixers = { alc662_eeepc_ep20_mixer, 16289 alc662_chmode_mixer }, 16290 .init_verbs = { alc662_init_verbs, 16291 alc662_eeepc_ep20_sue_init_verbs }, 16292 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16293 .dac_nids = alc662_dac_nids, 16294 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes), 16295 .channel_mode = alc662_3ST_6ch_modes, 16296 .input_mux = &alc662_lenovo_101e_capture_source, 16297 .unsol_event = alc662_eeepc_ep20_unsol_event, 16298 .init_hook = alc662_eeepc_ep20_inithook, 16299 }, 16300 [ALC662_ECS] = { 16301 .mixers = { alc662_ecs_mixer }, 16302 .init_verbs = { alc662_init_verbs, 16303 alc662_ecs_init_verbs }, 16304 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16305 .dac_nids = alc662_dac_nids, 16306 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16307 .channel_mode = alc662_3ST_2ch_modes, 16308 .input_mux = &alc662_eeepc_capture_source, 16309 .unsol_event = alc662_eeepc_unsol_event, 16310 .init_hook = alc662_eeepc_inithook, 16311 }, 16312 [ALC663_ASUS_M51VA] = { 16313 .mixers = { alc663_m51va_mixer }, 16314 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs }, 16315 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16316 .dac_nids = alc662_dac_nids, 16317 .dig_out_nid = ALC662_DIGOUT_NID, 16318 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16319 .channel_mode = alc662_3ST_2ch_modes, 16320 .input_mux = &alc663_m51va_capture_source, 16321 .unsol_event = alc663_m51va_unsol_event, 16322 .init_hook = alc663_m51va_inithook, 16323 }, 16324 [ALC663_ASUS_G71V] = { 16325 .mixers = { alc663_g71v_mixer }, 16326 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs }, 16327 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16328 .dac_nids = alc662_dac_nids, 16329 .dig_out_nid = ALC662_DIGOUT_NID, 16330 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16331 .channel_mode = alc662_3ST_2ch_modes, 16332 .input_mux = &alc662_eeepc_capture_source, 16333 .unsol_event = alc663_g71v_unsol_event, 16334 .init_hook = alc663_g71v_inithook, 16335 }, 16336 [ALC663_ASUS_H13] = { 16337 .mixers = { alc663_m51va_mixer }, 16338 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs }, 16339 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16340 .dac_nids = alc662_dac_nids, 16341 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16342 .channel_mode = alc662_3ST_2ch_modes, 16343 .input_mux = &alc663_m51va_capture_source, 16344 .unsol_event = alc663_m51va_unsol_event, 16345 .init_hook = alc663_m51va_inithook, 16346 }, 16347 [ALC663_ASUS_G50V] = { 16348 .mixers = { alc663_g50v_mixer }, 16349 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs }, 16350 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16351 .dac_nids = alc662_dac_nids, 16352 .dig_out_nid = ALC662_DIGOUT_NID, 16353 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes), 16354 .channel_mode = alc662_3ST_6ch_modes, 16355 .input_mux = &alc663_capture_source, 16356 .unsol_event = alc663_g50v_unsol_event, 16357 .init_hook = alc663_g50v_inithook, 16358 }, 16359 [ALC663_ASUS_MODE1] = { 16360 .mixers = { alc663_m51va_mixer }, 16361 .cap_mixer = alc662_auto_capture_mixer, 16362 .init_verbs = { alc662_init_verbs, 16363 alc663_21jd_amic_init_verbs }, 16364 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16365 .hp_nid = 0x03, 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 = alc663_mode1_unsol_event, 16372 .init_hook = alc663_mode1_inithook, 16373 }, 16374 [ALC662_ASUS_MODE2] = { 16375 .mixers = { alc662_1bjd_mixer }, 16376 .cap_mixer = alc662_auto_capture_mixer, 16377 .init_verbs = { alc662_init_verbs, 16378 alc662_1bjd_amic_init_verbs }, 16379 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16380 .dac_nids = alc662_dac_nids, 16381 .dig_out_nid = ALC662_DIGOUT_NID, 16382 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16383 .channel_mode = alc662_3ST_2ch_modes, 16384 .input_mux = &alc662_eeepc_capture_source, 16385 .unsol_event = alc662_mode2_unsol_event, 16386 .init_hook = alc662_mode2_inithook, 16387 }, 16388 [ALC663_ASUS_MODE3] = { 16389 .mixers = { alc663_two_hp_m1_mixer }, 16390 .cap_mixer = alc662_auto_capture_mixer, 16391 .init_verbs = { alc662_init_verbs, 16392 alc663_two_hp_amic_m1_init_verbs }, 16393 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16394 .hp_nid = 0x03, 16395 .dac_nids = alc662_dac_nids, 16396 .dig_out_nid = ALC662_DIGOUT_NID, 16397 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16398 .channel_mode = alc662_3ST_2ch_modes, 16399 .input_mux = &alc662_eeepc_capture_source, 16400 .unsol_event = alc663_mode3_unsol_event, 16401 .init_hook = alc663_mode3_inithook, 16402 }, 16403 [ALC663_ASUS_MODE4] = { 16404 .mixers = { alc663_asus_21jd_clfe_mixer }, 16405 .cap_mixer = alc662_auto_capture_mixer, 16406 .init_verbs = { alc662_init_verbs, 16407 alc663_21jd_amic_init_verbs}, 16408 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16409 .hp_nid = 0x03, 16410 .dac_nids = alc662_dac_nids, 16411 .dig_out_nid = ALC662_DIGOUT_NID, 16412 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16413 .channel_mode = alc662_3ST_2ch_modes, 16414 .input_mux = &alc662_eeepc_capture_source, 16415 .unsol_event = alc663_mode4_unsol_event, 16416 .init_hook = alc663_mode4_inithook, 16417 }, 16418 [ALC663_ASUS_MODE5] = { 16419 .mixers = { alc663_asus_15jd_clfe_mixer }, 16420 .cap_mixer = alc662_auto_capture_mixer, 16421 .init_verbs = { alc662_init_verbs, 16422 alc663_15jd_amic_init_verbs }, 16423 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16424 .hp_nid = 0x03, 16425 .dac_nids = alc662_dac_nids, 16426 .dig_out_nid = ALC662_DIGOUT_NID, 16427 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16428 .channel_mode = alc662_3ST_2ch_modes, 16429 .input_mux = &alc662_eeepc_capture_source, 16430 .unsol_event = alc663_mode5_unsol_event, 16431 .init_hook = alc663_mode5_inithook, 16432 }, 16433 [ALC663_ASUS_MODE6] = { 16434 .mixers = { alc663_two_hp_m2_mixer }, 16435 .cap_mixer = alc662_auto_capture_mixer, 16436 .init_verbs = { alc662_init_verbs, 16437 alc663_two_hp_amic_m2_init_verbs }, 16438 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 16439 .hp_nid = 0x03, 16440 .dac_nids = alc662_dac_nids, 16441 .dig_out_nid = ALC662_DIGOUT_NID, 16442 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 16443 .channel_mode = alc662_3ST_2ch_modes, 16444 .input_mux = &alc662_eeepc_capture_source, 16445 .unsol_event = alc663_mode6_unsol_event, 16446 .init_hook = alc663_mode6_inithook, 16447 }, 16448}; 16449 16450 16451/* 16452 * BIOS auto configuration 16453 */ 16454 16455/* add playback controls from the parsed DAC table */ 16456static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec, 16457 const struct auto_pin_cfg *cfg) 16458{ 16459 char name[32]; 16460 static const char *chname[4] = { 16461 "Front", "Surround", NULL /*CLFE*/, "Side" 16462 }; 16463 hda_nid_t nid; 16464 int i, err; 16465 16466 for (i = 0; i < cfg->line_outs; i++) { 16467 if (!spec->multiout.dac_nids[i]) 16468 continue; 16469 nid = alc880_idx_to_dac(i); 16470 if (i == 2) { 16471 /* Center/LFE */ 16472 err = add_control(spec, ALC_CTL_WIDGET_VOL, 16473 "Center Playback Volume", 16474 HDA_COMPOSE_AMP_VAL(nid, 1, 0, 16475 HDA_OUTPUT)); 16476 if (err < 0) 16477 return err; 16478 err = add_control(spec, ALC_CTL_WIDGET_VOL, 16479 "LFE Playback Volume", 16480 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 16481 HDA_OUTPUT)); 16482 if (err < 0) 16483 return err; 16484 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 16485 "Center Playback Switch", 16486 HDA_COMPOSE_AMP_VAL(0x0e, 1, 0, 16487 HDA_INPUT)); 16488 if (err < 0) 16489 return err; 16490 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 16491 "LFE Playback Switch", 16492 HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, 16493 HDA_INPUT)); 16494 if (err < 0) 16495 return err; 16496 } else { 16497 sprintf(name, "%s Playback Volume", chname[i]); 16498 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 16499 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 16500 HDA_OUTPUT)); 16501 if (err < 0) 16502 return err; 16503 sprintf(name, "%s Playback Switch", chname[i]); 16504 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 16505 HDA_COMPOSE_AMP_VAL(alc880_idx_to_mixer(i), 16506 3, 0, HDA_INPUT)); 16507 if (err < 0) 16508 return err; 16509 } 16510 } 16511 return 0; 16512} 16513 16514/* add playback controls for speaker and HP outputs */ 16515static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin, 16516 const char *pfx) 16517{ 16518 hda_nid_t nid; 16519 int err; 16520 char name[32]; 16521 16522 if (!pin) 16523 return 0; 16524 16525 if (pin == 0x17) { 16526 /* ALC663 has a mono output pin on 0x17 */ 16527 sprintf(name, "%s Playback Switch", pfx); 16528 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 16529 HDA_COMPOSE_AMP_VAL(pin, 2, 0, HDA_OUTPUT)); 16530 return err; 16531 } 16532 16533 if (alc880_is_fixed_pin(pin)) { 16534 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin)); 16535 /* printk(KERN_DEBUG "DAC nid=%x\n",nid); */ 16536 /* specify the DAC as the extra output */ 16537 if (!spec->multiout.hp_nid) 16538 spec->multiout.hp_nid = nid; 16539 else 16540 spec->multiout.extra_out_nid[0] = nid; 16541 /* control HP volume/switch on the output mixer amp */ 16542 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin)); 16543 sprintf(name, "%s Playback Volume", pfx); 16544 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 16545 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 16546 if (err < 0) 16547 return err; 16548 sprintf(name, "%s Playback Switch", pfx); 16549 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 16550 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT)); 16551 if (err < 0) 16552 return err; 16553 } else if (alc880_is_multi_pin(pin)) { 16554 /* set manual connection */ 16555 /* we have only a switch on HP-out PIN */ 16556 sprintf(name, "%s Playback Switch", pfx); 16557 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 16558 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 16559 if (err < 0) 16560 return err; 16561 } 16562 return 0; 16563} 16564 16565/* create playback/capture controls for input pins */ 16566static int alc662_auto_create_analog_input_ctls(struct alc_spec *spec, 16567 const struct auto_pin_cfg *cfg) 16568{ 16569 struct hda_input_mux *imux = &spec->private_imux[0]; 16570 int i, err, idx; 16571 16572 for (i = 0; i < AUTO_PIN_LAST; i++) { 16573 if (alc880_is_input_pin(cfg->input_pins[i])) { 16574 idx = alc880_input_pin_idx(cfg->input_pins[i]); 16575 err = new_analog_input(spec, cfg->input_pins[i], 16576 auto_pin_cfg_labels[i], 16577 idx, 0x0b); 16578 if (err < 0) 16579 return err; 16580 imux->items[imux->num_items].label = 16581 auto_pin_cfg_labels[i]; 16582 imux->items[imux->num_items].index = 16583 alc880_input_pin_idx(cfg->input_pins[i]); 16584 imux->num_items++; 16585 } 16586 } 16587 return 0; 16588} 16589 16590static void alc662_auto_set_output_and_unmute(struct hda_codec *codec, 16591 hda_nid_t nid, int pin_type, 16592 int dac_idx) 16593{ 16594 alc_set_pin_output(codec, nid, pin_type); 16595 /* need the manual connection? */ 16596 if (alc880_is_multi_pin(nid)) { 16597 struct alc_spec *spec = codec->spec; 16598 int idx = alc880_multi_pin_idx(nid); 16599 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0, 16600 AC_VERB_SET_CONNECT_SEL, 16601 alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx])); 16602 } 16603} 16604 16605static void alc662_auto_init_multi_out(struct hda_codec *codec) 16606{ 16607 struct alc_spec *spec = codec->spec; 16608 int i; 16609 16610 alc_subsystem_id(codec, 0x15, 0x1b, 0x14); 16611 for (i = 0; i <= HDA_SIDE; i++) { 16612 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 16613 int pin_type = get_pin_type(spec->autocfg.line_out_type); 16614 if (nid) 16615 alc662_auto_set_output_and_unmute(codec, nid, pin_type, 16616 i); 16617 } 16618} 16619 16620static void alc662_auto_init_hp_out(struct hda_codec *codec) 16621{ 16622 struct alc_spec *spec = codec->spec; 16623 hda_nid_t pin; 16624 16625 pin = spec->autocfg.hp_pins[0]; 16626 if (pin) /* connect to front */ 16627 /* use dac 0 */ 16628 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 16629 pin = spec->autocfg.speaker_pins[0]; 16630 if (pin) 16631 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 16632} 16633 16634#define alc662_is_input_pin(nid) alc880_is_input_pin(nid) 16635#define ALC662_PIN_CD_NID ALC880_PIN_CD_NID 16636 16637static void alc662_auto_init_analog_input(struct hda_codec *codec) 16638{ 16639 struct alc_spec *spec = codec->spec; 16640 int i; 16641 16642 for (i = 0; i < AUTO_PIN_LAST; i++) { 16643 hda_nid_t nid = spec->autocfg.input_pins[i]; 16644 if (alc662_is_input_pin(nid)) { 16645 snd_hda_codec_write(codec, nid, 0, 16646 AC_VERB_SET_PIN_WIDGET_CONTROL, 16647 (i <= AUTO_PIN_FRONT_MIC ? 16648 PIN_VREF80 : PIN_IN)); 16649 if (nid != ALC662_PIN_CD_NID) 16650 snd_hda_codec_write(codec, nid, 0, 16651 AC_VERB_SET_AMP_GAIN_MUTE, 16652 AMP_OUT_MUTE); 16653 } 16654 } 16655} 16656 16657#define alc662_auto_init_input_src alc882_auto_init_input_src 16658 16659static int alc662_parse_auto_config(struct hda_codec *codec) 16660{ 16661 struct alc_spec *spec = codec->spec; 16662 int err; 16663 static hda_nid_t alc662_ignore[] = { 0x1d, 0 }; 16664 16665 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 16666 alc662_ignore); 16667 if (err < 0) 16668 return err; 16669 if (!spec->autocfg.line_outs) 16670 return 0; /* can't find valid BIOS pin config */ 16671 16672 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg); 16673 if (err < 0) 16674 return err; 16675 err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg); 16676 if (err < 0) 16677 return err; 16678 err = alc662_auto_create_extra_out(spec, 16679 spec->autocfg.speaker_pins[0], 16680 "Speaker"); 16681 if (err < 0) 16682 return err; 16683 err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0], 16684 "Headphone"); 16685 if (err < 0) 16686 return err; 16687 err = alc662_auto_create_analog_input_ctls(spec, &spec->autocfg); 16688 if (err < 0) 16689 return err; 16690 16691 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 16692 16693 if (spec->autocfg.dig_outs) 16694 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID; 16695 16696 if (spec->kctls.list) 16697 add_mixer(spec, spec->kctls.list); 16698 16699 spec->num_mux_defs = 1; 16700 spec->input_mux = &spec->private_imux[0]; 16701 16702 add_verb(spec, alc662_auto_init_verbs); 16703 if (codec->vendor_id == 0x10ec0663) 16704 add_verb(spec, alc663_auto_init_verbs); 16705 16706 err = alc_auto_add_mic_boost(codec); 16707 if (err < 0) 16708 return err; 16709 16710 store_pin_configs(codec); 16711 return 1; 16712} 16713 16714/* additional initialization for auto-configuration model */ 16715static void alc662_auto_init(struct hda_codec *codec) 16716{ 16717 struct alc_spec *spec = codec->spec; 16718 alc662_auto_init_multi_out(codec); 16719 alc662_auto_init_hp_out(codec); 16720 alc662_auto_init_analog_input(codec); 16721 alc662_auto_init_input_src(codec); 16722 if (spec->unsol_event) 16723 alc_inithook(codec); 16724} 16725 16726static int patch_alc662(struct hda_codec *codec) 16727{ 16728 struct alc_spec *spec; 16729 int err, board_config; 16730 16731 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 16732 if (!spec) 16733 return -ENOMEM; 16734 16735 codec->spec = spec; 16736 16737 alc_fix_pll_init(codec, 0x20, 0x04, 15); 16738 16739 board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST, 16740 alc662_models, 16741 alc662_cfg_tbl); 16742 if (board_config < 0) { 16743 printk(KERN_INFO "hda_codec: Unknown model for ALC662, " 16744 "trying auto-probe from BIOS...\n"); 16745 board_config = ALC662_AUTO; 16746 } 16747 16748 if (board_config == ALC662_AUTO) { 16749 /* automatic parse from the BIOS config */ 16750 err = alc662_parse_auto_config(codec); 16751 if (err < 0) { 16752 alc_free(codec); 16753 return err; 16754 } else if (!err) { 16755 printk(KERN_INFO 16756 "hda_codec: Cannot set up configuration " 16757 "from BIOS. Using base mode...\n"); 16758 board_config = ALC662_3ST_2ch_DIG; 16759 } 16760 } 16761 16762 err = snd_hda_attach_beep_device(codec, 0x1); 16763 if (err < 0) { 16764 alc_free(codec); 16765 return err; 16766 } 16767 16768 if (board_config != ALC662_AUTO) 16769 setup_preset(spec, &alc662_presets[board_config]); 16770 16771 if (codec->vendor_id == 0x10ec0663) { 16772 spec->stream_name_analog = "ALC663 Analog"; 16773 spec->stream_name_digital = "ALC663 Digital"; 16774 } else if (codec->vendor_id == 0x10ec0272) { 16775 spec->stream_name_analog = "ALC272 Analog"; 16776 spec->stream_name_digital = "ALC272 Digital"; 16777 } else { 16778 spec->stream_name_analog = "ALC662 Analog"; 16779 spec->stream_name_digital = "ALC662 Digital"; 16780 } 16781 16782 spec->stream_analog_playback = &alc662_pcm_analog_playback; 16783 spec->stream_analog_capture = &alc662_pcm_analog_capture; 16784 16785 spec->stream_digital_playback = &alc662_pcm_digital_playback; 16786 spec->stream_digital_capture = &alc662_pcm_digital_capture; 16787 16788 spec->adc_nids = alc662_adc_nids; 16789 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids); 16790 spec->capsrc_nids = alc662_capsrc_nids; 16791 spec->capture_style = CAPT_MIX; 16792 16793 if (!spec->cap_mixer) 16794 set_capture_mixer(spec); 16795 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); 16796 16797 spec->vmaster_nid = 0x02; 16798 16799 codec->patch_ops = alc_patch_ops; 16800 if (board_config == ALC662_AUTO) 16801 spec->init_hook = alc662_auto_init; 16802#ifdef CONFIG_SND_HDA_POWER_SAVE 16803 if (!spec->loopback.amplist) 16804 spec->loopback.amplist = alc662_loopbacks; 16805#endif 16806 codec->proc_widget_hook = print_realtek_coef; 16807 16808 return 0; 16809} 16810 16811/* 16812 * patch entries 16813 */ 16814static struct hda_codec_preset snd_hda_preset_realtek[] = { 16815 { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 }, 16816 { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 }, 16817 { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 }, 16818 { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 }, 16819 { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 }, 16820 { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 }, 16821 { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660", 16822 .patch = patch_alc861 }, 16823 { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd }, 16824 { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 }, 16825 { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd }, 16826 { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2", 16827 .patch = patch_alc883 }, 16828 { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1", 16829 .patch = patch_alc662 }, 16830 { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 }, 16831 { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 }, 16832 { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 }, 16833 { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 }, 16834 { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A", 16835 .patch = patch_alc882 }, /* should be patch_alc883() in future */ 16836 { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A", 16837 .patch = patch_alc882 }, /* should be patch_alc883() in future */ 16838 { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 }, 16839 { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc883 }, 16840 { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200", 16841 .patch = patch_alc883 }, 16842 { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 }, 16843 { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 }, 16844 {} /* terminator */ 16845}; 16846 16847MODULE_ALIAS("snd-hda-codec-id:10ec*"); 16848 16849MODULE_LICENSE("GPL"); 16850MODULE_DESCRIPTION("Realtek HD-audio codec"); 16851 16852static struct hda_codec_preset_list realtek_list = { 16853 .preset = snd_hda_preset_realtek, 16854 .owner = THIS_MODULE, 16855}; 16856 16857static int __init patch_realtek_init(void) 16858{ 16859 return snd_hda_add_codec_preset(&realtek_list); 16860} 16861 16862static void __exit patch_realtek_exit(void) 16863{ 16864 snd_hda_delete_codec_preset(&realtek_list); 16865} 16866 16867module_init(patch_realtek_init) 16868module_exit(patch_realtek_exit) 16869