patch_realtek.c revision 60db6b53fb43421beb2ff3fe3e63412bf81620aa
1/* 2 * Universal Interface for Intel High Definition Audio Codec 3 * 4 * HD audio interface patch for ALC 260/880/882 codecs 5 * 6 * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw> 7 * PeiSen Hou <pshou@realtek.com.tw> 8 * Takashi Iwai <tiwai@suse.de> 9 * Jonathan Woithe <jwoithe@physics.adelaide.edu.au> 10 * 11 * This driver is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License as published by 13 * the Free Software Foundation; either version 2 of the License, or 14 * (at your option) any later version. 15 * 16 * This driver is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 * GNU General Public License for more details. 20 * 21 * You should have received a copy of the GNU General Public License 22 * along with this program; if not, write to the Free Software 23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 24 */ 25 26#include <linux/init.h> 27#include <linux/delay.h> 28#include <linux/slab.h> 29#include <linux/pci.h> 30#include <sound/core.h> 31#include "hda_codec.h" 32#include "hda_local.h" 33#include "hda_patch.h" 34 35#define ALC880_FRONT_EVENT 0x01 36#define ALC880_DCVOL_EVENT 0x02 37#define ALC880_HP_EVENT 0x04 38#define ALC880_MIC_EVENT 0x08 39 40/* ALC880 board config type */ 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_AUTO, 107 ALC262_MODEL_LAST /* last tag */ 108}; 109 110/* ALC268 models */ 111enum { 112 ALC267_QUANTA_IL1, 113 ALC268_3ST, 114 ALC268_TOSHIBA, 115 ALC268_ACER, 116 ALC268_ACER_ASPIRE_ONE, 117 ALC268_DELL, 118 ALC268_ZEPTO, 119#ifdef CONFIG_SND_DEBUG 120 ALC268_TEST, 121#endif 122 ALC268_AUTO, 123 ALC268_MODEL_LAST /* last tag */ 124}; 125 126/* ALC269 models */ 127enum { 128 ALC269_BASIC, 129 ALC269_QUANTA_FL1, 130 ALC269_ASUS_EEEPC_P703, 131 ALC269_ASUS_EEEPC_P901, 132 ALC269_AUTO, 133 ALC269_MODEL_LAST /* last tag */ 134}; 135 136/* ALC861 models */ 137enum { 138 ALC861_3ST, 139 ALC660_3ST, 140 ALC861_3ST_DIG, 141 ALC861_6ST_DIG, 142 ALC861_UNIWILL_M31, 143 ALC861_TOSHIBA, 144 ALC861_ASUS, 145 ALC861_ASUS_LAPTOP, 146 ALC861_AUTO, 147 ALC861_MODEL_LAST, 148}; 149 150/* ALC861-VD models */ 151enum { 152 ALC660VD_3ST, 153 ALC660VD_3ST_DIG, 154 ALC861VD_3ST, 155 ALC861VD_3ST_DIG, 156 ALC861VD_6ST_DIG, 157 ALC861VD_LENOVO, 158 ALC861VD_DALLAS, 159 ALC861VD_HP, 160 ALC861VD_AUTO, 161 ALC861VD_MODEL_LAST, 162}; 163 164/* ALC662 models */ 165enum { 166 ALC662_3ST_2ch_DIG, 167 ALC662_3ST_6ch_DIG, 168 ALC662_3ST_6ch, 169 ALC662_5ST_DIG, 170 ALC662_LENOVO_101E, 171 ALC662_ASUS_EEEPC_P701, 172 ALC662_ASUS_EEEPC_EP20, 173 ALC663_ASUS_M51VA, 174 ALC663_ASUS_G71V, 175 ALC663_ASUS_H13, 176 ALC663_ASUS_G50V, 177 ALC662_AUTO, 178 ALC662_MODEL_LAST, 179}; 180 181/* ALC882 models */ 182enum { 183 ALC882_3ST_DIG, 184 ALC882_6ST_DIG, 185 ALC882_ARIMA, 186 ALC882_W2JC, 187 ALC882_TARGA, 188 ALC882_ASUS_A7J, 189 ALC882_ASUS_A7M, 190 ALC885_MACPRO, 191 ALC885_MBP3, 192 ALC885_IMAC24, 193 ALC882_AUTO, 194 ALC882_MODEL_LAST, 195}; 196 197/* ALC883 models */ 198enum { 199 ALC883_3ST_2ch_DIG, 200 ALC883_3ST_6ch_DIG, 201 ALC883_3ST_6ch, 202 ALC883_6ST_DIG, 203 ALC883_TARGA_DIG, 204 ALC883_TARGA_2ch_DIG, 205 ALC883_ACER, 206 ALC883_ACER_ASPIRE, 207 ALC883_MEDION, 208 ALC883_MEDION_MD2, 209 ALC883_LAPTOP_EAPD, 210 ALC883_LENOVO_101E_2ch, 211 ALC883_LENOVO_NB0763, 212 ALC888_LENOVO_MS7195_DIG, 213 ALC883_HAIER_W66, 214 ALC888_3ST_HP, 215 ALC888_6ST_DELL, 216 ALC883_MITAC, 217 ALC883_CLEVO_M720, 218 ALC883_FUJITSU_PI2515, 219 ALC883_3ST_6ch_INTEL, 220 ALC883_AUTO, 221 ALC883_MODEL_LAST, 222}; 223 224/* for GPIO Poll */ 225#define GPIO_MASK 0x03 226 227struct alc_spec { 228 /* codec parameterization */ 229 struct snd_kcontrol_new *mixers[5]; /* mixer arrays */ 230 unsigned int num_mixers; 231 232 const struct hda_verb *init_verbs[5]; /* initialization verbs 233 * don't forget NULL 234 * termination! 235 */ 236 unsigned int num_init_verbs; 237 238 char *stream_name_analog; /* analog PCM stream */ 239 struct hda_pcm_stream *stream_analog_playback; 240 struct hda_pcm_stream *stream_analog_capture; 241 struct hda_pcm_stream *stream_analog_alt_playback; 242 struct hda_pcm_stream *stream_analog_alt_capture; 243 244 char *stream_name_digital; /* digital PCM stream */ 245 struct hda_pcm_stream *stream_digital_playback; 246 struct hda_pcm_stream *stream_digital_capture; 247 248 /* playback */ 249 struct hda_multi_out multiout; /* playback set-up 250 * max_channels, dacs must be set 251 * dig_out_nid and hp_nid are optional 252 */ 253 hda_nid_t alt_dac_nid; 254 255 /* capture */ 256 unsigned int num_adc_nids; 257 hda_nid_t *adc_nids; 258 hda_nid_t *capsrc_nids; 259 hda_nid_t dig_in_nid; /* digital-in NID; optional */ 260 261 /* capture source */ 262 unsigned int num_mux_defs; 263 const struct hda_input_mux *input_mux; 264 unsigned int cur_mux[3]; 265 266 /* channel model */ 267 const struct hda_channel_mode *channel_mode; 268 int num_channel_mode; 269 int need_dac_fix; 270 271 /* PCM information */ 272 struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */ 273 274 /* dynamic controls, init_verbs and input_mux */ 275 struct auto_pin_cfg autocfg; 276 unsigned int num_kctl_alloc, num_kctl_used; 277 struct snd_kcontrol_new *kctl_alloc; 278 struct hda_input_mux private_imux; 279 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS]; 280 281 /* hooks */ 282 void (*init_hook)(struct hda_codec *codec); 283 void (*unsol_event)(struct hda_codec *codec, unsigned int res); 284 285 /* for pin sensing */ 286 unsigned int sense_updated: 1; 287 unsigned int jack_present: 1; 288 unsigned int master_sw: 1; 289 290 /* for virtual master */ 291 hda_nid_t vmaster_nid; 292#ifdef CONFIG_SND_HDA_POWER_SAVE 293 struct hda_loopback_check loopback; 294#endif 295 296 /* for PLL fix */ 297 hda_nid_t pll_nid; 298 unsigned int pll_coef_idx, pll_coef_bit; 299}; 300 301/* 302 * configuration template - to be copied to the spec instance 303 */ 304struct alc_config_preset { 305 struct snd_kcontrol_new *mixers[5]; /* should be identical size 306 * with spec 307 */ 308 const struct hda_verb *init_verbs[5]; 309 unsigned int num_dacs; 310 hda_nid_t *dac_nids; 311 hda_nid_t dig_out_nid; /* optional */ 312 hda_nid_t hp_nid; /* optional */ 313 unsigned int num_adc_nids; 314 hda_nid_t *adc_nids; 315 hda_nid_t *capsrc_nids; 316 hda_nid_t dig_in_nid; 317 unsigned int num_channel_mode; 318 const struct hda_channel_mode *channel_mode; 319 int need_dac_fix; 320 unsigned int num_mux_defs; 321 const struct hda_input_mux *input_mux; 322 void (*unsol_event)(struct hda_codec *, unsigned int); 323 void (*init_hook)(struct hda_codec *); 324#ifdef CONFIG_SND_HDA_POWER_SAVE 325 struct hda_amp_list *loopbacks; 326#endif 327}; 328 329 330/* 331 * input MUX handling 332 */ 333static int alc_mux_enum_info(struct snd_kcontrol *kcontrol, 334 struct snd_ctl_elem_info *uinfo) 335{ 336 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 337 struct alc_spec *spec = codec->spec; 338 unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id); 339 if (mux_idx >= spec->num_mux_defs) 340 mux_idx = 0; 341 return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo); 342} 343 344static int alc_mux_enum_get(struct snd_kcontrol *kcontrol, 345 struct snd_ctl_elem_value *ucontrol) 346{ 347 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 348 struct alc_spec *spec = codec->spec; 349 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 350 351 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx]; 352 return 0; 353} 354 355static int alc_mux_enum_put(struct snd_kcontrol *kcontrol, 356 struct snd_ctl_elem_value *ucontrol) 357{ 358 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 359 struct alc_spec *spec = codec->spec; 360 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 361 unsigned int mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx; 362 hda_nid_t nid = spec->capsrc_nids ? 363 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx]; 364 return snd_hda_input_mux_put(codec, &spec->input_mux[mux_idx], ucontrol, 365 nid, &spec->cur_mux[adc_idx]); 366} 367 368 369/* 370 * channel mode setting 371 */ 372static int alc_ch_mode_info(struct snd_kcontrol *kcontrol, 373 struct snd_ctl_elem_info *uinfo) 374{ 375 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 376 struct alc_spec *spec = codec->spec; 377 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode, 378 spec->num_channel_mode); 379} 380 381static int alc_ch_mode_get(struct snd_kcontrol *kcontrol, 382 struct snd_ctl_elem_value *ucontrol) 383{ 384 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 385 struct alc_spec *spec = codec->spec; 386 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode, 387 spec->num_channel_mode, 388 spec->multiout.max_channels); 389} 390 391static int alc_ch_mode_put(struct snd_kcontrol *kcontrol, 392 struct snd_ctl_elem_value *ucontrol) 393{ 394 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 395 struct alc_spec *spec = codec->spec; 396 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode, 397 spec->num_channel_mode, 398 &spec->multiout.max_channels); 399 if (err >= 0 && spec->need_dac_fix) 400 spec->multiout.num_dacs = spec->multiout.max_channels / 2; 401 return err; 402} 403 404/* 405 * Control the mode of pin widget settings via the mixer. "pc" is used 406 * instead of "%" to avoid consequences of accidently treating the % as 407 * being part of a format specifier. Maximum allowed length of a value is 408 * 63 characters plus NULL terminator. 409 * 410 * Note: some retasking pin complexes seem to ignore requests for input 411 * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these 412 * are requested. Therefore order this list so that this behaviour will not 413 * cause problems when mixer clients move through the enum sequentially. 414 * NIDs 0x0f and 0x10 have been observed to have this behaviour as of 415 * March 2006. 416 */ 417static char *alc_pin_mode_names[] = { 418 "Mic 50pc bias", "Mic 80pc bias", 419 "Line in", "Line out", "Headphone out", 420}; 421static unsigned char alc_pin_mode_values[] = { 422 PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP, 423}; 424/* The control can present all 5 options, or it can limit the options based 425 * in the pin being assumed to be exclusively an input or an output pin. In 426 * addition, "input" pins may or may not process the mic bias option 427 * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to 428 * accept requests for bias as of chip versions up to March 2006) and/or 429 * wiring in the computer. 430 */ 431#define ALC_PIN_DIR_IN 0x00 432#define ALC_PIN_DIR_OUT 0x01 433#define ALC_PIN_DIR_INOUT 0x02 434#define ALC_PIN_DIR_IN_NOMICBIAS 0x03 435#define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04 436 437/* Info about the pin modes supported by the different pin direction modes. 438 * For each direction the minimum and maximum values are given. 439 */ 440static signed char alc_pin_mode_dir_info[5][2] = { 441 { 0, 2 }, /* ALC_PIN_DIR_IN */ 442 { 3, 4 }, /* ALC_PIN_DIR_OUT */ 443 { 0, 4 }, /* ALC_PIN_DIR_INOUT */ 444 { 2, 2 }, /* ALC_PIN_DIR_IN_NOMICBIAS */ 445 { 2, 4 }, /* ALC_PIN_DIR_INOUT_NOMICBIAS */ 446}; 447#define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0]) 448#define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1]) 449#define alc_pin_mode_n_items(_dir) \ 450 (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1) 451 452static int alc_pin_mode_info(struct snd_kcontrol *kcontrol, 453 struct snd_ctl_elem_info *uinfo) 454{ 455 unsigned int item_num = uinfo->value.enumerated.item; 456 unsigned char dir = (kcontrol->private_value >> 16) & 0xff; 457 458 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 459 uinfo->count = 1; 460 uinfo->value.enumerated.items = alc_pin_mode_n_items(dir); 461 462 if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir)) 463 item_num = alc_pin_mode_min(dir); 464 strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]); 465 return 0; 466} 467 468static int alc_pin_mode_get(struct snd_kcontrol *kcontrol, 469 struct snd_ctl_elem_value *ucontrol) 470{ 471 unsigned int i; 472 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 473 hda_nid_t nid = kcontrol->private_value & 0xffff; 474 unsigned char dir = (kcontrol->private_value >> 16) & 0xff; 475 long *valp = ucontrol->value.integer.value; 476 unsigned int pinctl = snd_hda_codec_read(codec, nid, 0, 477 AC_VERB_GET_PIN_WIDGET_CONTROL, 478 0x00); 479 480 /* Find enumerated value for current pinctl setting */ 481 i = alc_pin_mode_min(dir); 482 while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir)) 483 i++; 484 *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir); 485 return 0; 486} 487 488static int alc_pin_mode_put(struct snd_kcontrol *kcontrol, 489 struct snd_ctl_elem_value *ucontrol) 490{ 491 signed int change; 492 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 493 hda_nid_t nid = kcontrol->private_value & 0xffff; 494 unsigned char dir = (kcontrol->private_value >> 16) & 0xff; 495 long val = *ucontrol->value.integer.value; 496 unsigned int pinctl = snd_hda_codec_read(codec, nid, 0, 497 AC_VERB_GET_PIN_WIDGET_CONTROL, 498 0x00); 499 500 if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir)) 501 val = alc_pin_mode_min(dir); 502 503 change = pinctl != alc_pin_mode_values[val]; 504 if (change) { 505 /* Set pin mode to that requested */ 506 snd_hda_codec_write_cache(codec, nid, 0, 507 AC_VERB_SET_PIN_WIDGET_CONTROL, 508 alc_pin_mode_values[val]); 509 510 /* Also enable the retasking pin's input/output as required 511 * for the requested pin mode. Enum values of 2 or less are 512 * input modes. 513 * 514 * Dynamically switching the input/output buffers probably 515 * reduces noise slightly (particularly on input) so we'll 516 * do it. However, having both input and output buffers 517 * enabled simultaneously doesn't seem to be problematic if 518 * this turns out to be necessary in the future. 519 */ 520 if (val <= 2) { 521 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 522 HDA_AMP_MUTE, HDA_AMP_MUTE); 523 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0, 524 HDA_AMP_MUTE, 0); 525 } else { 526 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0, 527 HDA_AMP_MUTE, HDA_AMP_MUTE); 528 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 529 HDA_AMP_MUTE, 0); 530 } 531 } 532 return change; 533} 534 535#define ALC_PIN_MODE(xname, nid, dir) \ 536 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 537 .info = alc_pin_mode_info, \ 538 .get = alc_pin_mode_get, \ 539 .put = alc_pin_mode_put, \ 540 .private_value = nid | (dir<<16) } 541 542/* A switch control for ALC260 GPIO pins. Multiple GPIOs can be ganged 543 * together using a mask with more than one bit set. This control is 544 * currently used only by the ALC260 test model. At this stage they are not 545 * needed for any "production" models. 546 */ 547#ifdef CONFIG_SND_DEBUG 548#define alc_gpio_data_info snd_ctl_boolean_mono_info 549 550static int alc_gpio_data_get(struct snd_kcontrol *kcontrol, 551 struct snd_ctl_elem_value *ucontrol) 552{ 553 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 554 hda_nid_t nid = kcontrol->private_value & 0xffff; 555 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 556 long *valp = ucontrol->value.integer.value; 557 unsigned int val = snd_hda_codec_read(codec, nid, 0, 558 AC_VERB_GET_GPIO_DATA, 0x00); 559 560 *valp = (val & mask) != 0; 561 return 0; 562} 563static int alc_gpio_data_put(struct snd_kcontrol *kcontrol, 564 struct snd_ctl_elem_value *ucontrol) 565{ 566 signed int change; 567 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 568 hda_nid_t nid = kcontrol->private_value & 0xffff; 569 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 570 long val = *ucontrol->value.integer.value; 571 unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0, 572 AC_VERB_GET_GPIO_DATA, 573 0x00); 574 575 /* Set/unset the masked GPIO bit(s) as needed */ 576 change = (val == 0 ? 0 : mask) != (gpio_data & mask); 577 if (val == 0) 578 gpio_data &= ~mask; 579 else 580 gpio_data |= mask; 581 snd_hda_codec_write_cache(codec, nid, 0, 582 AC_VERB_SET_GPIO_DATA, gpio_data); 583 584 return change; 585} 586#define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \ 587 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 588 .info = alc_gpio_data_info, \ 589 .get = alc_gpio_data_get, \ 590 .put = alc_gpio_data_put, \ 591 .private_value = nid | (mask<<16) } 592#endif /* CONFIG_SND_DEBUG */ 593 594/* A switch control to allow the enabling of the digital IO pins on the 595 * ALC260. This is incredibly simplistic; the intention of this control is 596 * to provide something in the test model allowing digital outputs to be 597 * identified if present. If models are found which can utilise these 598 * outputs a more complete mixer control can be devised for those models if 599 * necessary. 600 */ 601#ifdef CONFIG_SND_DEBUG 602#define alc_spdif_ctrl_info snd_ctl_boolean_mono_info 603 604static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol, 605 struct snd_ctl_elem_value *ucontrol) 606{ 607 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 608 hda_nid_t nid = kcontrol->private_value & 0xffff; 609 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 610 long *valp = ucontrol->value.integer.value; 611 unsigned int val = snd_hda_codec_read(codec, nid, 0, 612 AC_VERB_GET_DIGI_CONVERT_1, 0x00); 613 614 *valp = (val & mask) != 0; 615 return 0; 616} 617static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol, 618 struct snd_ctl_elem_value *ucontrol) 619{ 620 signed int change; 621 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 622 hda_nid_t nid = kcontrol->private_value & 0xffff; 623 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 624 long val = *ucontrol->value.integer.value; 625 unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0, 626 AC_VERB_GET_DIGI_CONVERT_1, 627 0x00); 628 629 /* Set/unset the masked control bit(s) as needed */ 630 change = (val == 0 ? 0 : mask) != (ctrl_data & mask); 631 if (val==0) 632 ctrl_data &= ~mask; 633 else 634 ctrl_data |= mask; 635 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1, 636 ctrl_data); 637 638 return change; 639} 640#define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \ 641 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 642 .info = alc_spdif_ctrl_info, \ 643 .get = alc_spdif_ctrl_get, \ 644 .put = alc_spdif_ctrl_put, \ 645 .private_value = nid | (mask<<16) } 646#endif /* CONFIG_SND_DEBUG */ 647 648/* A switch control to allow the enabling EAPD digital outputs on the ALC26x. 649 * Again, this is only used in the ALC26x test models to help identify when 650 * the EAPD line must be asserted for features to work. 651 */ 652#ifdef CONFIG_SND_DEBUG 653#define alc_eapd_ctrl_info snd_ctl_boolean_mono_info 654 655static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol, 656 struct snd_ctl_elem_value *ucontrol) 657{ 658 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 659 hda_nid_t nid = kcontrol->private_value & 0xffff; 660 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 661 long *valp = ucontrol->value.integer.value; 662 unsigned int val = snd_hda_codec_read(codec, nid, 0, 663 AC_VERB_GET_EAPD_BTLENABLE, 0x00); 664 665 *valp = (val & mask) != 0; 666 return 0; 667} 668 669static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol, 670 struct snd_ctl_elem_value *ucontrol) 671{ 672 int change; 673 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 674 hda_nid_t nid = kcontrol->private_value & 0xffff; 675 unsigned char mask = (kcontrol->private_value >> 16) & 0xff; 676 long val = *ucontrol->value.integer.value; 677 unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0, 678 AC_VERB_GET_EAPD_BTLENABLE, 679 0x00); 680 681 /* Set/unset the masked control bit(s) as needed */ 682 change = (!val ? 0 : mask) != (ctrl_data & mask); 683 if (!val) 684 ctrl_data &= ~mask; 685 else 686 ctrl_data |= mask; 687 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE, 688 ctrl_data); 689 690 return change; 691} 692 693#define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \ 694 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 695 .info = alc_eapd_ctrl_info, \ 696 .get = alc_eapd_ctrl_get, \ 697 .put = alc_eapd_ctrl_put, \ 698 .private_value = nid | (mask<<16) } 699#endif /* CONFIG_SND_DEBUG */ 700 701/* 702 * set up from the preset table 703 */ 704static void setup_preset(struct alc_spec *spec, 705 const struct alc_config_preset *preset) 706{ 707 int i; 708 709 for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++) 710 spec->mixers[spec->num_mixers++] = preset->mixers[i]; 711 for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i]; 712 i++) 713 spec->init_verbs[spec->num_init_verbs++] = 714 preset->init_verbs[i]; 715 716 spec->channel_mode = preset->channel_mode; 717 spec->num_channel_mode = preset->num_channel_mode; 718 spec->need_dac_fix = preset->need_dac_fix; 719 720 spec->multiout.max_channels = spec->channel_mode[0].channels; 721 722 spec->multiout.num_dacs = preset->num_dacs; 723 spec->multiout.dac_nids = preset->dac_nids; 724 spec->multiout.dig_out_nid = preset->dig_out_nid; 725 spec->multiout.hp_nid = preset->hp_nid; 726 727 spec->num_mux_defs = preset->num_mux_defs; 728 if (!spec->num_mux_defs) 729 spec->num_mux_defs = 1; 730 spec->input_mux = preset->input_mux; 731 732 spec->num_adc_nids = preset->num_adc_nids; 733 spec->adc_nids = preset->adc_nids; 734 spec->capsrc_nids = preset->capsrc_nids; 735 spec->dig_in_nid = preset->dig_in_nid; 736 737 spec->unsol_event = preset->unsol_event; 738 spec->init_hook = preset->init_hook; 739#ifdef CONFIG_SND_HDA_POWER_SAVE 740 spec->loopback.amplist = preset->loopbacks; 741#endif 742} 743 744/* Enable GPIO mask and set output */ 745static struct hda_verb alc_gpio1_init_verbs[] = { 746 {0x01, AC_VERB_SET_GPIO_MASK, 0x01}, 747 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, 748 {0x01, AC_VERB_SET_GPIO_DATA, 0x01}, 749 { } 750}; 751 752static struct hda_verb alc_gpio2_init_verbs[] = { 753 {0x01, AC_VERB_SET_GPIO_MASK, 0x02}, 754 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02}, 755 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, 756 { } 757}; 758 759static struct hda_verb alc_gpio3_init_verbs[] = { 760 {0x01, AC_VERB_SET_GPIO_MASK, 0x03}, 761 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03}, 762 {0x01, AC_VERB_SET_GPIO_DATA, 0x03}, 763 { } 764}; 765 766/* 767 * Fix hardware PLL issue 768 * On some codecs, the analog PLL gating control must be off while 769 * the default value is 1. 770 */ 771static void alc_fix_pll(struct hda_codec *codec) 772{ 773 struct alc_spec *spec = codec->spec; 774 unsigned int val; 775 776 if (!spec->pll_nid) 777 return; 778 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX, 779 spec->pll_coef_idx); 780 val = snd_hda_codec_read(codec, spec->pll_nid, 0, 781 AC_VERB_GET_PROC_COEF, 0); 782 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX, 783 spec->pll_coef_idx); 784 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF, 785 val & ~(1 << spec->pll_coef_bit)); 786} 787 788static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid, 789 unsigned int coef_idx, unsigned int coef_bit) 790{ 791 struct alc_spec *spec = codec->spec; 792 spec->pll_nid = nid; 793 spec->pll_coef_idx = coef_idx; 794 spec->pll_coef_bit = coef_bit; 795 alc_fix_pll(codec); 796} 797 798static void alc_sku_automute(struct hda_codec *codec) 799{ 800 struct alc_spec *spec = codec->spec; 801 unsigned int present; 802 unsigned int hp_nid = spec->autocfg.hp_pins[0]; 803 unsigned int sp_nid = spec->autocfg.speaker_pins[0]; 804 805 /* need to execute and sync at first */ 806 snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0); 807 present = snd_hda_codec_read(codec, hp_nid, 0, 808 AC_VERB_GET_PIN_SENSE, 0); 809 spec->jack_present = (present & 0x80000000) != 0; 810 snd_hda_codec_write(codec, sp_nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 811 spec->jack_present ? 0 : PIN_OUT); 812} 813 814/* unsolicited event for HP jack sensing */ 815static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res) 816{ 817 if (codec->vendor_id == 0x10ec0880) 818 res >>= 28; 819 else 820 res >>= 26; 821 if (res != ALC880_HP_EVENT) 822 return; 823 824 alc_sku_automute(codec); 825} 826 827/* additional initialization for ALC888 variants */ 828static void alc888_coef_init(struct hda_codec *codec) 829{ 830 unsigned int tmp; 831 832 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0); 833 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0); 834 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7); 835 if ((tmp & 0xf0) == 2) 836 /* alc888S-VC */ 837 snd_hda_codec_read(codec, 0x20, 0, 838 AC_VERB_SET_PROC_COEF, 0x830); 839 else 840 /* alc888-VB */ 841 snd_hda_codec_read(codec, 0x20, 0, 842 AC_VERB_SET_PROC_COEF, 0x3030); 843} 844 845/* 32-bit subsystem ID for BIOS loading in HD Audio codec. 846 * 31 ~ 16 : Manufacture ID 847 * 15 ~ 8 : SKU ID 848 * 7 ~ 0 : Assembly ID 849 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36 850 */ 851static void alc_subsystem_id(struct hda_codec *codec, 852 unsigned int porta, unsigned int porte, 853 unsigned int portd) 854{ 855 unsigned int ass, tmp, i; 856 unsigned nid; 857 struct alc_spec *spec = codec->spec; 858 859 ass = codec->subsystem_id & 0xffff; 860 if ((ass != codec->bus->pci->subsystem_device) && (ass & 1)) 861 goto do_sku; 862 863 /* 864 * 31~30 : port conetcivity 865 * 29~21 : reserve 866 * 20 : PCBEEP input 867 * 19~16 : Check sum (15:1) 868 * 15~1 : Custom 869 * 0 : override 870 */ 871 nid = 0x1d; 872 if (codec->vendor_id == 0x10ec0260) 873 nid = 0x17; 874 ass = snd_hda_codec_read(codec, nid, 0, 875 AC_VERB_GET_CONFIG_DEFAULT, 0); 876 if (!(ass & 1) && !(ass & 0x100000)) 877 return; 878 if ((ass >> 30) != 1) /* no physical connection */ 879 return; 880 881 /* check sum */ 882 tmp = 0; 883 for (i = 1; i < 16; i++) { 884 if ((ass >> i) & 1) 885 tmp++; 886 } 887 if (((ass >> 16) & 0xf) != tmp) 888 return; 889do_sku: 890 /* 891 * 0 : override 892 * 1 : Swap Jack 893 * 2 : 0 --> Desktop, 1 --> Laptop 894 * 3~5 : External Amplifier control 895 * 7~6 : Reserved 896 */ 897 tmp = (ass & 0x38) >> 3; /* external Amp control */ 898 switch (tmp) { 899 case 1: 900 snd_hda_sequence_write(codec, alc_gpio1_init_verbs); 901 break; 902 case 3: 903 snd_hda_sequence_write(codec, alc_gpio2_init_verbs); 904 break; 905 case 7: 906 snd_hda_sequence_write(codec, alc_gpio3_init_verbs); 907 break; 908 case 5: /* set EAPD output high */ 909 switch (codec->vendor_id) { 910 case 0x10ec0260: 911 snd_hda_codec_write(codec, 0x0f, 0, 912 AC_VERB_SET_EAPD_BTLENABLE, 2); 913 snd_hda_codec_write(codec, 0x10, 0, 914 AC_VERB_SET_EAPD_BTLENABLE, 2); 915 break; 916 case 0x10ec0262: 917 case 0x10ec0267: 918 case 0x10ec0268: 919 case 0x10ec0269: 920 case 0x10ec0660: 921 case 0x10ec0662: 922 case 0x10ec0663: 923 case 0x10ec0862: 924 case 0x10ec0889: 925 snd_hda_codec_write(codec, 0x14, 0, 926 AC_VERB_SET_EAPD_BTLENABLE, 2); 927 snd_hda_codec_write(codec, 0x15, 0, 928 AC_VERB_SET_EAPD_BTLENABLE, 2); 929 break; 930 } 931 switch (codec->vendor_id) { 932 case 0x10ec0260: 933 snd_hda_codec_write(codec, 0x1a, 0, 934 AC_VERB_SET_COEF_INDEX, 7); 935 tmp = snd_hda_codec_read(codec, 0x1a, 0, 936 AC_VERB_GET_PROC_COEF, 0); 937 snd_hda_codec_write(codec, 0x1a, 0, 938 AC_VERB_SET_COEF_INDEX, 7); 939 snd_hda_codec_write(codec, 0x1a, 0, 940 AC_VERB_SET_PROC_COEF, 941 tmp | 0x2010); 942 break; 943 case 0x10ec0262: 944 case 0x10ec0880: 945 case 0x10ec0882: 946 case 0x10ec0883: 947 case 0x10ec0885: 948 case 0x10ec0889: 949 snd_hda_codec_write(codec, 0x20, 0, 950 AC_VERB_SET_COEF_INDEX, 7); 951 tmp = snd_hda_codec_read(codec, 0x20, 0, 952 AC_VERB_GET_PROC_COEF, 0); 953 snd_hda_codec_write(codec, 0x20, 0, 954 AC_VERB_SET_COEF_INDEX, 7); 955 snd_hda_codec_write(codec, 0x20, 0, 956 AC_VERB_SET_PROC_COEF, 957 tmp | 0x2010); 958 break; 959 case 0x10ec0888: 960 /*alc888_coef_init(codec);*/ /* called in alc_init() */ 961 break; 962 case 0x10ec0267: 963 case 0x10ec0268: 964 snd_hda_codec_write(codec, 0x20, 0, 965 AC_VERB_SET_COEF_INDEX, 7); 966 tmp = snd_hda_codec_read(codec, 0x20, 0, 967 AC_VERB_GET_PROC_COEF, 0); 968 snd_hda_codec_write(codec, 0x20, 0, 969 AC_VERB_SET_COEF_INDEX, 7); 970 snd_hda_codec_write(codec, 0x20, 0, 971 AC_VERB_SET_PROC_COEF, 972 tmp | 0x3000); 973 break; 974 } 975 default: 976 break; 977 } 978 979 /* is laptop or Desktop and enable the function "Mute internal speaker 980 * when the external headphone out jack is plugged" 981 */ 982 if (!(ass & 0x8000)) 983 return; 984 /* 985 * 10~8 : Jack location 986 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered 987 * 14~13: Resvered 988 * 15 : 1 --> enable the function "Mute internal speaker 989 * when the external headphone out jack is plugged" 990 */ 991 if (!spec->autocfg.speaker_pins[0]) { 992 if (spec->autocfg.line_out_pins[0]) 993 spec->autocfg.speaker_pins[0] = 994 spec->autocfg.line_out_pins[0]; 995 else 996 return; 997 } 998 999 if (!spec->autocfg.hp_pins[0]) { 1000 tmp = (ass >> 11) & 0x3; /* HP to chassis */ 1001 if (tmp == 0) 1002 spec->autocfg.hp_pins[0] = porta; 1003 else if (tmp == 1) 1004 spec->autocfg.hp_pins[0] = porte; 1005 else if (tmp == 2) 1006 spec->autocfg.hp_pins[0] = portd; 1007 else 1008 return; 1009 } 1010 1011 snd_hda_codec_write(codec, spec->autocfg.hp_pins[0], 0, 1012 AC_VERB_SET_UNSOLICITED_ENABLE, 1013 AC_USRSP_EN | ALC880_HP_EVENT); 1014 1015 spec->unsol_event = alc_sku_unsol_event; 1016} 1017 1018/* 1019 * Fix-up pin default configurations 1020 */ 1021 1022struct alc_pincfg { 1023 hda_nid_t nid; 1024 u32 val; 1025}; 1026 1027static void alc_fix_pincfg(struct hda_codec *codec, 1028 const struct snd_pci_quirk *quirk, 1029 const struct alc_pincfg **pinfix) 1030{ 1031 const struct alc_pincfg *cfg; 1032 1033 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk); 1034 if (!quirk) 1035 return; 1036 1037 cfg = pinfix[quirk->value]; 1038 for (; cfg->nid; cfg++) { 1039 int i; 1040 u32 val = cfg->val; 1041 for (i = 0; i < 4; i++) { 1042 snd_hda_codec_write(codec, cfg->nid, 0, 1043 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i, 1044 val & 0xff); 1045 val >>= 8; 1046 } 1047 } 1048} 1049 1050/* 1051 * ALC880 3-stack model 1052 * 1053 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e) 1054 * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18, 1055 * F-Mic = 0x1b, HP = 0x19 1056 */ 1057 1058static hda_nid_t alc880_dac_nids[4] = { 1059 /* front, rear, clfe, rear_surr */ 1060 0x02, 0x05, 0x04, 0x03 1061}; 1062 1063static hda_nid_t alc880_adc_nids[3] = { 1064 /* ADC0-2 */ 1065 0x07, 0x08, 0x09, 1066}; 1067 1068/* The datasheet says the node 0x07 is connected from inputs, 1069 * but it shows zero connection in the real implementation on some devices. 1070 * Note: this is a 915GAV bug, fixed on 915GLV 1071 */ 1072static hda_nid_t alc880_adc_nids_alt[2] = { 1073 /* ADC1-2 */ 1074 0x08, 0x09, 1075}; 1076 1077#define ALC880_DIGOUT_NID 0x06 1078#define ALC880_DIGIN_NID 0x0a 1079 1080static struct hda_input_mux alc880_capture_source = { 1081 .num_items = 4, 1082 .items = { 1083 { "Mic", 0x0 }, 1084 { "Front Mic", 0x3 }, 1085 { "Line", 0x2 }, 1086 { "CD", 0x4 }, 1087 }, 1088}; 1089 1090/* channel source setting (2/6 channel selection for 3-stack) */ 1091/* 2ch mode */ 1092static struct hda_verb alc880_threestack_ch2_init[] = { 1093 /* set line-in to input, mute it */ 1094 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 1095 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 1096 /* set mic-in to input vref 80%, mute it */ 1097 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 1098 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 1099 { } /* end */ 1100}; 1101 1102/* 6ch mode */ 1103static struct hda_verb alc880_threestack_ch6_init[] = { 1104 /* set line-in to output, unmute it */ 1105 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1106 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1107 /* set mic-in to output, unmute it */ 1108 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1109 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1110 { } /* end */ 1111}; 1112 1113static struct hda_channel_mode alc880_threestack_modes[2] = { 1114 { 2, alc880_threestack_ch2_init }, 1115 { 6, alc880_threestack_ch6_init }, 1116}; 1117 1118static struct snd_kcontrol_new alc880_three_stack_mixer[] = { 1119 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1120 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 1121 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 1122 HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT), 1123 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 1124 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 1125 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 1126 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 1127 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1128 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1129 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 1130 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 1131 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1132 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1133 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT), 1134 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT), 1135 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 1136 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 1137 HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT), 1138 { 1139 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1140 .name = "Channel Mode", 1141 .info = alc_ch_mode_info, 1142 .get = alc_ch_mode_get, 1143 .put = alc_ch_mode_put, 1144 }, 1145 { } /* end */ 1146}; 1147 1148/* capture mixer elements */ 1149static struct snd_kcontrol_new alc880_capture_mixer[] = { 1150 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT), 1151 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT), 1152 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT), 1153 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT), 1154 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT), 1155 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT), 1156 { 1157 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1158 /* The multiple "Capture Source" controls confuse alsamixer 1159 * So call somewhat different.. 1160 */ 1161 /* .name = "Capture Source", */ 1162 .name = "Input Source", 1163 .count = 3, 1164 .info = alc_mux_enum_info, 1165 .get = alc_mux_enum_get, 1166 .put = alc_mux_enum_put, 1167 }, 1168 { } /* end */ 1169}; 1170 1171/* capture mixer elements (in case NID 0x07 not available) */ 1172static struct snd_kcontrol_new alc880_capture_alt_mixer[] = { 1173 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 1174 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 1175 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 1176 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 1177 { 1178 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1179 /* The multiple "Capture Source" controls confuse alsamixer 1180 * So call somewhat different.. 1181 */ 1182 /* .name = "Capture Source", */ 1183 .name = "Input Source", 1184 .count = 2, 1185 .info = alc_mux_enum_info, 1186 .get = alc_mux_enum_get, 1187 .put = alc_mux_enum_put, 1188 }, 1189 { } /* end */ 1190}; 1191 1192 1193 1194/* 1195 * ALC880 5-stack model 1196 * 1197 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d), 1198 * Side = 0x02 (0xd) 1199 * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16 1200 * Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19 1201 */ 1202 1203/* additional mixers to alc880_three_stack_mixer */ 1204static struct snd_kcontrol_new alc880_five_stack_mixer[] = { 1205 HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1206 HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT), 1207 { } /* end */ 1208}; 1209 1210/* channel source setting (6/8 channel selection for 5-stack) */ 1211/* 6ch mode */ 1212static struct hda_verb alc880_fivestack_ch6_init[] = { 1213 /* set line-in to input, mute it */ 1214 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 1215 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 1216 { } /* end */ 1217}; 1218 1219/* 8ch mode */ 1220static struct hda_verb alc880_fivestack_ch8_init[] = { 1221 /* set line-in to output, unmute it */ 1222 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 1223 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 1224 { } /* end */ 1225}; 1226 1227static struct hda_channel_mode alc880_fivestack_modes[2] = { 1228 { 6, alc880_fivestack_ch6_init }, 1229 { 8, alc880_fivestack_ch8_init }, 1230}; 1231 1232 1233/* 1234 * ALC880 6-stack model 1235 * 1236 * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e), 1237 * Side = 0x05 (0x0f) 1238 * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17, 1239 * Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b 1240 */ 1241 1242static hda_nid_t alc880_6st_dac_nids[4] = { 1243 /* front, rear, clfe, rear_surr */ 1244 0x02, 0x03, 0x04, 0x05 1245}; 1246 1247static struct hda_input_mux alc880_6stack_capture_source = { 1248 .num_items = 4, 1249 .items = { 1250 { "Mic", 0x0 }, 1251 { "Front Mic", 0x1 }, 1252 { "Line", 0x2 }, 1253 { "CD", 0x4 }, 1254 }, 1255}; 1256 1257/* fixed 8-channels */ 1258static struct hda_channel_mode alc880_sixstack_modes[1] = { 1259 { 8, NULL }, 1260}; 1261 1262static struct snd_kcontrol_new alc880_six_stack_mixer[] = { 1263 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1264 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 1265 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1266 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 1267 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 1268 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 1269 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 1270 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 1271 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 1272 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 1273 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1274 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1275 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 1276 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 1277 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1278 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1279 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 1280 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 1281 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 1282 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 1283 { 1284 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1285 .name = "Channel Mode", 1286 .info = alc_ch_mode_info, 1287 .get = alc_ch_mode_get, 1288 .put = alc_ch_mode_put, 1289 }, 1290 { } /* end */ 1291}; 1292 1293 1294/* 1295 * ALC880 W810 model 1296 * 1297 * W810 has rear IO for: 1298 * Front (DAC 02) 1299 * Surround (DAC 03) 1300 * Center/LFE (DAC 04) 1301 * Digital out (06) 1302 * 1303 * The system also has a pair of internal speakers, and a headphone jack. 1304 * These are both connected to Line2 on the codec, hence to DAC 02. 1305 * 1306 * There is a variable resistor to control the speaker or headphone 1307 * volume. This is a hardware-only device without a software API. 1308 * 1309 * Plugging headphones in will disable the internal speakers. This is 1310 * implemented in hardware, not via the driver using jack sense. In 1311 * a similar fashion, plugging into the rear socket marked "front" will 1312 * disable both the speakers and headphones. 1313 * 1314 * For input, there's a microphone jack, and an "audio in" jack. 1315 * These may not do anything useful with this driver yet, because I 1316 * haven't setup any initialization verbs for these yet... 1317 */ 1318 1319static hda_nid_t alc880_w810_dac_nids[3] = { 1320 /* front, rear/surround, clfe */ 1321 0x02, 0x03, 0x04 1322}; 1323 1324/* fixed 6 channels */ 1325static struct hda_channel_mode alc880_w810_modes[1] = { 1326 { 6, NULL } 1327}; 1328 1329/* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */ 1330static struct snd_kcontrol_new alc880_w810_base_mixer[] = { 1331 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1332 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 1333 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1334 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 1335 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 1336 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 1337 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 1338 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 1339 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 1340 { } /* end */ 1341}; 1342 1343 1344/* 1345 * Z710V model 1346 * 1347 * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d) 1348 * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?), 1349 * Line = 0x1a 1350 */ 1351 1352static hda_nid_t alc880_z71v_dac_nids[1] = { 1353 0x02 1354}; 1355#define ALC880_Z71V_HP_DAC 0x03 1356 1357/* fixed 2 channels */ 1358static struct hda_channel_mode alc880_2_jack_modes[1] = { 1359 { 2, NULL } 1360}; 1361 1362static struct snd_kcontrol_new alc880_z71v_mixer[] = { 1363 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1364 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 1365 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1366 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT), 1367 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1368 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1369 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1370 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1371 { } /* end */ 1372}; 1373 1374 1375/* 1376 * ALC880 F1734 model 1377 * 1378 * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d) 1379 * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18 1380 */ 1381 1382static hda_nid_t alc880_f1734_dac_nids[1] = { 1383 0x03 1384}; 1385#define ALC880_F1734_HP_DAC 0x02 1386 1387static struct snd_kcontrol_new alc880_f1734_mixer[] = { 1388 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1389 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 1390 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1391 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 1392 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1393 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1394 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 1395 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 1396 { } /* end */ 1397}; 1398 1399static struct hda_input_mux alc880_f1734_capture_source = { 1400 .num_items = 2, 1401 .items = { 1402 { "Mic", 0x1 }, 1403 { "CD", 0x4 }, 1404 }, 1405}; 1406 1407 1408/* 1409 * ALC880 ASUS model 1410 * 1411 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e) 1412 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16, 1413 * Mic = 0x18, Line = 0x1a 1414 */ 1415 1416#define alc880_asus_dac_nids alc880_w810_dac_nids /* identical with w810 */ 1417#define alc880_asus_modes alc880_threestack_modes /* 2/6 channel mode */ 1418 1419static struct snd_kcontrol_new alc880_asus_mixer[] = { 1420 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1421 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 1422 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1423 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 1424 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 1425 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 1426 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 1427 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 1428 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1429 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1430 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 1431 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 1432 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1433 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1434 { 1435 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1436 .name = "Channel Mode", 1437 .info = alc_ch_mode_info, 1438 .get = alc_ch_mode_get, 1439 .put = alc_ch_mode_put, 1440 }, 1441 { } /* end */ 1442}; 1443 1444/* 1445 * ALC880 ASUS W1V model 1446 * 1447 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e) 1448 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16, 1449 * Mic = 0x18, Line = 0x1a, Line2 = 0x1b 1450 */ 1451 1452/* additional mixers to alc880_asus_mixer */ 1453static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = { 1454 HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT), 1455 HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT), 1456 { } /* end */ 1457}; 1458 1459/* additional mixers to alc880_asus_mixer */ 1460static struct snd_kcontrol_new alc880_pcbeep_mixer[] = { 1461 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 1462 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 1463 { } /* end */ 1464}; 1465 1466/* TCL S700 */ 1467static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = { 1468 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1469 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 1470 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 1471 HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT), 1472 HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT), 1473 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT), 1474 HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT), 1475 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 1476 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 1477 { 1478 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1479 /* The multiple "Capture Source" controls confuse alsamixer 1480 * So call somewhat different.. 1481 */ 1482 /* .name = "Capture Source", */ 1483 .name = "Input Source", 1484 .count = 1, 1485 .info = alc_mux_enum_info, 1486 .get = alc_mux_enum_get, 1487 .put = alc_mux_enum_put, 1488 }, 1489 { } /* end */ 1490}; 1491 1492/* Uniwill */ 1493static struct snd_kcontrol_new alc880_uniwill_mixer[] = { 1494 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1495 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 1496 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1497 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 1498 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 1499 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 1500 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 1501 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 1502 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1503 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1504 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 1505 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 1506 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1507 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1508 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 1509 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 1510 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 1511 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 1512 { 1513 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1514 .name = "Channel Mode", 1515 .info = alc_ch_mode_info, 1516 .get = alc_ch_mode_get, 1517 .put = alc_ch_mode_put, 1518 }, 1519 { } /* end */ 1520}; 1521 1522static struct snd_kcontrol_new alc880_fujitsu_mixer[] = { 1523 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1524 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 1525 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1526 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 1527 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 1528 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 1529 HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1530 HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1531 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 1532 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 1533 { } /* end */ 1534}; 1535 1536static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = { 1537 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 1538 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 1539 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 1540 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 1541 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 1542 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 1543 { } /* end */ 1544}; 1545 1546/* 1547 * virtual master controls 1548 */ 1549 1550/* 1551 * slave controls for virtual master 1552 */ 1553static const char *alc_slave_vols[] = { 1554 "Front Playback Volume", 1555 "Surround Playback Volume", 1556 "Center Playback Volume", 1557 "LFE Playback Volume", 1558 "Side Playback Volume", 1559 "Headphone Playback Volume", 1560 "Speaker Playback Volume", 1561 "Mono Playback Volume", 1562 "Line-Out Playback Volume", 1563 NULL, 1564}; 1565 1566static const char *alc_slave_sws[] = { 1567 "Front Playback Switch", 1568 "Surround Playback Switch", 1569 "Center Playback Switch", 1570 "LFE Playback Switch", 1571 "Side Playback Switch", 1572 "Headphone Playback Switch", 1573 "Speaker Playback Switch", 1574 "Mono Playback Switch", 1575 "IEC958 Playback Switch", 1576 NULL, 1577}; 1578 1579/* 1580 * build control elements 1581 */ 1582static int alc_build_controls(struct hda_codec *codec) 1583{ 1584 struct alc_spec *spec = codec->spec; 1585 int err; 1586 int i; 1587 1588 for (i = 0; i < spec->num_mixers; i++) { 1589 err = snd_hda_add_new_ctls(codec, spec->mixers[i]); 1590 if (err < 0) 1591 return err; 1592 } 1593 1594 if (spec->multiout.dig_out_nid) { 1595 err = snd_hda_create_spdif_out_ctls(codec, 1596 spec->multiout.dig_out_nid); 1597 if (err < 0) 1598 return err; 1599 err = snd_hda_create_spdif_share_sw(codec, 1600 &spec->multiout); 1601 if (err < 0) 1602 return err; 1603 spec->multiout.share_spdif = 1; 1604 } 1605 if (spec->dig_in_nid) { 1606 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid); 1607 if (err < 0) 1608 return err; 1609 } 1610 1611 /* if we have no master control, let's create it */ 1612 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) { 1613 unsigned int vmaster_tlv[4]; 1614 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid, 1615 HDA_OUTPUT, vmaster_tlv); 1616 err = snd_hda_add_vmaster(codec, "Master Playback Volume", 1617 vmaster_tlv, alc_slave_vols); 1618 if (err < 0) 1619 return err; 1620 } 1621 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) { 1622 err = snd_hda_add_vmaster(codec, "Master Playback Switch", 1623 NULL, alc_slave_sws); 1624 if (err < 0) 1625 return err; 1626 } 1627 1628 return 0; 1629} 1630 1631 1632/* 1633 * initialize the codec volumes, etc 1634 */ 1635 1636/* 1637 * generic initialization of ADC, input mixers and output mixers 1638 */ 1639static struct hda_verb alc880_volume_init_verbs[] = { 1640 /* 1641 * Unmute ADC0-2 and set the default input to mic-in 1642 */ 1643 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 1644 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1645 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 1646 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1647 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 1648 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1649 1650 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 1651 * mixer widget 1652 * Note: PASD motherboards uses the Line In 2 as the input for front 1653 * panel mic (mic 2) 1654 */ 1655 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 1656 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 1657 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 1658 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 1659 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 1660 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 1661 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 1662 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 1663 1664 /* 1665 * Set up output mixers (0x0c - 0x0f) 1666 */ 1667 /* set vol=0 to output mixers */ 1668 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1669 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1670 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1671 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1672 /* set up input amps for analog loopback */ 1673 /* Amp Indices: DAC = 0, mixer = 1 */ 1674 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 1675 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 1676 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 1677 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 1678 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 1679 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 1680 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 1681 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 1682 1683 { } 1684}; 1685 1686/* 1687 * 3-stack pin configuration: 1688 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b 1689 */ 1690static struct hda_verb alc880_pin_3stack_init_verbs[] = { 1691 /* 1692 * preset connection lists of input pins 1693 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround 1694 */ 1695 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 1696 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 1697 {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */ 1698 1699 /* 1700 * Set pin mode and muting 1701 */ 1702 /* set front pin widgets 0x14 for output */ 1703 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1704 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1705 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 1706 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1707 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1708 /* Mic2 (as headphone out) for HP output */ 1709 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1710 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1711 /* Line In pin widget for input */ 1712 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1713 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1714 /* Line2 (as front mic) pin widget for input and vref at 80% */ 1715 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1716 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1717 /* CD pin widget for input */ 1718 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1719 1720 { } 1721}; 1722 1723/* 1724 * 5-stack pin configuration: 1725 * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19, 1726 * line-in/side = 0x1a, f-mic = 0x1b 1727 */ 1728static struct hda_verb alc880_pin_5stack_init_verbs[] = { 1729 /* 1730 * preset connection lists of input pins 1731 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround 1732 */ 1733 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 1734 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */ 1735 1736 /* 1737 * Set pin mode and muting 1738 */ 1739 /* set pin widgets 0x14-0x17 for output */ 1740 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1741 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1742 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1743 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1744 /* unmute pins for output (no gain on this amp) */ 1745 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1746 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1747 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1748 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1749 1750 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 1751 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1752 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1753 /* Mic2 (as headphone out) for HP output */ 1754 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1755 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1756 /* Line In pin widget for input */ 1757 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1758 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1759 /* Line2 (as front mic) pin widget for input and vref at 80% */ 1760 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1761 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1762 /* CD pin widget for input */ 1763 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1764 1765 { } 1766}; 1767 1768/* 1769 * W810 pin configuration: 1770 * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b 1771 */ 1772static struct hda_verb alc880_pin_w810_init_verbs[] = { 1773 /* hphone/speaker input selector: front DAC */ 1774 {0x13, AC_VERB_SET_CONNECT_SEL, 0x0}, 1775 1776 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1777 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1778 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1779 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1780 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1781 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1782 1783 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1784 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1785 1786 { } 1787}; 1788 1789/* 1790 * Z71V pin configuration: 1791 * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?) 1792 */ 1793static struct hda_verb alc880_pin_z71v_init_verbs[] = { 1794 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1795 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1796 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1797 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1798 1799 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1800 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1801 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1802 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1803 1804 { } 1805}; 1806 1807/* 1808 * 6-stack pin configuration: 1809 * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18, 1810 * f-mic = 0x19, line = 0x1a, HP = 0x1b 1811 */ 1812static struct hda_verb alc880_pin_6stack_init_verbs[] = { 1813 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 1814 1815 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1816 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1817 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1818 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1819 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1820 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1821 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1822 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1823 1824 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1825 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1826 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1827 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1828 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1829 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1830 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1831 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1832 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1833 1834 { } 1835}; 1836 1837/* 1838 * Uniwill pin configuration: 1839 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19, 1840 * line = 0x1a 1841 */ 1842static struct hda_verb alc880_uniwill_init_verbs[] = { 1843 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 1844 1845 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1846 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1847 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1848 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1849 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1850 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1851 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1852 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1853 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 1854 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 1855 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 1856 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 1857 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 1858 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 1859 1860 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1861 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1862 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1863 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1864 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1865 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1866 /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */ 1867 /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */ 1868 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1869 1870 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 1871 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 1872 1873 { } 1874}; 1875 1876/* 1877* Uniwill P53 1878* HP = 0x14, InternalSpeaker = 0x15, mic = 0x19, 1879 */ 1880static struct hda_verb alc880_uniwill_p53_init_verbs[] = { 1881 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 1882 1883 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1884 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1885 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1886 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1887 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1888 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1889 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 1890 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 1891 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 1892 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 1893 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 1894 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 1895 1896 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1897 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1898 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1899 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1900 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1901 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1902 1903 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 1904 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT}, 1905 1906 { } 1907}; 1908 1909static struct hda_verb alc880_beep_init_verbs[] = { 1910 { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) }, 1911 { } 1912}; 1913 1914/* toggle speaker-output according to the hp-jack state */ 1915static void alc880_uniwill_hp_automute(struct hda_codec *codec) 1916{ 1917 unsigned int present; 1918 unsigned char bits; 1919 1920 present = snd_hda_codec_read(codec, 0x14, 0, 1921 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 1922 bits = present ? HDA_AMP_MUTE : 0; 1923 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 1924 HDA_AMP_MUTE, bits); 1925 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 1926 HDA_AMP_MUTE, bits); 1927} 1928 1929/* auto-toggle front mic */ 1930static void alc880_uniwill_mic_automute(struct hda_codec *codec) 1931{ 1932 unsigned int present; 1933 unsigned char bits; 1934 1935 present = snd_hda_codec_read(codec, 0x18, 0, 1936 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 1937 bits = present ? HDA_AMP_MUTE : 0; 1938 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits); 1939} 1940 1941static void alc880_uniwill_automute(struct hda_codec *codec) 1942{ 1943 alc880_uniwill_hp_automute(codec); 1944 alc880_uniwill_mic_automute(codec); 1945} 1946 1947static void alc880_uniwill_unsol_event(struct hda_codec *codec, 1948 unsigned int res) 1949{ 1950 /* Looks like the unsol event is incompatible with the standard 1951 * definition. 4bit tag is placed at 28 bit! 1952 */ 1953 switch (res >> 28) { 1954 case ALC880_HP_EVENT: 1955 alc880_uniwill_hp_automute(codec); 1956 break; 1957 case ALC880_MIC_EVENT: 1958 alc880_uniwill_mic_automute(codec); 1959 break; 1960 } 1961} 1962 1963static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec) 1964{ 1965 unsigned int present; 1966 unsigned char bits; 1967 1968 present = snd_hda_codec_read(codec, 0x14, 0, 1969 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 1970 bits = present ? HDA_AMP_MUTE : 0; 1971 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, HDA_AMP_MUTE, bits); 1972} 1973 1974static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec) 1975{ 1976 unsigned int present; 1977 1978 present = snd_hda_codec_read(codec, 0x21, 0, 1979 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0); 1980 present &= HDA_AMP_VOLMASK; 1981 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, 1982 HDA_AMP_VOLMASK, present); 1983 snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0, 1984 HDA_AMP_VOLMASK, present); 1985} 1986 1987static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec, 1988 unsigned int res) 1989{ 1990 /* Looks like the unsol event is incompatible with the standard 1991 * definition. 4bit tag is placed at 28 bit! 1992 */ 1993 if ((res >> 28) == ALC880_HP_EVENT) 1994 alc880_uniwill_p53_hp_automute(codec); 1995 if ((res >> 28) == ALC880_DCVOL_EVENT) 1996 alc880_uniwill_p53_dcvol_automute(codec); 1997} 1998 1999/* 2000 * F1734 pin configuration: 2001 * HP = 0x14, speaker-out = 0x15, mic = 0x18 2002 */ 2003static struct hda_verb alc880_pin_f1734_init_verbs[] = { 2004 {0x07, AC_VERB_SET_CONNECT_SEL, 0x01}, 2005 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, 2006 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, 2007 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, 2008 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, 2009 2010 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2011 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2012 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2013 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2014 2015 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2016 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2017 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50}, 2018 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2019 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2020 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2021 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2022 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2023 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2024 2025 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT}, 2026 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT}, 2027 2028 { } 2029}; 2030 2031/* 2032 * ASUS pin configuration: 2033 * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a 2034 */ 2035static struct hda_verb alc880_pin_asus_init_verbs[] = { 2036 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, 2037 {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, 2038 {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, 2039 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, 2040 2041 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2042 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2043 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2044 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2045 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2046 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2047 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2048 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2049 2050 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2051 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2052 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2053 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2054 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2055 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2056 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2057 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2058 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2059 2060 { } 2061}; 2062 2063/* Enable GPIO mask and set output */ 2064#define alc880_gpio1_init_verbs alc_gpio1_init_verbs 2065#define alc880_gpio2_init_verbs alc_gpio2_init_verbs 2066 2067/* Clevo m520g init */ 2068static struct hda_verb alc880_pin_clevo_init_verbs[] = { 2069 /* headphone output */ 2070 {0x11, AC_VERB_SET_CONNECT_SEL, 0x01}, 2071 /* line-out */ 2072 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2073 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2074 /* Line-in */ 2075 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2076 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2077 /* CD */ 2078 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2079 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2080 /* Mic1 (rear panel) */ 2081 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2082 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2083 /* Mic2 (front panel) */ 2084 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2085 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2086 /* headphone */ 2087 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2088 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2089 /* change to EAPD mode */ 2090 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 2091 {0x20, AC_VERB_SET_PROC_COEF, 0x3060}, 2092 2093 { } 2094}; 2095 2096static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = { 2097 /* change to EAPD mode */ 2098 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 2099 {0x20, AC_VERB_SET_PROC_COEF, 0x3060}, 2100 2101 /* Headphone output */ 2102 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2103 /* Front output*/ 2104 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2105 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 2106 2107 /* Line In pin widget for input */ 2108 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2109 /* CD pin widget for input */ 2110 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2111 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 2112 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2113 2114 /* change to EAPD mode */ 2115 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 2116 {0x20, AC_VERB_SET_PROC_COEF, 0x3070}, 2117 2118 { } 2119}; 2120 2121/* 2122 * LG m1 express dual 2123 * 2124 * Pin assignment: 2125 * Rear Line-In/Out (blue): 0x14 2126 * Build-in Mic-In: 0x15 2127 * Speaker-out: 0x17 2128 * HP-Out (green): 0x1b 2129 * Mic-In/Out (red): 0x19 2130 * SPDIF-Out: 0x1e 2131 */ 2132 2133/* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */ 2134static hda_nid_t alc880_lg_dac_nids[3] = { 2135 0x05, 0x02, 0x03 2136}; 2137 2138/* seems analog CD is not working */ 2139static struct hda_input_mux alc880_lg_capture_source = { 2140 .num_items = 3, 2141 .items = { 2142 { "Mic", 0x1 }, 2143 { "Line", 0x5 }, 2144 { "Internal Mic", 0x6 }, 2145 }, 2146}; 2147 2148/* 2,4,6 channel modes */ 2149static struct hda_verb alc880_lg_ch2_init[] = { 2150 /* set line-in and mic-in to input */ 2151 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 2152 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 2153 { } 2154}; 2155 2156static struct hda_verb alc880_lg_ch4_init[] = { 2157 /* set line-in to out and mic-in to input */ 2158 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, 2159 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 2160 { } 2161}; 2162 2163static struct hda_verb alc880_lg_ch6_init[] = { 2164 /* set line-in and mic-in to output */ 2165 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, 2166 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, 2167 { } 2168}; 2169 2170static struct hda_channel_mode alc880_lg_ch_modes[3] = { 2171 { 2, alc880_lg_ch2_init }, 2172 { 4, alc880_lg_ch4_init }, 2173 { 6, alc880_lg_ch6_init }, 2174}; 2175 2176static struct snd_kcontrol_new alc880_lg_mixer[] = { 2177 HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 2178 HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT), 2179 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2180 HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT), 2181 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT), 2182 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT), 2183 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT), 2184 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT), 2185 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 2186 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 2187 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT), 2188 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT), 2189 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT), 2190 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT), 2191 { 2192 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2193 .name = "Channel Mode", 2194 .info = alc_ch_mode_info, 2195 .get = alc_ch_mode_get, 2196 .put = alc_ch_mode_put, 2197 }, 2198 { } /* end */ 2199}; 2200 2201static struct hda_verb alc880_lg_init_verbs[] = { 2202 /* set capture source to mic-in */ 2203 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2204 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2205 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2206 /* mute all amp mixer inputs */ 2207 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)}, 2208 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 2209 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 2210 /* line-in to input */ 2211 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2212 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2213 /* built-in mic */ 2214 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2215 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2216 /* speaker-out */ 2217 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2218 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2219 /* mic-in to input */ 2220 {0x11, AC_VERB_SET_CONNECT_SEL, 0x01}, 2221 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2222 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2223 /* HP-out */ 2224 {0x13, AC_VERB_SET_CONNECT_SEL, 0x03}, 2225 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2226 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2227 /* jack sense */ 2228 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1}, 2229 { } 2230}; 2231 2232/* toggle speaker-output according to the hp-jack state */ 2233static void alc880_lg_automute(struct hda_codec *codec) 2234{ 2235 unsigned int present; 2236 unsigned char bits; 2237 2238 present = snd_hda_codec_read(codec, 0x1b, 0, 2239 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 2240 bits = present ? HDA_AMP_MUTE : 0; 2241 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0, 2242 HDA_AMP_MUTE, bits); 2243} 2244 2245static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res) 2246{ 2247 /* Looks like the unsol event is incompatible with the standard 2248 * definition. 4bit tag is placed at 28 bit! 2249 */ 2250 if ((res >> 28) == 0x01) 2251 alc880_lg_automute(codec); 2252} 2253 2254/* 2255 * LG LW20 2256 * 2257 * Pin assignment: 2258 * Speaker-out: 0x14 2259 * Mic-In: 0x18 2260 * Built-in Mic-In: 0x19 2261 * Line-In: 0x1b 2262 * HP-Out: 0x1a 2263 * SPDIF-Out: 0x1e 2264 */ 2265 2266static struct hda_input_mux alc880_lg_lw_capture_source = { 2267 .num_items = 3, 2268 .items = { 2269 { "Mic", 0x0 }, 2270 { "Internal Mic", 0x1 }, 2271 { "Line In", 0x2 }, 2272 }, 2273}; 2274 2275#define alc880_lg_lw_modes alc880_threestack_modes 2276 2277static struct snd_kcontrol_new alc880_lg_lw_mixer[] = { 2278 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2279 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 2280 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 2281 HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT), 2282 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 2283 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 2284 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 2285 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 2286 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 2287 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 2288 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 2289 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 2290 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 2291 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 2292 { 2293 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2294 .name = "Channel Mode", 2295 .info = alc_ch_mode_info, 2296 .get = alc_ch_mode_get, 2297 .put = alc_ch_mode_put, 2298 }, 2299 { } /* end */ 2300}; 2301 2302static struct hda_verb alc880_lg_lw_init_verbs[] = { 2303 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 2304 {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 2305 {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */ 2306 2307 /* set capture source to mic-in */ 2308 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2309 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2310 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2311 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 2312 /* speaker-out */ 2313 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2314 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2315 /* HP-out */ 2316 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2317 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2318 /* mic-in to input */ 2319 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2320 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2321 /* built-in mic */ 2322 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2323 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2324 /* jack sense */ 2325 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1}, 2326 { } 2327}; 2328 2329/* toggle speaker-output according to the hp-jack state */ 2330static void alc880_lg_lw_automute(struct hda_codec *codec) 2331{ 2332 unsigned int present; 2333 unsigned char bits; 2334 2335 present = snd_hda_codec_read(codec, 0x1b, 0, 2336 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 2337 bits = present ? HDA_AMP_MUTE : 0; 2338 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 2339 HDA_AMP_MUTE, bits); 2340} 2341 2342static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res) 2343{ 2344 /* Looks like the unsol event is incompatible with the standard 2345 * definition. 4bit tag is placed at 28 bit! 2346 */ 2347 if ((res >> 28) == 0x01) 2348 alc880_lg_lw_automute(codec); 2349} 2350 2351static struct snd_kcontrol_new alc880_medion_rim_mixer[] = { 2352 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2353 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT), 2354 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 2355 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 2356 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 2357 HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT), 2358 { } /* end */ 2359}; 2360 2361static struct hda_input_mux alc880_medion_rim_capture_source = { 2362 .num_items = 2, 2363 .items = { 2364 { "Mic", 0x0 }, 2365 { "Internal Mic", 0x1 }, 2366 }, 2367}; 2368 2369static struct hda_verb alc880_medion_rim_init_verbs[] = { 2370 {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 2371 2372 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2373 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2374 2375 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 2376 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2377 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2378 /* Mic2 (as headphone out) for HP output */ 2379 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2380 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2381 /* Internal Speaker */ 2382 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2383 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2384 2385 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 2386 {0x20, AC_VERB_SET_PROC_COEF, 0x3060}, 2387 2388 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 2389 { } 2390}; 2391 2392/* toggle speaker-output according to the hp-jack state */ 2393static void alc880_medion_rim_automute(struct hda_codec *codec) 2394{ 2395 unsigned int present; 2396 unsigned char bits; 2397 2398 present = snd_hda_codec_read(codec, 0x14, 0, 2399 AC_VERB_GET_PIN_SENSE, 0) 2400 & AC_PINSENSE_PRESENCE; 2401 bits = present ? HDA_AMP_MUTE : 0; 2402 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 2403 HDA_AMP_MUTE, bits); 2404 if (present) 2405 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0); 2406 else 2407 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2); 2408} 2409 2410static void alc880_medion_rim_unsol_event(struct hda_codec *codec, 2411 unsigned int res) 2412{ 2413 /* Looks like the unsol event is incompatible with the standard 2414 * definition. 4bit tag is placed at 28 bit! 2415 */ 2416 if ((res >> 28) == ALC880_HP_EVENT) 2417 alc880_medion_rim_automute(codec); 2418} 2419 2420#ifdef CONFIG_SND_HDA_POWER_SAVE 2421static struct hda_amp_list alc880_loopbacks[] = { 2422 { 0x0b, HDA_INPUT, 0 }, 2423 { 0x0b, HDA_INPUT, 1 }, 2424 { 0x0b, HDA_INPUT, 2 }, 2425 { 0x0b, HDA_INPUT, 3 }, 2426 { 0x0b, HDA_INPUT, 4 }, 2427 { } /* end */ 2428}; 2429 2430static struct hda_amp_list alc880_lg_loopbacks[] = { 2431 { 0x0b, HDA_INPUT, 1 }, 2432 { 0x0b, HDA_INPUT, 6 }, 2433 { 0x0b, HDA_INPUT, 7 }, 2434 { } /* end */ 2435}; 2436#endif 2437 2438/* 2439 * Common callbacks 2440 */ 2441 2442static int alc_init(struct hda_codec *codec) 2443{ 2444 struct alc_spec *spec = codec->spec; 2445 unsigned int i; 2446 2447 alc_fix_pll(codec); 2448 if (codec->vendor_id == 0x10ec0888) 2449 alc888_coef_init(codec); 2450 2451 for (i = 0; i < spec->num_init_verbs; i++) 2452 snd_hda_sequence_write(codec, spec->init_verbs[i]); 2453 2454 if (spec->init_hook) 2455 spec->init_hook(codec); 2456 2457 return 0; 2458} 2459 2460static void alc_unsol_event(struct hda_codec *codec, unsigned int res) 2461{ 2462 struct alc_spec *spec = codec->spec; 2463 2464 if (spec->unsol_event) 2465 spec->unsol_event(codec, res); 2466} 2467 2468#ifdef CONFIG_SND_HDA_POWER_SAVE 2469static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid) 2470{ 2471 struct alc_spec *spec = codec->spec; 2472 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid); 2473} 2474#endif 2475 2476/* 2477 * Analog playback callbacks 2478 */ 2479static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo, 2480 struct hda_codec *codec, 2481 struct snd_pcm_substream *substream) 2482{ 2483 struct alc_spec *spec = codec->spec; 2484 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, 2485 hinfo); 2486} 2487 2488static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 2489 struct hda_codec *codec, 2490 unsigned int stream_tag, 2491 unsigned int format, 2492 struct snd_pcm_substream *substream) 2493{ 2494 struct alc_spec *spec = codec->spec; 2495 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, 2496 stream_tag, format, substream); 2497} 2498 2499static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 2500 struct hda_codec *codec, 2501 struct snd_pcm_substream *substream) 2502{ 2503 struct alc_spec *spec = codec->spec; 2504 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); 2505} 2506 2507/* 2508 * Digital out 2509 */ 2510static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, 2511 struct hda_codec *codec, 2512 struct snd_pcm_substream *substream) 2513{ 2514 struct alc_spec *spec = codec->spec; 2515 return snd_hda_multi_out_dig_open(codec, &spec->multiout); 2516} 2517 2518static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 2519 struct hda_codec *codec, 2520 unsigned int stream_tag, 2521 unsigned int format, 2522 struct snd_pcm_substream *substream) 2523{ 2524 struct alc_spec *spec = codec->spec; 2525 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, 2526 stream_tag, format, substream); 2527} 2528 2529static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, 2530 struct hda_codec *codec, 2531 struct snd_pcm_substream *substream) 2532{ 2533 struct alc_spec *spec = codec->spec; 2534 return snd_hda_multi_out_dig_close(codec, &spec->multiout); 2535} 2536 2537/* 2538 * Analog capture 2539 */ 2540static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 2541 struct hda_codec *codec, 2542 unsigned int stream_tag, 2543 unsigned int format, 2544 struct snd_pcm_substream *substream) 2545{ 2546 struct alc_spec *spec = codec->spec; 2547 2548 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1], 2549 stream_tag, 0, format); 2550 return 0; 2551} 2552 2553static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 2554 struct hda_codec *codec, 2555 struct snd_pcm_substream *substream) 2556{ 2557 struct alc_spec *spec = codec->spec; 2558 2559 snd_hda_codec_cleanup_stream(codec, 2560 spec->adc_nids[substream->number + 1]); 2561 return 0; 2562} 2563 2564 2565/* 2566 */ 2567static struct hda_pcm_stream alc880_pcm_analog_playback = { 2568 .substreams = 1, 2569 .channels_min = 2, 2570 .channels_max = 8, 2571 /* NID is set in alc_build_pcms */ 2572 .ops = { 2573 .open = alc880_playback_pcm_open, 2574 .prepare = alc880_playback_pcm_prepare, 2575 .cleanup = alc880_playback_pcm_cleanup 2576 }, 2577}; 2578 2579static struct hda_pcm_stream alc880_pcm_analog_capture = { 2580 .substreams = 1, 2581 .channels_min = 2, 2582 .channels_max = 2, 2583 /* NID is set in alc_build_pcms */ 2584}; 2585 2586static struct hda_pcm_stream alc880_pcm_analog_alt_playback = { 2587 .substreams = 1, 2588 .channels_min = 2, 2589 .channels_max = 2, 2590 /* NID is set in alc_build_pcms */ 2591}; 2592 2593static struct hda_pcm_stream alc880_pcm_analog_alt_capture = { 2594 .substreams = 2, /* can be overridden */ 2595 .channels_min = 2, 2596 .channels_max = 2, 2597 /* NID is set in alc_build_pcms */ 2598 .ops = { 2599 .prepare = alc880_alt_capture_pcm_prepare, 2600 .cleanup = alc880_alt_capture_pcm_cleanup 2601 }, 2602}; 2603 2604static struct hda_pcm_stream alc880_pcm_digital_playback = { 2605 .substreams = 1, 2606 .channels_min = 2, 2607 .channels_max = 2, 2608 /* NID is set in alc_build_pcms */ 2609 .ops = { 2610 .open = alc880_dig_playback_pcm_open, 2611 .close = alc880_dig_playback_pcm_close, 2612 .prepare = alc880_dig_playback_pcm_prepare 2613 }, 2614}; 2615 2616static struct hda_pcm_stream alc880_pcm_digital_capture = { 2617 .substreams = 1, 2618 .channels_min = 2, 2619 .channels_max = 2, 2620 /* NID is set in alc_build_pcms */ 2621}; 2622 2623/* Used by alc_build_pcms to flag that a PCM has no playback stream */ 2624static struct hda_pcm_stream alc_pcm_null_stream = { 2625 .substreams = 0, 2626 .channels_min = 0, 2627 .channels_max = 0, 2628}; 2629 2630static int alc_build_pcms(struct hda_codec *codec) 2631{ 2632 struct alc_spec *spec = codec->spec; 2633 struct hda_pcm *info = spec->pcm_rec; 2634 int i; 2635 2636 codec->num_pcms = 1; 2637 codec->pcm_info = info; 2638 2639 info->name = spec->stream_name_analog; 2640 if (spec->stream_analog_playback) { 2641 if (snd_BUG_ON(!spec->multiout.dac_nids)) 2642 return -EINVAL; 2643 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback); 2644 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0]; 2645 } 2646 if (spec->stream_analog_capture) { 2647 if (snd_BUG_ON(!spec->adc_nids)) 2648 return -EINVAL; 2649 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture); 2650 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; 2651 } 2652 2653 if (spec->channel_mode) { 2654 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0; 2655 for (i = 0; i < spec->num_channel_mode; i++) { 2656 if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) { 2657 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels; 2658 } 2659 } 2660 } 2661 2662 /* SPDIF for stream index #1 */ 2663 if (spec->multiout.dig_out_nid || spec->dig_in_nid) { 2664 codec->num_pcms = 2; 2665 info = spec->pcm_rec + 1; 2666 info->name = spec->stream_name_digital; 2667 info->pcm_type = HDA_PCM_TYPE_SPDIF; 2668 if (spec->multiout.dig_out_nid && 2669 spec->stream_digital_playback) { 2670 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback); 2671 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid; 2672 } 2673 if (spec->dig_in_nid && 2674 spec->stream_digital_capture) { 2675 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture); 2676 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid; 2677 } 2678 /* FIXME: do we need this for all Realtek codec models? */ 2679 codec->spdif_status_reset = 1; 2680 } 2681 2682 /* If the use of more than one ADC is requested for the current 2683 * model, configure a second analog capture-only PCM. 2684 */ 2685 /* Additional Analaog capture for index #2 */ 2686 if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) || 2687 (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) { 2688 codec->num_pcms = 3; 2689 info = spec->pcm_rec + 2; 2690 info->name = spec->stream_name_analog; 2691 if (spec->alt_dac_nid) { 2692 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 2693 *spec->stream_analog_alt_playback; 2694 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 2695 spec->alt_dac_nid; 2696 } else { 2697 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 2698 alc_pcm_null_stream; 2699 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0; 2700 } 2701 if (spec->num_adc_nids > 1) { 2702 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 2703 *spec->stream_analog_alt_capture; 2704 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 2705 spec->adc_nids[1]; 2706 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 2707 spec->num_adc_nids - 1; 2708 } else { 2709 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 2710 alc_pcm_null_stream; 2711 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0; 2712 } 2713 } 2714 2715 return 0; 2716} 2717 2718static void alc_free(struct hda_codec *codec) 2719{ 2720 struct alc_spec *spec = codec->spec; 2721 unsigned int i; 2722 2723 if (!spec) 2724 return; 2725 2726 if (spec->kctl_alloc) { 2727 for (i = 0; i < spec->num_kctl_used; i++) 2728 kfree(spec->kctl_alloc[i].name); 2729 kfree(spec->kctl_alloc); 2730 } 2731 kfree(spec); 2732 codec->spec = NULL; /* to be sure */ 2733} 2734 2735/* 2736 */ 2737static struct hda_codec_ops alc_patch_ops = { 2738 .build_controls = alc_build_controls, 2739 .build_pcms = alc_build_pcms, 2740 .init = alc_init, 2741 .free = alc_free, 2742 .unsol_event = alc_unsol_event, 2743#ifdef CONFIG_SND_HDA_POWER_SAVE 2744 .check_power_status = alc_check_power_status, 2745#endif 2746}; 2747 2748 2749/* 2750 * Test configuration for debugging 2751 * 2752 * Almost all inputs/outputs are enabled. I/O pins can be configured via 2753 * enum controls. 2754 */ 2755#ifdef CONFIG_SND_DEBUG 2756static hda_nid_t alc880_test_dac_nids[4] = { 2757 0x02, 0x03, 0x04, 0x05 2758}; 2759 2760static struct hda_input_mux alc880_test_capture_source = { 2761 .num_items = 7, 2762 .items = { 2763 { "In-1", 0x0 }, 2764 { "In-2", 0x1 }, 2765 { "In-3", 0x2 }, 2766 { "In-4", 0x3 }, 2767 { "CD", 0x4 }, 2768 { "Front", 0x5 }, 2769 { "Surround", 0x6 }, 2770 }, 2771}; 2772 2773static struct hda_channel_mode alc880_test_modes[4] = { 2774 { 2, NULL }, 2775 { 4, NULL }, 2776 { 6, NULL }, 2777 { 8, NULL }, 2778}; 2779 2780static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol, 2781 struct snd_ctl_elem_info *uinfo) 2782{ 2783 static char *texts[] = { 2784 "N/A", "Line Out", "HP Out", 2785 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%" 2786 }; 2787 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 2788 uinfo->count = 1; 2789 uinfo->value.enumerated.items = 8; 2790 if (uinfo->value.enumerated.item >= 8) 2791 uinfo->value.enumerated.item = 7; 2792 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 2793 return 0; 2794} 2795 2796static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol, 2797 struct snd_ctl_elem_value *ucontrol) 2798{ 2799 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2800 hda_nid_t nid = (hda_nid_t)kcontrol->private_value; 2801 unsigned int pin_ctl, item = 0; 2802 2803 pin_ctl = snd_hda_codec_read(codec, nid, 0, 2804 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 2805 if (pin_ctl & AC_PINCTL_OUT_EN) { 2806 if (pin_ctl & AC_PINCTL_HP_EN) 2807 item = 2; 2808 else 2809 item = 1; 2810 } else if (pin_ctl & AC_PINCTL_IN_EN) { 2811 switch (pin_ctl & AC_PINCTL_VREFEN) { 2812 case AC_PINCTL_VREF_HIZ: item = 3; break; 2813 case AC_PINCTL_VREF_50: item = 4; break; 2814 case AC_PINCTL_VREF_GRD: item = 5; break; 2815 case AC_PINCTL_VREF_80: item = 6; break; 2816 case AC_PINCTL_VREF_100: item = 7; break; 2817 } 2818 } 2819 ucontrol->value.enumerated.item[0] = item; 2820 return 0; 2821} 2822 2823static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol, 2824 struct snd_ctl_elem_value *ucontrol) 2825{ 2826 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2827 hda_nid_t nid = (hda_nid_t)kcontrol->private_value; 2828 static unsigned int ctls[] = { 2829 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN, 2830 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ, 2831 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50, 2832 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD, 2833 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80, 2834 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100, 2835 }; 2836 unsigned int old_ctl, new_ctl; 2837 2838 old_ctl = snd_hda_codec_read(codec, nid, 0, 2839 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 2840 new_ctl = ctls[ucontrol->value.enumerated.item[0]]; 2841 if (old_ctl != new_ctl) { 2842 int val; 2843 snd_hda_codec_write_cache(codec, nid, 0, 2844 AC_VERB_SET_PIN_WIDGET_CONTROL, 2845 new_ctl); 2846 val = ucontrol->value.enumerated.item[0] >= 3 ? 2847 HDA_AMP_MUTE : 0; 2848 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 2849 HDA_AMP_MUTE, val); 2850 return 1; 2851 } 2852 return 0; 2853} 2854 2855static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol, 2856 struct snd_ctl_elem_info *uinfo) 2857{ 2858 static char *texts[] = { 2859 "Front", "Surround", "CLFE", "Side" 2860 }; 2861 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 2862 uinfo->count = 1; 2863 uinfo->value.enumerated.items = 4; 2864 if (uinfo->value.enumerated.item >= 4) 2865 uinfo->value.enumerated.item = 3; 2866 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 2867 return 0; 2868} 2869 2870static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol, 2871 struct snd_ctl_elem_value *ucontrol) 2872{ 2873 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2874 hda_nid_t nid = (hda_nid_t)kcontrol->private_value; 2875 unsigned int sel; 2876 2877 sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0); 2878 ucontrol->value.enumerated.item[0] = sel & 3; 2879 return 0; 2880} 2881 2882static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol, 2883 struct snd_ctl_elem_value *ucontrol) 2884{ 2885 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2886 hda_nid_t nid = (hda_nid_t)kcontrol->private_value; 2887 unsigned int sel; 2888 2889 sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3; 2890 if (ucontrol->value.enumerated.item[0] != sel) { 2891 sel = ucontrol->value.enumerated.item[0] & 3; 2892 snd_hda_codec_write_cache(codec, nid, 0, 2893 AC_VERB_SET_CONNECT_SEL, sel); 2894 return 1; 2895 } 2896 return 0; 2897} 2898 2899#define PIN_CTL_TEST(xname,nid) { \ 2900 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 2901 .name = xname, \ 2902 .info = alc_test_pin_ctl_info, \ 2903 .get = alc_test_pin_ctl_get, \ 2904 .put = alc_test_pin_ctl_put, \ 2905 .private_value = nid \ 2906 } 2907 2908#define PIN_SRC_TEST(xname,nid) { \ 2909 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 2910 .name = xname, \ 2911 .info = alc_test_pin_src_info, \ 2912 .get = alc_test_pin_src_get, \ 2913 .put = alc_test_pin_src_put, \ 2914 .private_value = nid \ 2915 } 2916 2917static struct snd_kcontrol_new alc880_test_mixer[] = { 2918 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 2919 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 2920 HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT), 2921 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 2922 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 2923 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 2924 HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT), 2925 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 2926 PIN_CTL_TEST("Front Pin Mode", 0x14), 2927 PIN_CTL_TEST("Surround Pin Mode", 0x15), 2928 PIN_CTL_TEST("CLFE Pin Mode", 0x16), 2929 PIN_CTL_TEST("Side Pin Mode", 0x17), 2930 PIN_CTL_TEST("In-1 Pin Mode", 0x18), 2931 PIN_CTL_TEST("In-2 Pin Mode", 0x19), 2932 PIN_CTL_TEST("In-3 Pin Mode", 0x1a), 2933 PIN_CTL_TEST("In-4 Pin Mode", 0x1b), 2934 PIN_SRC_TEST("In-1 Pin Source", 0x18), 2935 PIN_SRC_TEST("In-2 Pin Source", 0x19), 2936 PIN_SRC_TEST("In-3 Pin Source", 0x1a), 2937 PIN_SRC_TEST("In-4 Pin Source", 0x1b), 2938 HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT), 2939 HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT), 2940 HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT), 2941 HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT), 2942 HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT), 2943 HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT), 2944 HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT), 2945 HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT), 2946 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT), 2947 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT), 2948 { 2949 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2950 .name = "Channel Mode", 2951 .info = alc_ch_mode_info, 2952 .get = alc_ch_mode_get, 2953 .put = alc_ch_mode_put, 2954 }, 2955 { } /* end */ 2956}; 2957 2958static struct hda_verb alc880_test_init_verbs[] = { 2959 /* Unmute inputs of 0x0c - 0x0f */ 2960 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2961 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2962 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2963 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2964 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2965 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2966 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2967 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2968 /* Vol output for 0x0c-0x0f */ 2969 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2970 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2971 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2972 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2973 /* Set output pins 0x14-0x17 */ 2974 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2975 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2976 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2977 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2978 /* Unmute output pins 0x14-0x17 */ 2979 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2980 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2981 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2982 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2983 /* Set input pins 0x18-0x1c */ 2984 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2985 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2986 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2987 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2988 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2989 /* Mute input pins 0x18-0x1b */ 2990 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2991 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2992 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2993 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2994 /* ADC set up */ 2995 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2996 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 2997 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2998 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 2999 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3000 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 3001 /* Analog input/passthru */ 3002 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3003 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 3004 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 3005 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 3006 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 3007 { } 3008}; 3009#endif 3010 3011/* 3012 */ 3013 3014static const char *alc880_models[ALC880_MODEL_LAST] = { 3015 [ALC880_3ST] = "3stack", 3016 [ALC880_TCL_S700] = "tcl", 3017 [ALC880_3ST_DIG] = "3stack-digout", 3018 [ALC880_CLEVO] = "clevo", 3019 [ALC880_5ST] = "5stack", 3020 [ALC880_5ST_DIG] = "5stack-digout", 3021 [ALC880_W810] = "w810", 3022 [ALC880_Z71V] = "z71v", 3023 [ALC880_6ST] = "6stack", 3024 [ALC880_6ST_DIG] = "6stack-digout", 3025 [ALC880_ASUS] = "asus", 3026 [ALC880_ASUS_W1V] = "asus-w1v", 3027 [ALC880_ASUS_DIG] = "asus-dig", 3028 [ALC880_ASUS_DIG2] = "asus-dig2", 3029 [ALC880_UNIWILL_DIG] = "uniwill", 3030 [ALC880_UNIWILL_P53] = "uniwill-p53", 3031 [ALC880_FUJITSU] = "fujitsu", 3032 [ALC880_F1734] = "F1734", 3033 [ALC880_LG] = "lg", 3034 [ALC880_LG_LW] = "lg-lw", 3035 [ALC880_MEDION_RIM] = "medion", 3036#ifdef CONFIG_SND_DEBUG 3037 [ALC880_TEST] = "test", 3038#endif 3039 [ALC880_AUTO] = "auto", 3040}; 3041 3042static struct snd_pci_quirk alc880_cfg_tbl[] = { 3043 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810), 3044 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG), 3045 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST), 3046 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG), 3047 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG), 3048 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG), 3049 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG), 3050 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG), 3051 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST), 3052 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG), 3053 SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST), 3054 SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V), 3055 SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG), 3056 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG), 3057 SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG), 3058 SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG), 3059 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG), 3060 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V), 3061 /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */ 3062 SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG), 3063 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG), 3064 SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG), 3065 SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG), 3066 SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST), 3067 SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST), 3068 SND_PCI_QUIRK(0x1043, 0, "ASUS", ALC880_ASUS), /* default ASUS */ 3069 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST), 3070 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST), 3071 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST), 3072 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST), 3073 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST), 3074 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG), 3075 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG), 3076 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG), 3077 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG), 3078 SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO), 3079 SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO), 3080 SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2), 3081 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG), 3082 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG), 3083 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734), 3084 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL), 3085 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53), 3086 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810), 3087 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM), 3088 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG), 3089 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG), 3090 SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734), 3091 SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU), 3092 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL), 3093 SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU), 3094 SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW), 3095 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG), 3096 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG), 3097 SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW), 3098 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700), 3099 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */ 3100 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG), 3101 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG), 3102 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG), 3103 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG), 3104 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG), 3105 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG), 3106 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG), 3107 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG), 3108 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG), 3109 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG), 3110 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG), 3111 SND_PCI_QUIRK(0x8086, 0, "Intel mobo", ALC880_3ST), /* default Intel */ 3112 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG), 3113 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG), 3114 {} 3115}; 3116 3117/* 3118 * ALC880 codec presets 3119 */ 3120static struct alc_config_preset alc880_presets[] = { 3121 [ALC880_3ST] = { 3122 .mixers = { alc880_three_stack_mixer }, 3123 .init_verbs = { alc880_volume_init_verbs, 3124 alc880_pin_3stack_init_verbs }, 3125 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3126 .dac_nids = alc880_dac_nids, 3127 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 3128 .channel_mode = alc880_threestack_modes, 3129 .need_dac_fix = 1, 3130 .input_mux = &alc880_capture_source, 3131 }, 3132 [ALC880_3ST_DIG] = { 3133 .mixers = { alc880_three_stack_mixer }, 3134 .init_verbs = { alc880_volume_init_verbs, 3135 alc880_pin_3stack_init_verbs }, 3136 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3137 .dac_nids = alc880_dac_nids, 3138 .dig_out_nid = ALC880_DIGOUT_NID, 3139 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 3140 .channel_mode = alc880_threestack_modes, 3141 .need_dac_fix = 1, 3142 .input_mux = &alc880_capture_source, 3143 }, 3144 [ALC880_TCL_S700] = { 3145 .mixers = { alc880_tcl_s700_mixer }, 3146 .init_verbs = { alc880_volume_init_verbs, 3147 alc880_pin_tcl_S700_init_verbs, 3148 alc880_gpio2_init_verbs }, 3149 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3150 .dac_nids = alc880_dac_nids, 3151 .hp_nid = 0x03, 3152 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 3153 .channel_mode = alc880_2_jack_modes, 3154 .input_mux = &alc880_capture_source, 3155 }, 3156 [ALC880_5ST] = { 3157 .mixers = { alc880_three_stack_mixer, 3158 alc880_five_stack_mixer}, 3159 .init_verbs = { alc880_volume_init_verbs, 3160 alc880_pin_5stack_init_verbs }, 3161 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3162 .dac_nids = alc880_dac_nids, 3163 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes), 3164 .channel_mode = alc880_fivestack_modes, 3165 .input_mux = &alc880_capture_source, 3166 }, 3167 [ALC880_5ST_DIG] = { 3168 .mixers = { alc880_three_stack_mixer, 3169 alc880_five_stack_mixer }, 3170 .init_verbs = { alc880_volume_init_verbs, 3171 alc880_pin_5stack_init_verbs }, 3172 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3173 .dac_nids = alc880_dac_nids, 3174 .dig_out_nid = ALC880_DIGOUT_NID, 3175 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes), 3176 .channel_mode = alc880_fivestack_modes, 3177 .input_mux = &alc880_capture_source, 3178 }, 3179 [ALC880_6ST] = { 3180 .mixers = { alc880_six_stack_mixer }, 3181 .init_verbs = { alc880_volume_init_verbs, 3182 alc880_pin_6stack_init_verbs }, 3183 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids), 3184 .dac_nids = alc880_6st_dac_nids, 3185 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes), 3186 .channel_mode = alc880_sixstack_modes, 3187 .input_mux = &alc880_6stack_capture_source, 3188 }, 3189 [ALC880_6ST_DIG] = { 3190 .mixers = { alc880_six_stack_mixer }, 3191 .init_verbs = { alc880_volume_init_verbs, 3192 alc880_pin_6stack_init_verbs }, 3193 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids), 3194 .dac_nids = alc880_6st_dac_nids, 3195 .dig_out_nid = ALC880_DIGOUT_NID, 3196 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes), 3197 .channel_mode = alc880_sixstack_modes, 3198 .input_mux = &alc880_6stack_capture_source, 3199 }, 3200 [ALC880_W810] = { 3201 .mixers = { alc880_w810_base_mixer }, 3202 .init_verbs = { alc880_volume_init_verbs, 3203 alc880_pin_w810_init_verbs, 3204 alc880_gpio2_init_verbs }, 3205 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids), 3206 .dac_nids = alc880_w810_dac_nids, 3207 .dig_out_nid = ALC880_DIGOUT_NID, 3208 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes), 3209 .channel_mode = alc880_w810_modes, 3210 .input_mux = &alc880_capture_source, 3211 }, 3212 [ALC880_Z71V] = { 3213 .mixers = { alc880_z71v_mixer }, 3214 .init_verbs = { alc880_volume_init_verbs, 3215 alc880_pin_z71v_init_verbs }, 3216 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids), 3217 .dac_nids = alc880_z71v_dac_nids, 3218 .dig_out_nid = ALC880_DIGOUT_NID, 3219 .hp_nid = 0x03, 3220 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 3221 .channel_mode = alc880_2_jack_modes, 3222 .input_mux = &alc880_capture_source, 3223 }, 3224 [ALC880_F1734] = { 3225 .mixers = { alc880_f1734_mixer }, 3226 .init_verbs = { alc880_volume_init_verbs, 3227 alc880_pin_f1734_init_verbs }, 3228 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids), 3229 .dac_nids = alc880_f1734_dac_nids, 3230 .hp_nid = 0x02, 3231 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 3232 .channel_mode = alc880_2_jack_modes, 3233 .input_mux = &alc880_f1734_capture_source, 3234 .unsol_event = alc880_uniwill_p53_unsol_event, 3235 .init_hook = alc880_uniwill_p53_hp_automute, 3236 }, 3237 [ALC880_ASUS] = { 3238 .mixers = { alc880_asus_mixer }, 3239 .init_verbs = { alc880_volume_init_verbs, 3240 alc880_pin_asus_init_verbs, 3241 alc880_gpio1_init_verbs }, 3242 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3243 .dac_nids = alc880_asus_dac_nids, 3244 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 3245 .channel_mode = alc880_asus_modes, 3246 .need_dac_fix = 1, 3247 .input_mux = &alc880_capture_source, 3248 }, 3249 [ALC880_ASUS_DIG] = { 3250 .mixers = { alc880_asus_mixer }, 3251 .init_verbs = { alc880_volume_init_verbs, 3252 alc880_pin_asus_init_verbs, 3253 alc880_gpio1_init_verbs }, 3254 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3255 .dac_nids = alc880_asus_dac_nids, 3256 .dig_out_nid = ALC880_DIGOUT_NID, 3257 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 3258 .channel_mode = alc880_asus_modes, 3259 .need_dac_fix = 1, 3260 .input_mux = &alc880_capture_source, 3261 }, 3262 [ALC880_ASUS_DIG2] = { 3263 .mixers = { alc880_asus_mixer }, 3264 .init_verbs = { alc880_volume_init_verbs, 3265 alc880_pin_asus_init_verbs, 3266 alc880_gpio2_init_verbs }, /* use GPIO2 */ 3267 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3268 .dac_nids = alc880_asus_dac_nids, 3269 .dig_out_nid = ALC880_DIGOUT_NID, 3270 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 3271 .channel_mode = alc880_asus_modes, 3272 .need_dac_fix = 1, 3273 .input_mux = &alc880_capture_source, 3274 }, 3275 [ALC880_ASUS_W1V] = { 3276 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer }, 3277 .init_verbs = { alc880_volume_init_verbs, 3278 alc880_pin_asus_init_verbs, 3279 alc880_gpio1_init_verbs }, 3280 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3281 .dac_nids = alc880_asus_dac_nids, 3282 .dig_out_nid = ALC880_DIGOUT_NID, 3283 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 3284 .channel_mode = alc880_asus_modes, 3285 .need_dac_fix = 1, 3286 .input_mux = &alc880_capture_source, 3287 }, 3288 [ALC880_UNIWILL_DIG] = { 3289 .mixers = { alc880_asus_mixer, alc880_pcbeep_mixer }, 3290 .init_verbs = { alc880_volume_init_verbs, 3291 alc880_pin_asus_init_verbs }, 3292 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3293 .dac_nids = alc880_asus_dac_nids, 3294 .dig_out_nid = ALC880_DIGOUT_NID, 3295 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), 3296 .channel_mode = alc880_asus_modes, 3297 .need_dac_fix = 1, 3298 .input_mux = &alc880_capture_source, 3299 }, 3300 [ALC880_UNIWILL] = { 3301 .mixers = { alc880_uniwill_mixer }, 3302 .init_verbs = { alc880_volume_init_verbs, 3303 alc880_uniwill_init_verbs }, 3304 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3305 .dac_nids = alc880_asus_dac_nids, 3306 .dig_out_nid = ALC880_DIGOUT_NID, 3307 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 3308 .channel_mode = alc880_threestack_modes, 3309 .need_dac_fix = 1, 3310 .input_mux = &alc880_capture_source, 3311 .unsol_event = alc880_uniwill_unsol_event, 3312 .init_hook = alc880_uniwill_automute, 3313 }, 3314 [ALC880_UNIWILL_P53] = { 3315 .mixers = { alc880_uniwill_p53_mixer }, 3316 .init_verbs = { alc880_volume_init_verbs, 3317 alc880_uniwill_p53_init_verbs }, 3318 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), 3319 .dac_nids = alc880_asus_dac_nids, 3320 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes), 3321 .channel_mode = alc880_threestack_modes, 3322 .input_mux = &alc880_capture_source, 3323 .unsol_event = alc880_uniwill_p53_unsol_event, 3324 .init_hook = alc880_uniwill_p53_hp_automute, 3325 }, 3326 [ALC880_FUJITSU] = { 3327 .mixers = { alc880_fujitsu_mixer, 3328 alc880_pcbeep_mixer, }, 3329 .init_verbs = { alc880_volume_init_verbs, 3330 alc880_uniwill_p53_init_verbs, 3331 alc880_beep_init_verbs }, 3332 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3333 .dac_nids = alc880_dac_nids, 3334 .dig_out_nid = ALC880_DIGOUT_NID, 3335 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 3336 .channel_mode = alc880_2_jack_modes, 3337 .input_mux = &alc880_capture_source, 3338 .unsol_event = alc880_uniwill_p53_unsol_event, 3339 .init_hook = alc880_uniwill_p53_hp_automute, 3340 }, 3341 [ALC880_CLEVO] = { 3342 .mixers = { alc880_three_stack_mixer }, 3343 .init_verbs = { alc880_volume_init_verbs, 3344 alc880_pin_clevo_init_verbs }, 3345 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3346 .dac_nids = alc880_dac_nids, 3347 .hp_nid = 0x03, 3348 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 3349 .channel_mode = alc880_threestack_modes, 3350 .need_dac_fix = 1, 3351 .input_mux = &alc880_capture_source, 3352 }, 3353 [ALC880_LG] = { 3354 .mixers = { alc880_lg_mixer }, 3355 .init_verbs = { alc880_volume_init_verbs, 3356 alc880_lg_init_verbs }, 3357 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids), 3358 .dac_nids = alc880_lg_dac_nids, 3359 .dig_out_nid = ALC880_DIGOUT_NID, 3360 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes), 3361 .channel_mode = alc880_lg_ch_modes, 3362 .need_dac_fix = 1, 3363 .input_mux = &alc880_lg_capture_source, 3364 .unsol_event = alc880_lg_unsol_event, 3365 .init_hook = alc880_lg_automute, 3366#ifdef CONFIG_SND_HDA_POWER_SAVE 3367 .loopbacks = alc880_lg_loopbacks, 3368#endif 3369 }, 3370 [ALC880_LG_LW] = { 3371 .mixers = { alc880_lg_lw_mixer }, 3372 .init_verbs = { alc880_volume_init_verbs, 3373 alc880_lg_lw_init_verbs }, 3374 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3375 .dac_nids = alc880_dac_nids, 3376 .dig_out_nid = ALC880_DIGOUT_NID, 3377 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes), 3378 .channel_mode = alc880_lg_lw_modes, 3379 .input_mux = &alc880_lg_lw_capture_source, 3380 .unsol_event = alc880_lg_lw_unsol_event, 3381 .init_hook = alc880_lg_lw_automute, 3382 }, 3383 [ALC880_MEDION_RIM] = { 3384 .mixers = { alc880_medion_rim_mixer }, 3385 .init_verbs = { alc880_volume_init_verbs, 3386 alc880_medion_rim_init_verbs, 3387 alc_gpio2_init_verbs }, 3388 .num_dacs = ARRAY_SIZE(alc880_dac_nids), 3389 .dac_nids = alc880_dac_nids, 3390 .dig_out_nid = ALC880_DIGOUT_NID, 3391 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), 3392 .channel_mode = alc880_2_jack_modes, 3393 .input_mux = &alc880_medion_rim_capture_source, 3394 .unsol_event = alc880_medion_rim_unsol_event, 3395 .init_hook = alc880_medion_rim_automute, 3396 }, 3397#ifdef CONFIG_SND_DEBUG 3398 [ALC880_TEST] = { 3399 .mixers = { alc880_test_mixer }, 3400 .init_verbs = { alc880_test_init_verbs }, 3401 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids), 3402 .dac_nids = alc880_test_dac_nids, 3403 .dig_out_nid = ALC880_DIGOUT_NID, 3404 .num_channel_mode = ARRAY_SIZE(alc880_test_modes), 3405 .channel_mode = alc880_test_modes, 3406 .input_mux = &alc880_test_capture_source, 3407 }, 3408#endif 3409}; 3410 3411/* 3412 * Automatic parse of I/O pins from the BIOS configuration 3413 */ 3414 3415#define NUM_CONTROL_ALLOC 32 3416#define NUM_VERB_ALLOC 32 3417 3418enum { 3419 ALC_CTL_WIDGET_VOL, 3420 ALC_CTL_WIDGET_MUTE, 3421 ALC_CTL_BIND_MUTE, 3422}; 3423static struct snd_kcontrol_new alc880_control_templates[] = { 3424 HDA_CODEC_VOLUME(NULL, 0, 0, 0), 3425 HDA_CODEC_MUTE(NULL, 0, 0, 0), 3426 HDA_BIND_MUTE(NULL, 0, 0, 0), 3427}; 3428 3429/* add dynamic controls */ 3430static int add_control(struct alc_spec *spec, int type, const char *name, 3431 unsigned long val) 3432{ 3433 struct snd_kcontrol_new *knew; 3434 3435 if (spec->num_kctl_used >= spec->num_kctl_alloc) { 3436 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC; 3437 3438 /* array + terminator */ 3439 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); 3440 if (!knew) 3441 return -ENOMEM; 3442 if (spec->kctl_alloc) { 3443 memcpy(knew, spec->kctl_alloc, 3444 sizeof(*knew) * spec->num_kctl_alloc); 3445 kfree(spec->kctl_alloc); 3446 } 3447 spec->kctl_alloc = knew; 3448 spec->num_kctl_alloc = num; 3449 } 3450 3451 knew = &spec->kctl_alloc[spec->num_kctl_used]; 3452 *knew = alc880_control_templates[type]; 3453 knew->name = kstrdup(name, GFP_KERNEL); 3454 if (!knew->name) 3455 return -ENOMEM; 3456 knew->private_value = val; 3457 spec->num_kctl_used++; 3458 return 0; 3459} 3460 3461#define alc880_is_fixed_pin(nid) ((nid) >= 0x14 && (nid) <= 0x17) 3462#define alc880_fixed_pin_idx(nid) ((nid) - 0x14) 3463#define alc880_is_multi_pin(nid) ((nid) >= 0x18) 3464#define alc880_multi_pin_idx(nid) ((nid) - 0x18) 3465#define alc880_is_input_pin(nid) ((nid) >= 0x18) 3466#define alc880_input_pin_idx(nid) ((nid) - 0x18) 3467#define alc880_idx_to_dac(nid) ((nid) + 0x02) 3468#define alc880_dac_to_idx(nid) ((nid) - 0x02) 3469#define alc880_idx_to_mixer(nid) ((nid) + 0x0c) 3470#define alc880_idx_to_selector(nid) ((nid) + 0x10) 3471#define ALC880_PIN_CD_NID 0x1c 3472 3473/* fill in the dac_nids table from the parsed pin configuration */ 3474static int alc880_auto_fill_dac_nids(struct alc_spec *spec, 3475 const struct auto_pin_cfg *cfg) 3476{ 3477 hda_nid_t nid; 3478 int assigned[4]; 3479 int i, j; 3480 3481 memset(assigned, 0, sizeof(assigned)); 3482 spec->multiout.dac_nids = spec->private_dac_nids; 3483 3484 /* check the pins hardwired to audio widget */ 3485 for (i = 0; i < cfg->line_outs; i++) { 3486 nid = cfg->line_out_pins[i]; 3487 if (alc880_is_fixed_pin(nid)) { 3488 int idx = alc880_fixed_pin_idx(nid); 3489 spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx); 3490 assigned[idx] = 1; 3491 } 3492 } 3493 /* left pins can be connect to any audio widget */ 3494 for (i = 0; i < cfg->line_outs; i++) { 3495 nid = cfg->line_out_pins[i]; 3496 if (alc880_is_fixed_pin(nid)) 3497 continue; 3498 /* search for an empty channel */ 3499 for (j = 0; j < cfg->line_outs; j++) { 3500 if (!assigned[j]) { 3501 spec->multiout.dac_nids[i] = 3502 alc880_idx_to_dac(j); 3503 assigned[j] = 1; 3504 break; 3505 } 3506 } 3507 } 3508 spec->multiout.num_dacs = cfg->line_outs; 3509 return 0; 3510} 3511 3512/* add playback controls from the parsed DAC table */ 3513static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec, 3514 const struct auto_pin_cfg *cfg) 3515{ 3516 char name[32]; 3517 static const char *chname[4] = { 3518 "Front", "Surround", NULL /*CLFE*/, "Side" 3519 }; 3520 hda_nid_t nid; 3521 int i, err; 3522 3523 for (i = 0; i < cfg->line_outs; i++) { 3524 if (!spec->multiout.dac_nids[i]) 3525 continue; 3526 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i])); 3527 if (i == 2) { 3528 /* Center/LFE */ 3529 err = add_control(spec, ALC_CTL_WIDGET_VOL, 3530 "Center Playback Volume", 3531 HDA_COMPOSE_AMP_VAL(nid, 1, 0, 3532 HDA_OUTPUT)); 3533 if (err < 0) 3534 return err; 3535 err = add_control(spec, ALC_CTL_WIDGET_VOL, 3536 "LFE Playback Volume", 3537 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 3538 HDA_OUTPUT)); 3539 if (err < 0) 3540 return err; 3541 err = add_control(spec, ALC_CTL_BIND_MUTE, 3542 "Center Playback Switch", 3543 HDA_COMPOSE_AMP_VAL(nid, 1, 2, 3544 HDA_INPUT)); 3545 if (err < 0) 3546 return err; 3547 err = add_control(spec, ALC_CTL_BIND_MUTE, 3548 "LFE Playback Switch", 3549 HDA_COMPOSE_AMP_VAL(nid, 2, 2, 3550 HDA_INPUT)); 3551 if (err < 0) 3552 return err; 3553 } else { 3554 sprintf(name, "%s Playback Volume", chname[i]); 3555 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 3556 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 3557 HDA_OUTPUT)); 3558 if (err < 0) 3559 return err; 3560 sprintf(name, "%s Playback Switch", chname[i]); 3561 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 3562 HDA_COMPOSE_AMP_VAL(nid, 3, 2, 3563 HDA_INPUT)); 3564 if (err < 0) 3565 return err; 3566 } 3567 } 3568 return 0; 3569} 3570 3571/* add playback controls for speaker and HP outputs */ 3572static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin, 3573 const char *pfx) 3574{ 3575 hda_nid_t nid; 3576 int err; 3577 char name[32]; 3578 3579 if (!pin) 3580 return 0; 3581 3582 if (alc880_is_fixed_pin(pin)) { 3583 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin)); 3584 /* specify the DAC as the extra output */ 3585 if (!spec->multiout.hp_nid) 3586 spec->multiout.hp_nid = nid; 3587 else 3588 spec->multiout.extra_out_nid[0] = nid; 3589 /* control HP volume/switch on the output mixer amp */ 3590 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin)); 3591 sprintf(name, "%s Playback Volume", pfx); 3592 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 3593 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 3594 if (err < 0) 3595 return err; 3596 sprintf(name, "%s Playback Switch", pfx); 3597 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 3598 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT)); 3599 if (err < 0) 3600 return err; 3601 } else if (alc880_is_multi_pin(pin)) { 3602 /* set manual connection */ 3603 /* we have only a switch on HP-out PIN */ 3604 sprintf(name, "%s Playback Switch", pfx); 3605 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 3606 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 3607 if (err < 0) 3608 return err; 3609 } 3610 return 0; 3611} 3612 3613/* create input playback/capture controls for the given pin */ 3614static int new_analog_input(struct alc_spec *spec, hda_nid_t pin, 3615 const char *ctlname, 3616 int idx, hda_nid_t mix_nid) 3617{ 3618 char name[32]; 3619 int err; 3620 3621 sprintf(name, "%s Playback Volume", ctlname); 3622 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 3623 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); 3624 if (err < 0) 3625 return err; 3626 sprintf(name, "%s Playback Switch", ctlname); 3627 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 3628 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); 3629 if (err < 0) 3630 return err; 3631 return 0; 3632} 3633 3634/* create playback/capture controls for input pins */ 3635static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec, 3636 const struct auto_pin_cfg *cfg) 3637{ 3638 struct hda_input_mux *imux = &spec->private_imux; 3639 int i, err, idx; 3640 3641 for (i = 0; i < AUTO_PIN_LAST; i++) { 3642 if (alc880_is_input_pin(cfg->input_pins[i])) { 3643 idx = alc880_input_pin_idx(cfg->input_pins[i]); 3644 err = new_analog_input(spec, cfg->input_pins[i], 3645 auto_pin_cfg_labels[i], 3646 idx, 0x0b); 3647 if (err < 0) 3648 return err; 3649 imux->items[imux->num_items].label = 3650 auto_pin_cfg_labels[i]; 3651 imux->items[imux->num_items].index = 3652 alc880_input_pin_idx(cfg->input_pins[i]); 3653 imux->num_items++; 3654 } 3655 } 3656 return 0; 3657} 3658 3659static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid, 3660 unsigned int pin_type) 3661{ 3662 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 3663 pin_type); 3664 /* unmute pin */ 3665 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, 3666 AMP_OUT_UNMUTE); 3667} 3668 3669static void alc880_auto_set_output_and_unmute(struct hda_codec *codec, 3670 hda_nid_t nid, int pin_type, 3671 int dac_idx) 3672{ 3673 alc_set_pin_output(codec, nid, pin_type); 3674 /* need the manual connection? */ 3675 if (alc880_is_multi_pin(nid)) { 3676 struct alc_spec *spec = codec->spec; 3677 int idx = alc880_multi_pin_idx(nid); 3678 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0, 3679 AC_VERB_SET_CONNECT_SEL, 3680 alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx])); 3681 } 3682} 3683 3684static int get_pin_type(int line_out_type) 3685{ 3686 if (line_out_type == AUTO_PIN_HP_OUT) 3687 return PIN_HP; 3688 else 3689 return PIN_OUT; 3690} 3691 3692static void alc880_auto_init_multi_out(struct hda_codec *codec) 3693{ 3694 struct alc_spec *spec = codec->spec; 3695 int i; 3696 3697 alc_subsystem_id(codec, 0x15, 0x1b, 0x14); 3698 for (i = 0; i < spec->autocfg.line_outs; i++) { 3699 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 3700 int pin_type = get_pin_type(spec->autocfg.line_out_type); 3701 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i); 3702 } 3703} 3704 3705static void alc880_auto_init_extra_out(struct hda_codec *codec) 3706{ 3707 struct alc_spec *spec = codec->spec; 3708 hda_nid_t pin; 3709 3710 pin = spec->autocfg.speaker_pins[0]; 3711 if (pin) /* connect to front */ 3712 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 3713 pin = spec->autocfg.hp_pins[0]; 3714 if (pin) /* connect to front */ 3715 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 3716} 3717 3718static void alc880_auto_init_analog_input(struct hda_codec *codec) 3719{ 3720 struct alc_spec *spec = codec->spec; 3721 int i; 3722 3723 for (i = 0; i < AUTO_PIN_LAST; i++) { 3724 hda_nid_t nid = spec->autocfg.input_pins[i]; 3725 if (alc880_is_input_pin(nid)) { 3726 snd_hda_codec_write(codec, nid, 0, 3727 AC_VERB_SET_PIN_WIDGET_CONTROL, 3728 i <= AUTO_PIN_FRONT_MIC ? 3729 PIN_VREF80 : PIN_IN); 3730 if (nid != ALC880_PIN_CD_NID) 3731 snd_hda_codec_write(codec, nid, 0, 3732 AC_VERB_SET_AMP_GAIN_MUTE, 3733 AMP_OUT_MUTE); 3734 } 3735 } 3736} 3737 3738/* parse the BIOS configuration and set up the alc_spec */ 3739/* return 1 if successful, 0 if the proper config is not found, 3740 * or a negative error code 3741 */ 3742static int alc880_parse_auto_config(struct hda_codec *codec) 3743{ 3744 struct alc_spec *spec = codec->spec; 3745 int err; 3746 static hda_nid_t alc880_ignore[] = { 0x1d, 0 }; 3747 3748 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 3749 alc880_ignore); 3750 if (err < 0) 3751 return err; 3752 if (!spec->autocfg.line_outs) 3753 return 0; /* can't find valid BIOS pin config */ 3754 3755 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg); 3756 if (err < 0) 3757 return err; 3758 err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg); 3759 if (err < 0) 3760 return err; 3761 err = alc880_auto_create_extra_out(spec, 3762 spec->autocfg.speaker_pins[0], 3763 "Speaker"); 3764 if (err < 0) 3765 return err; 3766 err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0], 3767 "Headphone"); 3768 if (err < 0) 3769 return err; 3770 err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg); 3771 if (err < 0) 3772 return err; 3773 3774 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 3775 3776 if (spec->autocfg.dig_out_pin) 3777 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID; 3778 if (spec->autocfg.dig_in_pin) 3779 spec->dig_in_nid = ALC880_DIGIN_NID; 3780 3781 if (spec->kctl_alloc) 3782 spec->mixers[spec->num_mixers++] = spec->kctl_alloc; 3783 3784 spec->init_verbs[spec->num_init_verbs++] = alc880_volume_init_verbs; 3785 3786 spec->num_mux_defs = 1; 3787 spec->input_mux = &spec->private_imux; 3788 3789 return 1; 3790} 3791 3792/* additional initialization for auto-configuration model */ 3793static void alc880_auto_init(struct hda_codec *codec) 3794{ 3795 struct alc_spec *spec = codec->spec; 3796 alc880_auto_init_multi_out(codec); 3797 alc880_auto_init_extra_out(codec); 3798 alc880_auto_init_analog_input(codec); 3799 if (spec->unsol_event) 3800 alc_sku_automute(codec); 3801} 3802 3803/* 3804 * OK, here we have finally the patch for ALC880 3805 */ 3806 3807static int patch_alc880(struct hda_codec *codec) 3808{ 3809 struct alc_spec *spec; 3810 int board_config; 3811 int err; 3812 3813 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 3814 if (spec == NULL) 3815 return -ENOMEM; 3816 3817 codec->spec = spec; 3818 3819 board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST, 3820 alc880_models, 3821 alc880_cfg_tbl); 3822 if (board_config < 0) { 3823 printk(KERN_INFO "hda_codec: Unknown model for ALC880, " 3824 "trying auto-probe from BIOS...\n"); 3825 board_config = ALC880_AUTO; 3826 } 3827 3828 if (board_config == ALC880_AUTO) { 3829 /* automatic parse from the BIOS config */ 3830 err = alc880_parse_auto_config(codec); 3831 if (err < 0) { 3832 alc_free(codec); 3833 return err; 3834 } else if (!err) { 3835 printk(KERN_INFO 3836 "hda_codec: Cannot set up configuration " 3837 "from BIOS. Using 3-stack mode...\n"); 3838 board_config = ALC880_3ST; 3839 } 3840 } 3841 3842 if (board_config != ALC880_AUTO) 3843 setup_preset(spec, &alc880_presets[board_config]); 3844 3845 spec->stream_name_analog = "ALC880 Analog"; 3846 spec->stream_analog_playback = &alc880_pcm_analog_playback; 3847 spec->stream_analog_capture = &alc880_pcm_analog_capture; 3848 spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture; 3849 3850 spec->stream_name_digital = "ALC880 Digital"; 3851 spec->stream_digital_playback = &alc880_pcm_digital_playback; 3852 spec->stream_digital_capture = &alc880_pcm_digital_capture; 3853 3854 if (!spec->adc_nids && spec->input_mux) { 3855 /* check whether NID 0x07 is valid */ 3856 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]); 3857 /* get type */ 3858 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 3859 if (wcap != AC_WID_AUD_IN) { 3860 spec->adc_nids = alc880_adc_nids_alt; 3861 spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt); 3862 spec->mixers[spec->num_mixers] = 3863 alc880_capture_alt_mixer; 3864 spec->num_mixers++; 3865 } else { 3866 spec->adc_nids = alc880_adc_nids; 3867 spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids); 3868 spec->mixers[spec->num_mixers] = alc880_capture_mixer; 3869 spec->num_mixers++; 3870 } 3871 } 3872 3873 spec->vmaster_nid = 0x0c; 3874 3875 codec->patch_ops = alc_patch_ops; 3876 if (board_config == ALC880_AUTO) 3877 spec->init_hook = alc880_auto_init; 3878#ifdef CONFIG_SND_HDA_POWER_SAVE 3879 if (!spec->loopback.amplist) 3880 spec->loopback.amplist = alc880_loopbacks; 3881#endif 3882 3883 return 0; 3884} 3885 3886 3887/* 3888 * ALC260 support 3889 */ 3890 3891static hda_nid_t alc260_dac_nids[1] = { 3892 /* front */ 3893 0x02, 3894}; 3895 3896static hda_nid_t alc260_adc_nids[1] = { 3897 /* ADC0 */ 3898 0x04, 3899}; 3900 3901static hda_nid_t alc260_adc_nids_alt[1] = { 3902 /* ADC1 */ 3903 0x05, 3904}; 3905 3906static hda_nid_t alc260_hp_adc_nids[2] = { 3907 /* ADC1, 0 */ 3908 0x05, 0x04 3909}; 3910 3911/* NIDs used when simultaneous access to both ADCs makes sense. Note that 3912 * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC. 3913 */ 3914static hda_nid_t alc260_dual_adc_nids[2] = { 3915 /* ADC0, ADC1 */ 3916 0x04, 0x05 3917}; 3918 3919#define ALC260_DIGOUT_NID 0x03 3920#define ALC260_DIGIN_NID 0x06 3921 3922static struct hda_input_mux alc260_capture_source = { 3923 .num_items = 4, 3924 .items = { 3925 { "Mic", 0x0 }, 3926 { "Front Mic", 0x1 }, 3927 { "Line", 0x2 }, 3928 { "CD", 0x4 }, 3929 }, 3930}; 3931 3932/* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack, 3933 * headphone jack and the internal CD lines since these are the only pins at 3934 * which audio can appear. For flexibility, also allow the option of 3935 * recording the mixer output on the second ADC (ADC0 doesn't have a 3936 * connection to the mixer output). 3937 */ 3938static struct hda_input_mux alc260_fujitsu_capture_sources[2] = { 3939 { 3940 .num_items = 3, 3941 .items = { 3942 { "Mic/Line", 0x0 }, 3943 { "CD", 0x4 }, 3944 { "Headphone", 0x2 }, 3945 }, 3946 }, 3947 { 3948 .num_items = 4, 3949 .items = { 3950 { "Mic/Line", 0x0 }, 3951 { "CD", 0x4 }, 3952 { "Headphone", 0x2 }, 3953 { "Mixer", 0x5 }, 3954 }, 3955 }, 3956 3957}; 3958 3959/* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to 3960 * the Fujitsu S702x, but jacks are marked differently. 3961 */ 3962static struct hda_input_mux alc260_acer_capture_sources[2] = { 3963 { 3964 .num_items = 4, 3965 .items = { 3966 { "Mic", 0x0 }, 3967 { "Line", 0x2 }, 3968 { "CD", 0x4 }, 3969 { "Headphone", 0x5 }, 3970 }, 3971 }, 3972 { 3973 .num_items = 5, 3974 .items = { 3975 { "Mic", 0x0 }, 3976 { "Line", 0x2 }, 3977 { "CD", 0x4 }, 3978 { "Headphone", 0x6 }, 3979 { "Mixer", 0x5 }, 3980 }, 3981 }, 3982}; 3983/* 3984 * This is just place-holder, so there's something for alc_build_pcms to look 3985 * at when it calculates the maximum number of channels. ALC260 has no mixer 3986 * element which allows changing the channel mode, so the verb list is 3987 * never used. 3988 */ 3989static struct hda_channel_mode alc260_modes[1] = { 3990 { 2, NULL }, 3991}; 3992 3993 3994/* Mixer combinations 3995 * 3996 * basic: base_output + input + pc_beep + capture 3997 * HP: base_output + input + capture_alt 3998 * HP_3013: hp_3013 + input + capture 3999 * fujitsu: fujitsu + capture 4000 * acer: acer + capture 4001 */ 4002 4003static struct snd_kcontrol_new alc260_base_output_mixer[] = { 4004 HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4005 HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT), 4006 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT), 4007 HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT), 4008 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT), 4009 HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT), 4010 { } /* end */ 4011}; 4012 4013static struct snd_kcontrol_new alc260_input_mixer[] = { 4014 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 4015 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 4016 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT), 4017 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT), 4018 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT), 4019 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT), 4020 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT), 4021 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT), 4022 { } /* end */ 4023}; 4024 4025static struct snd_kcontrol_new alc260_pc_beep_mixer[] = { 4026 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x07, 0x05, HDA_INPUT), 4027 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x07, 0x05, HDA_INPUT), 4028 { } /* end */ 4029}; 4030 4031/* update HP, line and mono out pins according to the master switch */ 4032static void alc260_hp_master_update(struct hda_codec *codec, 4033 hda_nid_t hp, hda_nid_t line, 4034 hda_nid_t mono) 4035{ 4036 struct alc_spec *spec = codec->spec; 4037 unsigned int val = spec->master_sw ? PIN_HP : 0; 4038 /* change HP and line-out pins */ 4039 snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4040 val); 4041 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4042 val); 4043 /* mono (speaker) depending on the HP jack sense */ 4044 val = (val && !spec->jack_present) ? PIN_OUT : 0; 4045 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4046 val); 4047} 4048 4049static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol, 4050 struct snd_ctl_elem_value *ucontrol) 4051{ 4052 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 4053 struct alc_spec *spec = codec->spec; 4054 *ucontrol->value.integer.value = spec->master_sw; 4055 return 0; 4056} 4057 4058static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol, 4059 struct snd_ctl_elem_value *ucontrol) 4060{ 4061 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 4062 struct alc_spec *spec = codec->spec; 4063 int val = !!*ucontrol->value.integer.value; 4064 hda_nid_t hp, line, mono; 4065 4066 if (val == spec->master_sw) 4067 return 0; 4068 spec->master_sw = val; 4069 hp = (kcontrol->private_value >> 16) & 0xff; 4070 line = (kcontrol->private_value >> 8) & 0xff; 4071 mono = kcontrol->private_value & 0xff; 4072 alc260_hp_master_update(codec, hp, line, mono); 4073 return 1; 4074} 4075 4076static struct snd_kcontrol_new alc260_hp_output_mixer[] = { 4077 { 4078 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4079 .name = "Master Playback Switch", 4080 .info = snd_ctl_boolean_mono_info, 4081 .get = alc260_hp_master_sw_get, 4082 .put = alc260_hp_master_sw_put, 4083 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11 4084 }, 4085 HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4086 HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT), 4087 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT), 4088 HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT), 4089 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, 4090 HDA_OUTPUT), 4091 HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT), 4092 { } /* end */ 4093}; 4094 4095static struct hda_verb alc260_hp_unsol_verbs[] = { 4096 {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 4097 {}, 4098}; 4099 4100static void alc260_hp_automute(struct hda_codec *codec) 4101{ 4102 struct alc_spec *spec = codec->spec; 4103 unsigned int present; 4104 4105 present = snd_hda_codec_read(codec, 0x10, 0, 4106 AC_VERB_GET_PIN_SENSE, 0); 4107 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0; 4108 alc260_hp_master_update(codec, 0x0f, 0x10, 0x11); 4109} 4110 4111static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res) 4112{ 4113 if ((res >> 26) == ALC880_HP_EVENT) 4114 alc260_hp_automute(codec); 4115} 4116 4117static struct snd_kcontrol_new alc260_hp_3013_mixer[] = { 4118 { 4119 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4120 .name = "Master Playback Switch", 4121 .info = snd_ctl_boolean_mono_info, 4122 .get = alc260_hp_master_sw_get, 4123 .put = alc260_hp_master_sw_put, 4124 .private_value = (0x10 << 16) | (0x15 << 8) | 0x11 4125 }, 4126 HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT), 4127 HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT), 4128 HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT), 4129 HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT), 4130 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4131 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 4132 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT), 4133 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT), 4134 { } /* end */ 4135}; 4136 4137static struct hda_bind_ctls alc260_dc7600_bind_master_vol = { 4138 .ops = &snd_hda_bind_vol, 4139 .values = { 4140 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT), 4141 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT), 4142 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT), 4143 0 4144 }, 4145}; 4146 4147static struct hda_bind_ctls alc260_dc7600_bind_switch = { 4148 .ops = &snd_hda_bind_sw, 4149 .values = { 4150 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT), 4151 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT), 4152 0 4153 }, 4154}; 4155 4156static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = { 4157 HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol), 4158 HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch), 4159 HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT), 4160 HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT), 4161 { } /* end */ 4162}; 4163 4164static struct hda_verb alc260_hp_3013_unsol_verbs[] = { 4165 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 4166 {}, 4167}; 4168 4169static void alc260_hp_3013_automute(struct hda_codec *codec) 4170{ 4171 struct alc_spec *spec = codec->spec; 4172 unsigned int present; 4173 4174 present = snd_hda_codec_read(codec, 0x15, 0, 4175 AC_VERB_GET_PIN_SENSE, 0); 4176 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0; 4177 alc260_hp_master_update(codec, 0x10, 0x15, 0x11); 4178} 4179 4180static void alc260_hp_3013_unsol_event(struct hda_codec *codec, 4181 unsigned int res) 4182{ 4183 if ((res >> 26) == ALC880_HP_EVENT) 4184 alc260_hp_3013_automute(codec); 4185} 4186 4187static void alc260_hp_3012_automute(struct hda_codec *codec) 4188{ 4189 unsigned int present, bits; 4190 4191 present = snd_hda_codec_read(codec, 0x10, 0, 4192 AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE; 4193 4194 bits = present ? 0 : PIN_OUT; 4195 snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4196 bits); 4197 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4198 bits); 4199 snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 4200 bits); 4201} 4202 4203static void alc260_hp_3012_unsol_event(struct hda_codec *codec, 4204 unsigned int res) 4205{ 4206 if ((res >> 26) == ALC880_HP_EVENT) 4207 alc260_hp_3012_automute(codec); 4208} 4209 4210/* Fujitsu S702x series laptops. ALC260 pin usage: Mic/Line jack = 0x12, 4211 * HP jack = 0x14, CD audio = 0x16, internal speaker = 0x10. 4212 */ 4213static struct snd_kcontrol_new alc260_fujitsu_mixer[] = { 4214 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4215 HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT), 4216 ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT), 4217 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 4218 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 4219 HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT), 4220 HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT), 4221 ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN), 4222 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT), 4223 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT), 4224 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT), 4225 HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT), 4226 { } /* end */ 4227}; 4228 4229/* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks. Note that current 4230 * versions of the ALC260 don't act on requests to enable mic bias from NID 4231 * 0x0f (used to drive the headphone jack in these laptops). The ALC260 4232 * datasheet doesn't mention this restriction. At this stage it's not clear 4233 * whether this behaviour is intentional or is a hardware bug in chip 4234 * revisions available in early 2006. Therefore for now allow the 4235 * "Headphone Jack Mode" control to span all choices, but if it turns out 4236 * that the lack of mic bias for this NID is intentional we could change the 4237 * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS. 4238 * 4239 * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006 4240 * don't appear to make the mic bias available from the "line" jack, even 4241 * though the NID used for this jack (0x14) can supply it. The theory is 4242 * that perhaps Acer have included blocking capacitors between the ALC260 4243 * and the output jack. If this turns out to be the case for all such 4244 * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT 4245 * to ALC_PIN_DIR_INOUT_NOMICBIAS. 4246 * 4247 * The C20x Tablet series have a mono internal speaker which is controlled 4248 * via the chip's Mono sum widget and pin complex, so include the necessary 4249 * controls for such models. On models without a "mono speaker" the control 4250 * won't do anything. 4251 */ 4252static struct snd_kcontrol_new alc260_acer_mixer[] = { 4253 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4254 HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT), 4255 ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT), 4256 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, 4257 HDA_OUTPUT), 4258 HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, 4259 HDA_INPUT), 4260 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 4261 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 4262 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT), 4263 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT), 4264 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN), 4265 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT), 4266 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT), 4267 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT), 4268 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT), 4269 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT), 4270 { } /* end */ 4271}; 4272 4273/* Packard bell V7900 ALC260 pin usage: HP = 0x0f, Mic jack = 0x12, 4274 * Line In jack = 0x14, CD audio = 0x16, pc beep = 0x17. 4275 */ 4276static struct snd_kcontrol_new alc260_will_mixer[] = { 4277 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4278 HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT), 4279 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT), 4280 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT), 4281 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN), 4282 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT), 4283 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT), 4284 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT), 4285 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 4286 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 4287 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT), 4288 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT), 4289 { } /* end */ 4290}; 4291 4292/* Replacer 672V ALC260 pin usage: Mic jack = 0x12, 4293 * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f. 4294 */ 4295static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = { 4296 HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4297 HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT), 4298 HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT), 4299 HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT), 4300 ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN), 4301 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT), 4302 HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT), 4303 HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT), 4304 HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT), 4305 ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT), 4306 { } /* end */ 4307}; 4308 4309/* capture mixer elements */ 4310static struct snd_kcontrol_new alc260_capture_mixer[] = { 4311 HDA_CODEC_VOLUME("Capture Volume", 0x04, 0x0, HDA_INPUT), 4312 HDA_CODEC_MUTE("Capture Switch", 0x04, 0x0, HDA_INPUT), 4313 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x05, 0x0, HDA_INPUT), 4314 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x05, 0x0, HDA_INPUT), 4315 { 4316 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4317 /* The multiple "Capture Source" controls confuse alsamixer 4318 * So call somewhat different.. 4319 */ 4320 /* .name = "Capture Source", */ 4321 .name = "Input Source", 4322 .count = 2, 4323 .info = alc_mux_enum_info, 4324 .get = alc_mux_enum_get, 4325 .put = alc_mux_enum_put, 4326 }, 4327 { } /* end */ 4328}; 4329 4330static struct snd_kcontrol_new alc260_capture_alt_mixer[] = { 4331 HDA_CODEC_VOLUME("Capture Volume", 0x05, 0x0, HDA_INPUT), 4332 HDA_CODEC_MUTE("Capture Switch", 0x05, 0x0, HDA_INPUT), 4333 { 4334 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4335 /* The multiple "Capture Source" controls confuse alsamixer 4336 * So call somewhat different.. 4337 */ 4338 /* .name = "Capture Source", */ 4339 .name = "Input Source", 4340 .count = 1, 4341 .info = alc_mux_enum_info, 4342 .get = alc_mux_enum_get, 4343 .put = alc_mux_enum_put, 4344 }, 4345 { } /* end */ 4346}; 4347 4348/* 4349 * initialization verbs 4350 */ 4351static struct hda_verb alc260_init_verbs[] = { 4352 /* Line In pin widget for input */ 4353 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 4354 /* CD pin widget for input */ 4355 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 4356 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 4357 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 4358 /* Mic2 (front panel) pin widget for input and vref at 80% */ 4359 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 4360 /* LINE-2 is used for line-out in rear */ 4361 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4362 /* select line-out */ 4363 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00}, 4364 /* LINE-OUT pin */ 4365 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4366 /* enable HP */ 4367 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 4368 /* enable Mono */ 4369 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4370 /* mute capture amp left and right */ 4371 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4372 /* set connection select to line in (default select for this ADC) */ 4373 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02}, 4374 /* mute capture amp left and right */ 4375 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4376 /* set connection select to line in (default select for this ADC) */ 4377 {0x05, AC_VERB_SET_CONNECT_SEL, 0x02}, 4378 /* set vol=0 Line-Out mixer amp left and right */ 4379 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4380 /* unmute pin widget amp left and right (no gain on this amp) */ 4381 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4382 /* set vol=0 HP mixer amp left and right */ 4383 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4384 /* unmute pin widget amp left and right (no gain on this amp) */ 4385 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4386 /* set vol=0 Mono mixer amp left and right */ 4387 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4388 /* unmute pin widget amp left and right (no gain on this amp) */ 4389 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4390 /* unmute LINE-2 out pin */ 4391 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4392 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & 4393 * Line In 2 = 0x03 4394 */ 4395 /* mute analog inputs */ 4396 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4397 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4398 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 4399 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 4400 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 4401 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */ 4402 /* mute Front out path */ 4403 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4404 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4405 /* mute Headphone out path */ 4406 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4407 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4408 /* mute Mono out path */ 4409 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4410 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4411 { } 4412}; 4413 4414#if 0 /* should be identical with alc260_init_verbs? */ 4415static struct hda_verb alc260_hp_init_verbs[] = { 4416 /* Headphone and output */ 4417 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 4418 /* mono output */ 4419 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 4420 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 4421 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 4422 /* Mic2 (front panel) pin widget for input and vref at 80% */ 4423 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 4424 /* Line In pin widget for input */ 4425 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 4426 /* Line-2 pin widget for output */ 4427 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 4428 /* CD pin widget for input */ 4429 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 4430 /* unmute amp left and right */ 4431 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000}, 4432 /* set connection select to line in (default select for this ADC) */ 4433 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02}, 4434 /* unmute Line-Out mixer amp left and right (volume = 0) */ 4435 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 4436 /* mute pin widget amp left and right (no gain on this amp) */ 4437 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 4438 /* unmute HP mixer amp left and right (volume = 0) */ 4439 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 4440 /* mute pin widget amp left and right (no gain on this amp) */ 4441 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 4442 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & 4443 * Line In 2 = 0x03 4444 */ 4445 /* mute analog inputs */ 4446 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4447 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4448 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 4449 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 4450 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 4451 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */ 4452 /* Unmute Front out path */ 4453 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4454 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4455 /* Unmute Headphone out path */ 4456 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4457 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4458 /* Unmute Mono out path */ 4459 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4460 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4461 { } 4462}; 4463#endif 4464 4465static struct hda_verb alc260_hp_3013_init_verbs[] = { 4466 /* Line out and output */ 4467 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 4468 /* mono output */ 4469 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 4470 /* Mic1 (rear panel) pin widget for input and vref at 80% */ 4471 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 4472 /* Mic2 (front panel) pin widget for input and vref at 80% */ 4473 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 4474 /* Line In pin widget for input */ 4475 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 4476 /* Headphone pin widget for output */ 4477 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 4478 /* CD pin widget for input */ 4479 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 4480 /* unmute amp left and right */ 4481 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000}, 4482 /* set connection select to line in (default select for this ADC) */ 4483 {0x04, AC_VERB_SET_CONNECT_SEL, 0x02}, 4484 /* unmute Line-Out mixer amp left and right (volume = 0) */ 4485 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 4486 /* mute pin widget amp left and right (no gain on this amp) */ 4487 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 4488 /* unmute HP mixer amp left and right (volume = 0) */ 4489 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 4490 /* mute pin widget amp left and right (no gain on this amp) */ 4491 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 4492 /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & 4493 * Line In 2 = 0x03 4494 */ 4495 /* mute analog inputs */ 4496 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4497 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4498 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 4499 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 4500 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 4501 /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */ 4502 /* Unmute Front out path */ 4503 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4504 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4505 /* Unmute Headphone out path */ 4506 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4507 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4508 /* Unmute Mono out path */ 4509 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 4510 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 4511 { } 4512}; 4513 4514/* Initialisation sequence for ALC260 as configured in Fujitsu S702x 4515 * laptops. ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD 4516 * audio = 0x16, internal speaker = 0x10. 4517 */ 4518static struct hda_verb alc260_fujitsu_init_verbs[] = { 4519 /* Disable all GPIOs */ 4520 {0x01, AC_VERB_SET_GPIO_MASK, 0}, 4521 /* Internal speaker is connected to headphone pin */ 4522 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 4523 /* Headphone/Line-out jack connects to Line1 pin; make it an output */ 4524 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4525 /* Mic/Line-in jack is connected to mic1 pin, so make it an input */ 4526 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 4527 /* Ensure all other unused pins are disabled and muted. */ 4528 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 4529 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4530 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 4531 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4532 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 4533 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4534 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 4535 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4536 4537 /* Disable digital (SPDIF) pins */ 4538 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0}, 4539 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0}, 4540 4541 /* Ensure Line1 pin widget takes its input from the OUT1 sum bus 4542 * when acting as an output. 4543 */ 4544 {0x0d, AC_VERB_SET_CONNECT_SEL, 0}, 4545 4546 /* Start with output sum widgets muted and their output gains at min */ 4547 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4548 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4549 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4550 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4551 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4552 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4553 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4554 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4555 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4556 4557 /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */ 4558 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4559 /* Unmute Line1 pin widget output buffer since it starts as an output. 4560 * If the pin mode is changed by the user the pin mode control will 4561 * take care of enabling the pin's input/output buffers as needed. 4562 * Therefore there's no need to enable the input buffer at this 4563 * stage. 4564 */ 4565 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4566 /* Unmute input buffer of pin widget used for Line-in (no equiv 4567 * mixer ctrl) 4568 */ 4569 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4570 4571 /* Mute capture amp left and right */ 4572 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4573 /* Set ADC connection select to match default mixer setting - line 4574 * in (on mic1 pin) 4575 */ 4576 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00}, 4577 4578 /* Do the same for the second ADC: mute capture input amp and 4579 * set ADC connection to line in (on mic1 pin) 4580 */ 4581 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4582 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00}, 4583 4584 /* Mute all inputs to mixer widget (even unconnected ones) */ 4585 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */ 4586 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */ 4587 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */ 4588 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */ 4589 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */ 4590 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */ 4591 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */ 4592 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */ 4593 4594 { } 4595}; 4596 4597/* Initialisation sequence for ALC260 as configured in Acer TravelMate and 4598 * similar laptops (adapted from Fujitsu init verbs). 4599 */ 4600static struct hda_verb alc260_acer_init_verbs[] = { 4601 /* On TravelMate laptops, GPIO 0 enables the internal speaker and 4602 * the headphone jack. Turn this on and rely on the standard mute 4603 * methods whenever the user wants to turn these outputs off. 4604 */ 4605 {0x01, AC_VERB_SET_GPIO_MASK, 0x01}, 4606 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, 4607 {0x01, AC_VERB_SET_GPIO_DATA, 0x01}, 4608 /* Internal speaker/Headphone jack is connected to Line-out pin */ 4609 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 4610 /* Internal microphone/Mic jack is connected to Mic1 pin */ 4611 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50}, 4612 /* Line In jack is connected to Line1 pin */ 4613 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 4614 /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */ 4615 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 4616 /* Ensure all other unused pins are disabled and muted. */ 4617 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 4618 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4619 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 4620 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4621 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 4622 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4623 /* Disable digital (SPDIF) pins */ 4624 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0}, 4625 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0}, 4626 4627 /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum 4628 * bus when acting as outputs. 4629 */ 4630 {0x0b, AC_VERB_SET_CONNECT_SEL, 0}, 4631 {0x0d, AC_VERB_SET_CONNECT_SEL, 0}, 4632 4633 /* Start with output sum widgets muted and their output gains at min */ 4634 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4635 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4636 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4637 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4638 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4639 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4640 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4641 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4642 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4643 4644 /* Unmute Line-out pin widget amp left and right 4645 * (no equiv mixer ctrl) 4646 */ 4647 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4648 /* Unmute mono pin widget amp output (no equiv mixer ctrl) */ 4649 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4650 /* Unmute Mic1 and Line1 pin widget input buffers since they start as 4651 * inputs. If the pin mode is changed by the user the pin mode control 4652 * will take care of enabling the pin's input/output buffers as needed. 4653 * Therefore there's no need to enable the input buffer at this 4654 * stage. 4655 */ 4656 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4657 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4658 4659 /* Mute capture amp left and right */ 4660 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4661 /* Set ADC connection select to match default mixer setting - mic 4662 * (on mic1 pin) 4663 */ 4664 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00}, 4665 4666 /* Do similar with the second ADC: mute capture input amp and 4667 * set ADC connection to mic to match ALSA's default state. 4668 */ 4669 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4670 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00}, 4671 4672 /* Mute all inputs to mixer widget (even unconnected ones) */ 4673 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */ 4674 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */ 4675 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */ 4676 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */ 4677 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */ 4678 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */ 4679 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */ 4680 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */ 4681 4682 { } 4683}; 4684 4685static struct hda_verb alc260_will_verbs[] = { 4686 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 4687 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00}, 4688 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00}, 4689 {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02}, 4690 {0x1a, AC_VERB_SET_COEF_INDEX, 0x07}, 4691 {0x1a, AC_VERB_SET_PROC_COEF, 0x3040}, 4692 {} 4693}; 4694 4695static struct hda_verb alc260_replacer_672v_verbs[] = { 4696 {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02}, 4697 {0x1a, AC_VERB_SET_COEF_INDEX, 0x07}, 4698 {0x1a, AC_VERB_SET_PROC_COEF, 0x3050}, 4699 4700 {0x01, AC_VERB_SET_GPIO_MASK, 0x01}, 4701 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, 4702 {0x01, AC_VERB_SET_GPIO_DATA, 0x00}, 4703 4704 {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 4705 {} 4706}; 4707 4708/* toggle speaker-output according to the hp-jack state */ 4709static void alc260_replacer_672v_automute(struct hda_codec *codec) 4710{ 4711 unsigned int present; 4712 4713 /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */ 4714 present = snd_hda_codec_read(codec, 0x0f, 0, 4715 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 4716 if (present) { 4717 snd_hda_codec_write_cache(codec, 0x01, 0, 4718 AC_VERB_SET_GPIO_DATA, 1); 4719 snd_hda_codec_write_cache(codec, 0x0f, 0, 4720 AC_VERB_SET_PIN_WIDGET_CONTROL, 4721 PIN_HP); 4722 } else { 4723 snd_hda_codec_write_cache(codec, 0x01, 0, 4724 AC_VERB_SET_GPIO_DATA, 0); 4725 snd_hda_codec_write_cache(codec, 0x0f, 0, 4726 AC_VERB_SET_PIN_WIDGET_CONTROL, 4727 PIN_OUT); 4728 } 4729} 4730 4731static void alc260_replacer_672v_unsol_event(struct hda_codec *codec, 4732 unsigned int res) 4733{ 4734 if ((res >> 26) == ALC880_HP_EVENT) 4735 alc260_replacer_672v_automute(codec); 4736} 4737 4738static struct hda_verb alc260_hp_dc7600_verbs[] = { 4739 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01}, 4740 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 4741 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4742 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 4743 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4744 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4745 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 4746 {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 4747 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 4748 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 4749 {} 4750}; 4751 4752/* Test configuration for debugging, modelled after the ALC880 test 4753 * configuration. 4754 */ 4755#ifdef CONFIG_SND_DEBUG 4756static hda_nid_t alc260_test_dac_nids[1] = { 4757 0x02, 4758}; 4759static hda_nid_t alc260_test_adc_nids[2] = { 4760 0x04, 0x05, 4761}; 4762/* For testing the ALC260, each input MUX needs its own definition since 4763 * the signal assignments are different. This assumes that the first ADC 4764 * is NID 0x04. 4765 */ 4766static struct hda_input_mux alc260_test_capture_sources[2] = { 4767 { 4768 .num_items = 7, 4769 .items = { 4770 { "MIC1 pin", 0x0 }, 4771 { "MIC2 pin", 0x1 }, 4772 { "LINE1 pin", 0x2 }, 4773 { "LINE2 pin", 0x3 }, 4774 { "CD pin", 0x4 }, 4775 { "LINE-OUT pin", 0x5 }, 4776 { "HP-OUT pin", 0x6 }, 4777 }, 4778 }, 4779 { 4780 .num_items = 8, 4781 .items = { 4782 { "MIC1 pin", 0x0 }, 4783 { "MIC2 pin", 0x1 }, 4784 { "LINE1 pin", 0x2 }, 4785 { "LINE2 pin", 0x3 }, 4786 { "CD pin", 0x4 }, 4787 { "Mixer", 0x5 }, 4788 { "LINE-OUT pin", 0x6 }, 4789 { "HP-OUT pin", 0x7 }, 4790 }, 4791 }, 4792}; 4793static struct snd_kcontrol_new alc260_test_mixer[] = { 4794 /* Output driver widgets */ 4795 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT), 4796 HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT), 4797 HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT), 4798 HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT), 4799 HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT), 4800 HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT), 4801 4802 /* Modes for retasking pin widgets 4803 * Note: the ALC260 doesn't seem to act on requests to enable mic 4804 * bias from NIDs 0x0f and 0x10. The ALC260 datasheet doesn't 4805 * mention this restriction. At this stage it's not clear whether 4806 * this behaviour is intentional or is a hardware bug in chip 4807 * revisions available at least up until early 2006. Therefore for 4808 * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all 4809 * choices, but if it turns out that the lack of mic bias for these 4810 * NIDs is intentional we could change their modes from 4811 * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS. 4812 */ 4813 ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT), 4814 ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT), 4815 ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT), 4816 ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT), 4817 ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT), 4818 ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT), 4819 4820 /* Loopback mixer controls */ 4821 HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT), 4822 HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT), 4823 HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT), 4824 HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT), 4825 HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT), 4826 HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT), 4827 HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT), 4828 HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT), 4829 HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), 4830 HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), 4831 HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT), 4832 HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT), 4833 HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT), 4834 HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT), 4835 HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT), 4836 HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT), 4837 4838 /* Controls for GPIO pins, assuming they are configured as outputs */ 4839 ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01), 4840 ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02), 4841 ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04), 4842 ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08), 4843 4844 /* Switches to allow the digital IO pins to be enabled. The datasheet 4845 * is ambigious as to which NID is which; testing on laptops which 4846 * make this output available should provide clarification. 4847 */ 4848 ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01), 4849 ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01), 4850 4851 /* A switch allowing EAPD to be enabled. Some laptops seem to use 4852 * this output to turn on an external amplifier. 4853 */ 4854 ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02), 4855 ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02), 4856 4857 { } /* end */ 4858}; 4859static struct hda_verb alc260_test_init_verbs[] = { 4860 /* Enable all GPIOs as outputs with an initial value of 0 */ 4861 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f}, 4862 {0x01, AC_VERB_SET_GPIO_DATA, 0x00}, 4863 {0x01, AC_VERB_SET_GPIO_MASK, 0x0f}, 4864 4865 /* Enable retasking pins as output, initially without power amp */ 4866 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4867 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4868 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4869 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4870 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4871 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4872 4873 /* Disable digital (SPDIF) pins initially, but users can enable 4874 * them via a mixer switch. In the case of SPDIF-out, this initverb 4875 * payload also sets the generation to 0, output to be in "consumer" 4876 * PCM format, copyright asserted, no pre-emphasis and no validity 4877 * control. 4878 */ 4879 {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0}, 4880 {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0}, 4881 4882 /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the 4883 * OUT1 sum bus when acting as an output. 4884 */ 4885 {0x0b, AC_VERB_SET_CONNECT_SEL, 0}, 4886 {0x0c, AC_VERB_SET_CONNECT_SEL, 0}, 4887 {0x0d, AC_VERB_SET_CONNECT_SEL, 0}, 4888 {0x0e, AC_VERB_SET_CONNECT_SEL, 0}, 4889 4890 /* Start with output sum widgets muted and their output gains at min */ 4891 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4892 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4893 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4894 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4895 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4896 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4897 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4898 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4899 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4900 4901 /* Unmute retasking pin widget output buffers since the default 4902 * state appears to be output. As the pin mode is changed by the 4903 * user the pin mode control will take care of enabling the pin's 4904 * input/output buffers as needed. 4905 */ 4906 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4907 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4908 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4909 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4910 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4911 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4912 /* Also unmute the mono-out pin widget */ 4913 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4914 4915 /* Mute capture amp left and right */ 4916 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4917 /* Set ADC connection select to match default mixer setting (mic1 4918 * pin) 4919 */ 4920 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00}, 4921 4922 /* Do the same for the second ADC: mute capture input amp and 4923 * set ADC connection to mic1 pin 4924 */ 4925 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4926 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00}, 4927 4928 /* Mute all inputs to mixer widget (even unconnected ones) */ 4929 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */ 4930 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */ 4931 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */ 4932 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */ 4933 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */ 4934 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */ 4935 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */ 4936 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */ 4937 4938 { } 4939}; 4940#endif 4941 4942#define alc260_pcm_analog_playback alc880_pcm_analog_alt_playback 4943#define alc260_pcm_analog_capture alc880_pcm_analog_capture 4944 4945#define alc260_pcm_digital_playback alc880_pcm_digital_playback 4946#define alc260_pcm_digital_capture alc880_pcm_digital_capture 4947 4948/* 4949 * for BIOS auto-configuration 4950 */ 4951 4952static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid, 4953 const char *pfx) 4954{ 4955 hda_nid_t nid_vol; 4956 unsigned long vol_val, sw_val; 4957 char name[32]; 4958 int err; 4959 4960 if (nid >= 0x0f && nid < 0x11) { 4961 nid_vol = nid - 0x7; 4962 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT); 4963 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 4964 } else if (nid == 0x11) { 4965 nid_vol = nid - 0x7; 4966 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT); 4967 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT); 4968 } else if (nid >= 0x12 && nid <= 0x15) { 4969 nid_vol = 0x08; 4970 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT); 4971 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 4972 } else 4973 return 0; /* N/A */ 4974 4975 snprintf(name, sizeof(name), "%s Playback Volume", pfx); 4976 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val); 4977 if (err < 0) 4978 return err; 4979 snprintf(name, sizeof(name), "%s Playback Switch", pfx); 4980 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val); 4981 if (err < 0) 4982 return err; 4983 return 1; 4984} 4985 4986/* add playback controls from the parsed DAC table */ 4987static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec, 4988 const struct auto_pin_cfg *cfg) 4989{ 4990 hda_nid_t nid; 4991 int err; 4992 4993 spec->multiout.num_dacs = 1; 4994 spec->multiout.dac_nids = spec->private_dac_nids; 4995 spec->multiout.dac_nids[0] = 0x02; 4996 4997 nid = cfg->line_out_pins[0]; 4998 if (nid) { 4999 err = alc260_add_playback_controls(spec, nid, "Front"); 5000 if (err < 0) 5001 return err; 5002 } 5003 5004 nid = cfg->speaker_pins[0]; 5005 if (nid) { 5006 err = alc260_add_playback_controls(spec, nid, "Speaker"); 5007 if (err < 0) 5008 return err; 5009 } 5010 5011 nid = cfg->hp_pins[0]; 5012 if (nid) { 5013 err = alc260_add_playback_controls(spec, nid, "Headphone"); 5014 if (err < 0) 5015 return err; 5016 } 5017 return 0; 5018} 5019 5020/* create playback/capture controls for input pins */ 5021static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec, 5022 const struct auto_pin_cfg *cfg) 5023{ 5024 struct hda_input_mux *imux = &spec->private_imux; 5025 int i, err, idx; 5026 5027 for (i = 0; i < AUTO_PIN_LAST; i++) { 5028 if (cfg->input_pins[i] >= 0x12) { 5029 idx = cfg->input_pins[i] - 0x12; 5030 err = new_analog_input(spec, cfg->input_pins[i], 5031 auto_pin_cfg_labels[i], idx, 5032 0x07); 5033 if (err < 0) 5034 return err; 5035 imux->items[imux->num_items].label = 5036 auto_pin_cfg_labels[i]; 5037 imux->items[imux->num_items].index = idx; 5038 imux->num_items++; 5039 } 5040 if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){ 5041 idx = cfg->input_pins[i] - 0x09; 5042 err = new_analog_input(spec, cfg->input_pins[i], 5043 auto_pin_cfg_labels[i], idx, 5044 0x07); 5045 if (err < 0) 5046 return err; 5047 imux->items[imux->num_items].label = 5048 auto_pin_cfg_labels[i]; 5049 imux->items[imux->num_items].index = idx; 5050 imux->num_items++; 5051 } 5052 } 5053 return 0; 5054} 5055 5056static void alc260_auto_set_output_and_unmute(struct hda_codec *codec, 5057 hda_nid_t nid, int pin_type, 5058 int sel_idx) 5059{ 5060 alc_set_pin_output(codec, nid, pin_type); 5061 /* need the manual connection? */ 5062 if (nid >= 0x12) { 5063 int idx = nid - 0x12; 5064 snd_hda_codec_write(codec, idx + 0x0b, 0, 5065 AC_VERB_SET_CONNECT_SEL, sel_idx); 5066 } 5067} 5068 5069static void alc260_auto_init_multi_out(struct hda_codec *codec) 5070{ 5071 struct alc_spec *spec = codec->spec; 5072 hda_nid_t nid; 5073 5074 alc_subsystem_id(codec, 0x10, 0x15, 0x0f); 5075 nid = spec->autocfg.line_out_pins[0]; 5076 if (nid) { 5077 int pin_type = get_pin_type(spec->autocfg.line_out_type); 5078 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0); 5079 } 5080 5081 nid = spec->autocfg.speaker_pins[0]; 5082 if (nid) 5083 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0); 5084 5085 nid = spec->autocfg.hp_pins[0]; 5086 if (nid) 5087 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0); 5088} 5089 5090#define ALC260_PIN_CD_NID 0x16 5091static void alc260_auto_init_analog_input(struct hda_codec *codec) 5092{ 5093 struct alc_spec *spec = codec->spec; 5094 int i; 5095 5096 for (i = 0; i < AUTO_PIN_LAST; i++) { 5097 hda_nid_t nid = spec->autocfg.input_pins[i]; 5098 if (nid >= 0x12) { 5099 snd_hda_codec_write(codec, nid, 0, 5100 AC_VERB_SET_PIN_WIDGET_CONTROL, 5101 i <= AUTO_PIN_FRONT_MIC ? 5102 PIN_VREF80 : PIN_IN); 5103 if (nid != ALC260_PIN_CD_NID) 5104 snd_hda_codec_write(codec, nid, 0, 5105 AC_VERB_SET_AMP_GAIN_MUTE, 5106 AMP_OUT_MUTE); 5107 } 5108 } 5109} 5110 5111/* 5112 * generic initialization of ADC, input mixers and output mixers 5113 */ 5114static struct hda_verb alc260_volume_init_verbs[] = { 5115 /* 5116 * Unmute ADC0-1 and set the default input to mic-in 5117 */ 5118 {0x04, AC_VERB_SET_CONNECT_SEL, 0x00}, 5119 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5120 {0x05, AC_VERB_SET_CONNECT_SEL, 0x00}, 5121 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5122 5123 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 5124 * mixer widget 5125 * Note: PASD motherboards uses the Line In 2 as the input for 5126 * front panel mic (mic 2) 5127 */ 5128 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 5129 /* mute analog inputs */ 5130 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5131 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5132 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5133 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5134 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5135 5136 /* 5137 * Set up output mixers (0x08 - 0x0a) 5138 */ 5139 /* set vol=0 to output mixers */ 5140 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5141 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5142 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5143 /* set up input amps for analog loopback */ 5144 /* Amp Indices: DAC = 0, mixer = 1 */ 5145 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5146 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5147 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5148 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5149 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5150 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5151 5152 { } 5153}; 5154 5155static int alc260_parse_auto_config(struct hda_codec *codec) 5156{ 5157 struct alc_spec *spec = codec->spec; 5158 unsigned int wcap; 5159 int err; 5160 static hda_nid_t alc260_ignore[] = { 0x17, 0 }; 5161 5162 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 5163 alc260_ignore); 5164 if (err < 0) 5165 return err; 5166 err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg); 5167 if (err < 0) 5168 return err; 5169 if (!spec->kctl_alloc) 5170 return 0; /* can't find valid BIOS pin config */ 5171 err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg); 5172 if (err < 0) 5173 return err; 5174 5175 spec->multiout.max_channels = 2; 5176 5177 if (spec->autocfg.dig_out_pin) 5178 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID; 5179 if (spec->kctl_alloc) 5180 spec->mixers[spec->num_mixers++] = spec->kctl_alloc; 5181 5182 spec->init_verbs[spec->num_init_verbs++] = alc260_volume_init_verbs; 5183 5184 spec->num_mux_defs = 1; 5185 spec->input_mux = &spec->private_imux; 5186 5187 /* check whether NID 0x04 is valid */ 5188 wcap = get_wcaps(codec, 0x04); 5189 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */ 5190 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) { 5191 spec->adc_nids = alc260_adc_nids_alt; 5192 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt); 5193 spec->mixers[spec->num_mixers] = alc260_capture_alt_mixer; 5194 } else { 5195 spec->adc_nids = alc260_adc_nids; 5196 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids); 5197 spec->mixers[spec->num_mixers] = alc260_capture_mixer; 5198 } 5199 spec->num_mixers++; 5200 5201 return 1; 5202} 5203 5204/* additional initialization for auto-configuration model */ 5205static void alc260_auto_init(struct hda_codec *codec) 5206{ 5207 struct alc_spec *spec = codec->spec; 5208 alc260_auto_init_multi_out(codec); 5209 alc260_auto_init_analog_input(codec); 5210 if (spec->unsol_event) 5211 alc_sku_automute(codec); 5212} 5213 5214#ifdef CONFIG_SND_HDA_POWER_SAVE 5215static struct hda_amp_list alc260_loopbacks[] = { 5216 { 0x07, HDA_INPUT, 0 }, 5217 { 0x07, HDA_INPUT, 1 }, 5218 { 0x07, HDA_INPUT, 2 }, 5219 { 0x07, HDA_INPUT, 3 }, 5220 { 0x07, HDA_INPUT, 4 }, 5221 { } /* end */ 5222}; 5223#endif 5224 5225/* 5226 * ALC260 configurations 5227 */ 5228static const char *alc260_models[ALC260_MODEL_LAST] = { 5229 [ALC260_BASIC] = "basic", 5230 [ALC260_HP] = "hp", 5231 [ALC260_HP_3013] = "hp-3013", 5232 [ALC260_FUJITSU_S702X] = "fujitsu", 5233 [ALC260_ACER] = "acer", 5234 [ALC260_WILL] = "will", 5235 [ALC260_REPLACER_672V] = "replacer", 5236#ifdef CONFIG_SND_DEBUG 5237 [ALC260_TEST] = "test", 5238#endif 5239 [ALC260_AUTO] = "auto", 5240}; 5241 5242static struct snd_pci_quirk alc260_cfg_tbl[] = { 5243 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER), 5244 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER), 5245 SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013), 5246 SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013), 5247 SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013), 5248 SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013), 5249 SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600), 5250 SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013), 5251 SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP), 5252 SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP), 5253 SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP), 5254 SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC), 5255 SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC), 5256 SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC), 5257 SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X), 5258 SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC), 5259 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V), 5260 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL), 5261 {} 5262}; 5263 5264static struct alc_config_preset alc260_presets[] = { 5265 [ALC260_BASIC] = { 5266 .mixers = { alc260_base_output_mixer, 5267 alc260_input_mixer, 5268 alc260_pc_beep_mixer, 5269 alc260_capture_mixer }, 5270 .init_verbs = { alc260_init_verbs }, 5271 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5272 .dac_nids = alc260_dac_nids, 5273 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids), 5274 .adc_nids = alc260_adc_nids, 5275 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5276 .channel_mode = alc260_modes, 5277 .input_mux = &alc260_capture_source, 5278 }, 5279 [ALC260_HP] = { 5280 .mixers = { alc260_hp_output_mixer, 5281 alc260_input_mixer, 5282 alc260_capture_alt_mixer }, 5283 .init_verbs = { alc260_init_verbs, 5284 alc260_hp_unsol_verbs }, 5285 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5286 .dac_nids = alc260_dac_nids, 5287 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids), 5288 .adc_nids = alc260_hp_adc_nids, 5289 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5290 .channel_mode = alc260_modes, 5291 .input_mux = &alc260_capture_source, 5292 .unsol_event = alc260_hp_unsol_event, 5293 .init_hook = alc260_hp_automute, 5294 }, 5295 [ALC260_HP_DC7600] = { 5296 .mixers = { alc260_hp_dc7600_mixer, 5297 alc260_input_mixer, 5298 alc260_capture_alt_mixer }, 5299 .init_verbs = { alc260_init_verbs, 5300 alc260_hp_dc7600_verbs }, 5301 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5302 .dac_nids = alc260_dac_nids, 5303 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids), 5304 .adc_nids = alc260_hp_adc_nids, 5305 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5306 .channel_mode = alc260_modes, 5307 .input_mux = &alc260_capture_source, 5308 .unsol_event = alc260_hp_3012_unsol_event, 5309 .init_hook = alc260_hp_3012_automute, 5310 }, 5311 [ALC260_HP_3013] = { 5312 .mixers = { alc260_hp_3013_mixer, 5313 alc260_input_mixer, 5314 alc260_capture_alt_mixer }, 5315 .init_verbs = { alc260_hp_3013_init_verbs, 5316 alc260_hp_3013_unsol_verbs }, 5317 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5318 .dac_nids = alc260_dac_nids, 5319 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids), 5320 .adc_nids = alc260_hp_adc_nids, 5321 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5322 .channel_mode = alc260_modes, 5323 .input_mux = &alc260_capture_source, 5324 .unsol_event = alc260_hp_3013_unsol_event, 5325 .init_hook = alc260_hp_3013_automute, 5326 }, 5327 [ALC260_FUJITSU_S702X] = { 5328 .mixers = { alc260_fujitsu_mixer, 5329 alc260_capture_mixer }, 5330 .init_verbs = { alc260_fujitsu_init_verbs }, 5331 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5332 .dac_nids = alc260_dac_nids, 5333 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids), 5334 .adc_nids = alc260_dual_adc_nids, 5335 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5336 .channel_mode = alc260_modes, 5337 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources), 5338 .input_mux = alc260_fujitsu_capture_sources, 5339 }, 5340 [ALC260_ACER] = { 5341 .mixers = { alc260_acer_mixer, 5342 alc260_capture_mixer }, 5343 .init_verbs = { alc260_acer_init_verbs }, 5344 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5345 .dac_nids = alc260_dac_nids, 5346 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids), 5347 .adc_nids = alc260_dual_adc_nids, 5348 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5349 .channel_mode = alc260_modes, 5350 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources), 5351 .input_mux = alc260_acer_capture_sources, 5352 }, 5353 [ALC260_WILL] = { 5354 .mixers = { alc260_will_mixer, 5355 alc260_capture_mixer }, 5356 .init_verbs = { alc260_init_verbs, alc260_will_verbs }, 5357 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5358 .dac_nids = alc260_dac_nids, 5359 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids), 5360 .adc_nids = alc260_adc_nids, 5361 .dig_out_nid = ALC260_DIGOUT_NID, 5362 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5363 .channel_mode = alc260_modes, 5364 .input_mux = &alc260_capture_source, 5365 }, 5366 [ALC260_REPLACER_672V] = { 5367 .mixers = { alc260_replacer_672v_mixer, 5368 alc260_capture_mixer }, 5369 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs }, 5370 .num_dacs = ARRAY_SIZE(alc260_dac_nids), 5371 .dac_nids = alc260_dac_nids, 5372 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids), 5373 .adc_nids = alc260_adc_nids, 5374 .dig_out_nid = ALC260_DIGOUT_NID, 5375 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5376 .channel_mode = alc260_modes, 5377 .input_mux = &alc260_capture_source, 5378 .unsol_event = alc260_replacer_672v_unsol_event, 5379 .init_hook = alc260_replacer_672v_automute, 5380 }, 5381#ifdef CONFIG_SND_DEBUG 5382 [ALC260_TEST] = { 5383 .mixers = { alc260_test_mixer, 5384 alc260_capture_mixer }, 5385 .init_verbs = { alc260_test_init_verbs }, 5386 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids), 5387 .dac_nids = alc260_test_dac_nids, 5388 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids), 5389 .adc_nids = alc260_test_adc_nids, 5390 .num_channel_mode = ARRAY_SIZE(alc260_modes), 5391 .channel_mode = alc260_modes, 5392 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources), 5393 .input_mux = alc260_test_capture_sources, 5394 }, 5395#endif 5396}; 5397 5398static int patch_alc260(struct hda_codec *codec) 5399{ 5400 struct alc_spec *spec; 5401 int err, board_config; 5402 5403 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5404 if (spec == NULL) 5405 return -ENOMEM; 5406 5407 codec->spec = spec; 5408 5409 board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST, 5410 alc260_models, 5411 alc260_cfg_tbl); 5412 if (board_config < 0) { 5413 snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260, " 5414 "trying auto-probe from BIOS...\n"); 5415 board_config = ALC260_AUTO; 5416 } 5417 5418 if (board_config == ALC260_AUTO) { 5419 /* automatic parse from the BIOS config */ 5420 err = alc260_parse_auto_config(codec); 5421 if (err < 0) { 5422 alc_free(codec); 5423 return err; 5424 } else if (!err) { 5425 printk(KERN_INFO 5426 "hda_codec: Cannot set up configuration " 5427 "from BIOS. Using base mode...\n"); 5428 board_config = ALC260_BASIC; 5429 } 5430 } 5431 5432 if (board_config != ALC260_AUTO) 5433 setup_preset(spec, &alc260_presets[board_config]); 5434 5435 spec->stream_name_analog = "ALC260 Analog"; 5436 spec->stream_analog_playback = &alc260_pcm_analog_playback; 5437 spec->stream_analog_capture = &alc260_pcm_analog_capture; 5438 5439 spec->stream_name_digital = "ALC260 Digital"; 5440 spec->stream_digital_playback = &alc260_pcm_digital_playback; 5441 spec->stream_digital_capture = &alc260_pcm_digital_capture; 5442 5443 spec->vmaster_nid = 0x08; 5444 5445 codec->patch_ops = alc_patch_ops; 5446 if (board_config == ALC260_AUTO) 5447 spec->init_hook = alc260_auto_init; 5448#ifdef CONFIG_SND_HDA_POWER_SAVE 5449 if (!spec->loopback.amplist) 5450 spec->loopback.amplist = alc260_loopbacks; 5451#endif 5452 5453 return 0; 5454} 5455 5456 5457/* 5458 * ALC882 support 5459 * 5460 * ALC882 is almost identical with ALC880 but has cleaner and more flexible 5461 * configuration. Each pin widget can choose any input DACs and a mixer. 5462 * Each ADC is connected from a mixer of all inputs. This makes possible 5463 * 6-channel independent captures. 5464 * 5465 * In addition, an independent DAC for the multi-playback (not used in this 5466 * driver yet). 5467 */ 5468#define ALC882_DIGOUT_NID 0x06 5469#define ALC882_DIGIN_NID 0x0a 5470 5471static struct hda_channel_mode alc882_ch_modes[1] = { 5472 { 8, NULL } 5473}; 5474 5475static hda_nid_t alc882_dac_nids[4] = { 5476 /* front, rear, clfe, rear_surr */ 5477 0x02, 0x03, 0x04, 0x05 5478}; 5479 5480/* identical with ALC880 */ 5481#define alc882_adc_nids alc880_adc_nids 5482#define alc882_adc_nids_alt alc880_adc_nids_alt 5483 5484static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 }; 5485static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 }; 5486 5487/* input MUX */ 5488/* FIXME: should be a matrix-type input source selection */ 5489 5490static struct hda_input_mux alc882_capture_source = { 5491 .num_items = 4, 5492 .items = { 5493 { "Mic", 0x0 }, 5494 { "Front Mic", 0x1 }, 5495 { "Line", 0x2 }, 5496 { "CD", 0x4 }, 5497 }, 5498}; 5499#define alc882_mux_enum_info alc_mux_enum_info 5500#define alc882_mux_enum_get alc_mux_enum_get 5501 5502static int alc882_mux_enum_put(struct snd_kcontrol *kcontrol, 5503 struct snd_ctl_elem_value *ucontrol) 5504{ 5505 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 5506 struct alc_spec *spec = codec->spec; 5507 const struct hda_input_mux *imux = spec->input_mux; 5508 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 5509 hda_nid_t nid = spec->capsrc_nids ? 5510 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx]; 5511 unsigned int *cur_val = &spec->cur_mux[adc_idx]; 5512 unsigned int i, idx; 5513 5514 idx = ucontrol->value.enumerated.item[0]; 5515 if (idx >= imux->num_items) 5516 idx = imux->num_items - 1; 5517 if (*cur_val == idx) 5518 return 0; 5519 for (i = 0; i < imux->num_items; i++) { 5520 unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE; 5521 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 5522 imux->items[i].index, 5523 HDA_AMP_MUTE, v); 5524 } 5525 *cur_val = idx; 5526 return 1; 5527} 5528 5529/* 5530 * 2ch mode 5531 */ 5532static struct hda_verb alc882_3ST_ch2_init[] = { 5533 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 5534 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 5535 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 5536 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 5537 { } /* end */ 5538}; 5539 5540/* 5541 * 6ch mode 5542 */ 5543static struct hda_verb alc882_3ST_ch6_init[] = { 5544 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 5545 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 5546 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 }, 5547 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 5548 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 5549 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 5550 { } /* end */ 5551}; 5552 5553static struct hda_channel_mode alc882_3ST_6ch_modes[2] = { 5554 { 2, alc882_3ST_ch2_init }, 5555 { 6, alc882_3ST_ch6_init }, 5556}; 5557 5558/* 5559 * 6ch mode 5560 */ 5561static struct hda_verb alc882_sixstack_ch6_init[] = { 5562 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 5563 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 5564 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 5565 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 5566 { } /* end */ 5567}; 5568 5569/* 5570 * 8ch mode 5571 */ 5572static struct hda_verb alc882_sixstack_ch8_init[] = { 5573 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 5574 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 5575 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 5576 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 5577 { } /* end */ 5578}; 5579 5580static struct hda_channel_mode alc882_sixstack_modes[2] = { 5581 { 6, alc882_sixstack_ch6_init }, 5582 { 8, alc882_sixstack_ch8_init }, 5583}; 5584 5585/* 5586 * macbook pro ALC885 can switch LineIn to LineOut without loosing Mic 5587 */ 5588 5589/* 5590 * 2ch mode 5591 */ 5592static struct hda_verb alc885_mbp_ch2_init[] = { 5593 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 5594 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5595 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5596 { } /* end */ 5597}; 5598 5599/* 5600 * 6ch mode 5601 */ 5602static struct hda_verb alc885_mbp_ch6_init[] = { 5603 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 5604 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5605 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 5606 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5607 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5608 { } /* end */ 5609}; 5610 5611static struct hda_channel_mode alc885_mbp_6ch_modes[2] = { 5612 { 2, alc885_mbp_ch2_init }, 5613 { 6, alc885_mbp_ch6_init }, 5614}; 5615 5616 5617/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17 5618 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b 5619 */ 5620static struct snd_kcontrol_new alc882_base_mixer[] = { 5621 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 5622 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 5623 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 5624 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 5625 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 5626 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 5627 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 5628 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 5629 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 5630 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 5631 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 5632 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 5633 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 5634 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 5635 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 5636 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 5637 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 5638 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 5639 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 5640 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 5641 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 5642 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 5643 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 5644 { } /* end */ 5645}; 5646 5647static struct snd_kcontrol_new alc885_mbp3_mixer[] = { 5648 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT), 5649 HDA_BIND_MUTE ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT), 5650 HDA_CODEC_MUTE ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT), 5651 HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT), 5652 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 5653 HDA_CODEC_MUTE ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 5654 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT), 5655 HDA_CODEC_MUTE ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT), 5656 HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT), 5657 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT), 5658 { } /* end */ 5659}; 5660static struct snd_kcontrol_new alc882_w2jc_mixer[] = { 5661 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 5662 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 5663 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 5664 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 5665 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 5666 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 5667 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 5668 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 5669 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 5670 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 5671 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 5672 { } /* end */ 5673}; 5674 5675static struct snd_kcontrol_new alc882_targa_mixer[] = { 5676 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 5677 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 5678 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 5679 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 5680 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 5681 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 5682 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 5683 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 5684 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 5685 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 5686 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 5687 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 5688 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 5689 { } /* end */ 5690}; 5691 5692/* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ??? 5693 * Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c 5694 */ 5695static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = { 5696 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 5697 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 5698 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 5699 HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT), 5700 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 5701 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 5702 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 5703 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 5704 HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT), 5705 HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT), 5706 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 5707 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 5708 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 5709 { } /* end */ 5710}; 5711 5712static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = { 5713 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 5714 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 5715 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 5716 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 5717 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 5718 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 5719 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 5720 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 5721 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 5722 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 5723 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 5724 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 5725 { } /* end */ 5726}; 5727 5728static struct snd_kcontrol_new alc882_chmode_mixer[] = { 5729 { 5730 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 5731 .name = "Channel Mode", 5732 .info = alc_ch_mode_info, 5733 .get = alc_ch_mode_get, 5734 .put = alc_ch_mode_put, 5735 }, 5736 { } /* end */ 5737}; 5738 5739static struct hda_verb alc882_init_verbs[] = { 5740 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 5741 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5742 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5743 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5744 /* Rear mixer */ 5745 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5746 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5747 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5748 /* CLFE mixer */ 5749 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5750 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5751 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5752 /* Side mixer */ 5753 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5754 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5755 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5756 5757 /* Front Pin: output 0 (0x0c) */ 5758 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5759 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5760 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 5761 /* Rear Pin: output 1 (0x0d) */ 5762 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5763 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5764 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 5765 /* CLFE Pin: output 2 (0x0e) */ 5766 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5767 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5768 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02}, 5769 /* Side Pin: output 3 (0x0f) */ 5770 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5771 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5772 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 5773 /* Mic (rear) pin: input vref at 80% */ 5774 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 5775 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 5776 /* Front Mic pin: input vref at 80% */ 5777 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 5778 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 5779 /* Line In pin: input */ 5780 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 5781 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 5782 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 5783 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 5784 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5785 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 5786 /* CD pin widget for input */ 5787 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 5788 5789 /* FIXME: use matrix-type input source selection */ 5790 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 5791 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 5792 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5793 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5794 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5795 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5796 /* Input mixer2 */ 5797 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5798 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5799 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5800 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5801 /* Input mixer3 */ 5802 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5803 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5804 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5805 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5806 /* ADC1: mute amp left and right */ 5807 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5808 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 5809 /* ADC2: mute amp left and right */ 5810 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5811 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 5812 /* ADC3: mute amp left and right */ 5813 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5814 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 5815 5816 { } 5817}; 5818 5819static struct hda_verb alc882_eapd_verbs[] = { 5820 /* change to EAPD mode */ 5821 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 5822 {0x20, AC_VERB_SET_PROC_COEF, 0x3060}, 5823 { } 5824}; 5825 5826/* Mac Pro test */ 5827static struct snd_kcontrol_new alc882_macpro_mixer[] = { 5828 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 5829 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 5830 HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT), 5831 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT), 5832 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT), 5833 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT), 5834 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT), 5835 { } /* end */ 5836}; 5837 5838static struct hda_verb alc882_macpro_init_verbs[] = { 5839 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 5840 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5841 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5842 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5843 /* Front Pin: output 0 (0x0c) */ 5844 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5845 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5846 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 5847 /* Front Mic pin: input vref at 80% */ 5848 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 5849 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 5850 /* Speaker: output */ 5851 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5852 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5853 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04}, 5854 /* Headphone output (output 0 - 0x0c) */ 5855 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 5856 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5857 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00}, 5858 5859 /* FIXME: use matrix-type input source selection */ 5860 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 5861 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 5862 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5863 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5864 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5865 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5866 /* Input mixer2 */ 5867 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5868 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5869 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5870 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5871 /* Input mixer3 */ 5872 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5873 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5874 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5875 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5876 /* ADC1: mute amp left and right */ 5877 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5878 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 5879 /* ADC2: mute amp left and right */ 5880 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5881 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 5882 /* ADC3: mute amp left and right */ 5883 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5884 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 5885 5886 { } 5887}; 5888 5889/* Macbook Pro rev3 */ 5890static struct hda_verb alc885_mbp3_init_verbs[] = { 5891 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 5892 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5893 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5894 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5895 /* Rear mixer */ 5896 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 5897 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5898 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5899 /* Front Pin: output 0 (0x0c) */ 5900 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5901 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5902 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 5903 /* HP Pin: output 0 (0x0d) */ 5904 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4}, 5905 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 5906 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 5907 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 5908 /* Mic (rear) pin: input vref at 80% */ 5909 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 5910 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 5911 /* Front Mic pin: input vref at 80% */ 5912 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 5913 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 5914 /* Line In pin: use output 1 when in LineOut mode */ 5915 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 5916 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 5917 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, 5918 5919 /* FIXME: use matrix-type input source selection */ 5920 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 5921 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 5922 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5923 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5924 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5925 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5926 /* Input mixer2 */ 5927 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5928 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5929 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5930 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5931 /* Input mixer3 */ 5932 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5933 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5934 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5935 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5936 /* ADC1: mute amp left and right */ 5937 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5938 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 5939 /* ADC2: mute amp left and right */ 5940 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5941 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 5942 /* ADC3: mute amp left and right */ 5943 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5944 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 5945 5946 { } 5947}; 5948 5949/* iMac 24 mixer. */ 5950static struct snd_kcontrol_new alc885_imac24_mixer[] = { 5951 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT), 5952 HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT), 5953 { } /* end */ 5954}; 5955 5956/* iMac 24 init verbs. */ 5957static struct hda_verb alc885_imac24_init_verbs[] = { 5958 /* Internal speakers: output 0 (0x0c) */ 5959 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5960 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5961 {0x18, AC_VERB_SET_CONNECT_SEL, 0x00}, 5962 /* Internal speakers: output 0 (0x0c) */ 5963 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 5964 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5965 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00}, 5966 /* Headphone: output 0 (0x0c) */ 5967 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 5968 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 5969 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 5970 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 5971 /* Front Mic: input vref at 80% */ 5972 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 5973 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 5974 { } 5975}; 5976 5977/* Toggle speaker-output according to the hp-jack state */ 5978static void alc885_imac24_automute(struct hda_codec *codec) 5979{ 5980 unsigned int present; 5981 5982 present = snd_hda_codec_read(codec, 0x14, 0, 5983 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 5984 snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0, 5985 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 5986 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0, 5987 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 5988} 5989 5990/* Processes unsolicited events. */ 5991static void alc885_imac24_unsol_event(struct hda_codec *codec, 5992 unsigned int res) 5993{ 5994 /* Headphone insertion or removal. */ 5995 if ((res >> 26) == ALC880_HP_EVENT) 5996 alc885_imac24_automute(codec); 5997} 5998 5999static void alc885_mbp3_automute(struct hda_codec *codec) 6000{ 6001 unsigned int present; 6002 6003 present = snd_hda_codec_read(codec, 0x15, 0, 6004 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 6005 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 6006 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 6007 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 6008 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE); 6009 6010} 6011static void alc885_mbp3_unsol_event(struct hda_codec *codec, 6012 unsigned int res) 6013{ 6014 /* Headphone insertion or removal. */ 6015 if ((res >> 26) == ALC880_HP_EVENT) 6016 alc885_mbp3_automute(codec); 6017} 6018 6019 6020static struct hda_verb alc882_targa_verbs[] = { 6021 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6022 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6023 6024 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 6025 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6026 6027 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 6028 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */ 6029 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 6030 6031 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 6032 {0x01, AC_VERB_SET_GPIO_MASK, 0x03}, 6033 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03}, 6034 {0x01, AC_VERB_SET_GPIO_DATA, 0x03}, 6035 { } /* end */ 6036}; 6037 6038/* toggle speaker-output according to the hp-jack state */ 6039static void alc882_targa_automute(struct hda_codec *codec) 6040{ 6041 unsigned int present; 6042 6043 present = snd_hda_codec_read(codec, 0x14, 0, 6044 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 6045 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 6046 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 6047 snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA, 6048 present ? 1 : 3); 6049} 6050 6051static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res) 6052{ 6053 /* Looks like the unsol event is incompatible with the standard 6054 * definition. 4bit tag is placed at 26 bit! 6055 */ 6056 if (((res >> 26) == ALC880_HP_EVENT)) { 6057 alc882_targa_automute(codec); 6058 } 6059} 6060 6061static struct hda_verb alc882_asus_a7j_verbs[] = { 6062 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6063 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6064 6065 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 6066 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6067 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6068 6069 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */ 6070 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 6071 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */ 6072 6073 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 6074 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */ 6075 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 6076 { } /* end */ 6077}; 6078 6079static struct hda_verb alc882_asus_a7m_verbs[] = { 6080 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6081 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6082 6083 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 6084 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6085 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 6086 6087 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */ 6088 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 6089 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */ 6090 6091 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 6092 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */ 6093 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 6094 { } /* end */ 6095}; 6096 6097static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted) 6098{ 6099 unsigned int gpiostate, gpiomask, gpiodir; 6100 6101 gpiostate = snd_hda_codec_read(codec, codec->afg, 0, 6102 AC_VERB_GET_GPIO_DATA, 0); 6103 6104 if (!muted) 6105 gpiostate |= (1 << pin); 6106 else 6107 gpiostate &= ~(1 << pin); 6108 6109 gpiomask = snd_hda_codec_read(codec, codec->afg, 0, 6110 AC_VERB_GET_GPIO_MASK, 0); 6111 gpiomask |= (1 << pin); 6112 6113 gpiodir = snd_hda_codec_read(codec, codec->afg, 0, 6114 AC_VERB_GET_GPIO_DIRECTION, 0); 6115 gpiodir |= (1 << pin); 6116 6117 6118 snd_hda_codec_write(codec, codec->afg, 0, 6119 AC_VERB_SET_GPIO_MASK, gpiomask); 6120 snd_hda_codec_write(codec, codec->afg, 0, 6121 AC_VERB_SET_GPIO_DIRECTION, gpiodir); 6122 6123 msleep(1); 6124 6125 snd_hda_codec_write(codec, codec->afg, 0, 6126 AC_VERB_SET_GPIO_DATA, gpiostate); 6127} 6128 6129/* set up GPIO at initialization */ 6130static void alc885_macpro_init_hook(struct hda_codec *codec) 6131{ 6132 alc882_gpio_mute(codec, 0, 0); 6133 alc882_gpio_mute(codec, 1, 0); 6134} 6135 6136/* set up GPIO and update auto-muting at initialization */ 6137static void alc885_imac24_init_hook(struct hda_codec *codec) 6138{ 6139 alc885_macpro_init_hook(codec); 6140 alc885_imac24_automute(codec); 6141} 6142 6143/* 6144 * generic initialization of ADC, input mixers and output mixers 6145 */ 6146static struct hda_verb alc882_auto_init_verbs[] = { 6147 /* 6148 * Unmute ADC0-2 and set the default input to mic-in 6149 */ 6150 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 6151 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6152 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 6153 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6154 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 6155 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6156 6157 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 6158 * mixer widget 6159 * Note: PASD motherboards uses the Line In 2 as the input for 6160 * front panel mic (mic 2) 6161 */ 6162 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 6163 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 6164 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 6165 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 6166 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 6167 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 6168 6169 /* 6170 * Set up output mixers (0x0c - 0x0f) 6171 */ 6172 /* set vol=0 to output mixers */ 6173 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6174 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6175 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6176 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 6177 /* set up input amps for analog loopback */ 6178 /* Amp Indices: DAC = 0, mixer = 1 */ 6179 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6180 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6181 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6182 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6183 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6184 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6185 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6186 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6187 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 6188 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 6189 6190 /* FIXME: use matrix-type input source selection */ 6191 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 6192 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 6193 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 6194 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 6195 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 6196 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 6197 /* Input mixer2 */ 6198 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 6199 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 6200 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 6201 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 6202 /* Input mixer3 */ 6203 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 6204 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 6205 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 6206 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 6207 6208 { } 6209}; 6210 6211/* capture mixer elements */ 6212static struct snd_kcontrol_new alc882_capture_alt_mixer[] = { 6213 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 6214 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 6215 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 6216 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 6217 { 6218 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6219 /* The multiple "Capture Source" controls confuse alsamixer 6220 * So call somewhat different.. 6221 */ 6222 /* .name = "Capture Source", */ 6223 .name = "Input Source", 6224 .count = 2, 6225 .info = alc882_mux_enum_info, 6226 .get = alc882_mux_enum_get, 6227 .put = alc882_mux_enum_put, 6228 }, 6229 { } /* end */ 6230}; 6231 6232static struct snd_kcontrol_new alc882_capture_mixer[] = { 6233 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT), 6234 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT), 6235 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT), 6236 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT), 6237 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT), 6238 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT), 6239 { 6240 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6241 /* The multiple "Capture Source" controls confuse alsamixer 6242 * So call somewhat different.. 6243 */ 6244 /* .name = "Capture Source", */ 6245 .name = "Input Source", 6246 .count = 3, 6247 .info = alc882_mux_enum_info, 6248 .get = alc882_mux_enum_get, 6249 .put = alc882_mux_enum_put, 6250 }, 6251 { } /* end */ 6252}; 6253 6254#ifdef CONFIG_SND_HDA_POWER_SAVE 6255#define alc882_loopbacks alc880_loopbacks 6256#endif 6257 6258/* pcm configuration: identiacal with ALC880 */ 6259#define alc882_pcm_analog_playback alc880_pcm_analog_playback 6260#define alc882_pcm_analog_capture alc880_pcm_analog_capture 6261#define alc882_pcm_digital_playback alc880_pcm_digital_playback 6262#define alc882_pcm_digital_capture alc880_pcm_digital_capture 6263 6264/* 6265 * configuration and preset 6266 */ 6267static const char *alc882_models[ALC882_MODEL_LAST] = { 6268 [ALC882_3ST_DIG] = "3stack-dig", 6269 [ALC882_6ST_DIG] = "6stack-dig", 6270 [ALC882_ARIMA] = "arima", 6271 [ALC882_W2JC] = "w2jc", 6272 [ALC882_TARGA] = "targa", 6273 [ALC882_ASUS_A7J] = "asus-a7j", 6274 [ALC882_ASUS_A7M] = "asus-a7m", 6275 [ALC885_MACPRO] = "macpro", 6276 [ALC885_MBP3] = "mbp3", 6277 [ALC885_IMAC24] = "imac24", 6278 [ALC882_AUTO] = "auto", 6279}; 6280 6281static struct snd_pci_quirk alc882_cfg_tbl[] = { 6282 SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG), 6283 SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J), 6284 SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J), 6285 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M), 6286 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC), 6287 SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG), 6288 SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG), 6289 SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG), 6290 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG), 6291 SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8 */ 6292 SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG), 6293 SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), 6294 {} 6295}; 6296 6297static struct alc_config_preset alc882_presets[] = { 6298 [ALC882_3ST_DIG] = { 6299 .mixers = { alc882_base_mixer }, 6300 .init_verbs = { alc882_init_verbs }, 6301 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6302 .dac_nids = alc882_dac_nids, 6303 .dig_out_nid = ALC882_DIGOUT_NID, 6304 .dig_in_nid = ALC882_DIGIN_NID, 6305 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes), 6306 .channel_mode = alc882_ch_modes, 6307 .need_dac_fix = 1, 6308 .input_mux = &alc882_capture_source, 6309 }, 6310 [ALC882_6ST_DIG] = { 6311 .mixers = { alc882_base_mixer, alc882_chmode_mixer }, 6312 .init_verbs = { alc882_init_verbs }, 6313 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6314 .dac_nids = alc882_dac_nids, 6315 .dig_out_nid = ALC882_DIGOUT_NID, 6316 .dig_in_nid = ALC882_DIGIN_NID, 6317 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes), 6318 .channel_mode = alc882_sixstack_modes, 6319 .input_mux = &alc882_capture_source, 6320 }, 6321 [ALC882_ARIMA] = { 6322 .mixers = { alc882_base_mixer, alc882_chmode_mixer }, 6323 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs }, 6324 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6325 .dac_nids = alc882_dac_nids, 6326 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes), 6327 .channel_mode = alc882_sixstack_modes, 6328 .input_mux = &alc882_capture_source, 6329 }, 6330 [ALC882_W2JC] = { 6331 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer }, 6332 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs, 6333 alc880_gpio1_init_verbs }, 6334 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6335 .dac_nids = alc882_dac_nids, 6336 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 6337 .channel_mode = alc880_threestack_modes, 6338 .need_dac_fix = 1, 6339 .input_mux = &alc882_capture_source, 6340 .dig_out_nid = ALC882_DIGOUT_NID, 6341 }, 6342 [ALC885_MBP3] = { 6343 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer }, 6344 .init_verbs = { alc885_mbp3_init_verbs, 6345 alc880_gpio1_init_verbs }, 6346 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6347 .dac_nids = alc882_dac_nids, 6348 .channel_mode = alc885_mbp_6ch_modes, 6349 .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes), 6350 .input_mux = &alc882_capture_source, 6351 .dig_out_nid = ALC882_DIGOUT_NID, 6352 .dig_in_nid = ALC882_DIGIN_NID, 6353 .unsol_event = alc885_mbp3_unsol_event, 6354 .init_hook = alc885_mbp3_automute, 6355 }, 6356 [ALC885_MACPRO] = { 6357 .mixers = { alc882_macpro_mixer }, 6358 .init_verbs = { alc882_macpro_init_verbs }, 6359 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6360 .dac_nids = alc882_dac_nids, 6361 .dig_out_nid = ALC882_DIGOUT_NID, 6362 .dig_in_nid = ALC882_DIGIN_NID, 6363 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes), 6364 .channel_mode = alc882_ch_modes, 6365 .input_mux = &alc882_capture_source, 6366 .init_hook = alc885_macpro_init_hook, 6367 }, 6368 [ALC885_IMAC24] = { 6369 .mixers = { alc885_imac24_mixer }, 6370 .init_verbs = { alc885_imac24_init_verbs }, 6371 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6372 .dac_nids = alc882_dac_nids, 6373 .dig_out_nid = ALC882_DIGOUT_NID, 6374 .dig_in_nid = ALC882_DIGIN_NID, 6375 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes), 6376 .channel_mode = alc882_ch_modes, 6377 .input_mux = &alc882_capture_source, 6378 .unsol_event = alc885_imac24_unsol_event, 6379 .init_hook = alc885_imac24_init_hook, 6380 }, 6381 [ALC882_TARGA] = { 6382 .mixers = { alc882_targa_mixer, alc882_chmode_mixer, 6383 alc882_capture_mixer }, 6384 .init_verbs = { alc882_init_verbs, alc882_targa_verbs}, 6385 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6386 .dac_nids = alc882_dac_nids, 6387 .dig_out_nid = ALC882_DIGOUT_NID, 6388 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids), 6389 .adc_nids = alc882_adc_nids, 6390 .capsrc_nids = alc882_capsrc_nids, 6391 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes), 6392 .channel_mode = alc882_3ST_6ch_modes, 6393 .need_dac_fix = 1, 6394 .input_mux = &alc882_capture_source, 6395 .unsol_event = alc882_targa_unsol_event, 6396 .init_hook = alc882_targa_automute, 6397 }, 6398 [ALC882_ASUS_A7J] = { 6399 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer, 6400 alc882_capture_mixer }, 6401 .init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs}, 6402 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6403 .dac_nids = alc882_dac_nids, 6404 .dig_out_nid = ALC882_DIGOUT_NID, 6405 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids), 6406 .adc_nids = alc882_adc_nids, 6407 .capsrc_nids = alc882_capsrc_nids, 6408 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes), 6409 .channel_mode = alc882_3ST_6ch_modes, 6410 .need_dac_fix = 1, 6411 .input_mux = &alc882_capture_source, 6412 }, 6413 [ALC882_ASUS_A7M] = { 6414 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer }, 6415 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs, 6416 alc880_gpio1_init_verbs, 6417 alc882_asus_a7m_verbs }, 6418 .num_dacs = ARRAY_SIZE(alc882_dac_nids), 6419 .dac_nids = alc882_dac_nids, 6420 .dig_out_nid = ALC882_DIGOUT_NID, 6421 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), 6422 .channel_mode = alc880_threestack_modes, 6423 .need_dac_fix = 1, 6424 .input_mux = &alc882_capture_source, 6425 }, 6426}; 6427 6428 6429/* 6430 * Pin config fixes 6431 */ 6432enum { 6433 PINFIX_ABIT_AW9D_MAX 6434}; 6435 6436static struct alc_pincfg alc882_abit_aw9d_pinfix[] = { 6437 { 0x15, 0x01080104 }, /* side */ 6438 { 0x16, 0x01011012 }, /* rear */ 6439 { 0x17, 0x01016011 }, /* clfe */ 6440 { } 6441}; 6442 6443static const struct alc_pincfg *alc882_pin_fixes[] = { 6444 [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix, 6445}; 6446 6447static struct snd_pci_quirk alc882_pinfix_tbl[] = { 6448 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX), 6449 {} 6450}; 6451 6452/* 6453 * BIOS auto configuration 6454 */ 6455static void alc882_auto_set_output_and_unmute(struct hda_codec *codec, 6456 hda_nid_t nid, int pin_type, 6457 int dac_idx) 6458{ 6459 /* set as output */ 6460 struct alc_spec *spec = codec->spec; 6461 int idx; 6462 6463 alc_set_pin_output(codec, nid, pin_type); 6464 if (spec->multiout.dac_nids[dac_idx] == 0x25) 6465 idx = 4; 6466 else 6467 idx = spec->multiout.dac_nids[dac_idx] - 2; 6468 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx); 6469 6470} 6471 6472static void alc882_auto_init_multi_out(struct hda_codec *codec) 6473{ 6474 struct alc_spec *spec = codec->spec; 6475 int i; 6476 6477 alc_subsystem_id(codec, 0x15, 0x1b, 0x14); 6478 for (i = 0; i <= HDA_SIDE; i++) { 6479 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 6480 int pin_type = get_pin_type(spec->autocfg.line_out_type); 6481 if (nid) 6482 alc882_auto_set_output_and_unmute(codec, nid, pin_type, 6483 i); 6484 } 6485} 6486 6487static void alc882_auto_init_hp_out(struct hda_codec *codec) 6488{ 6489 struct alc_spec *spec = codec->spec; 6490 hda_nid_t pin; 6491 6492 pin = spec->autocfg.hp_pins[0]; 6493 if (pin) /* connect to front */ 6494 /* use dac 0 */ 6495 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 6496 pin = spec->autocfg.speaker_pins[0]; 6497 if (pin) 6498 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 6499} 6500 6501#define alc882_is_input_pin(nid) alc880_is_input_pin(nid) 6502#define ALC882_PIN_CD_NID ALC880_PIN_CD_NID 6503 6504static void alc882_auto_init_analog_input(struct hda_codec *codec) 6505{ 6506 struct alc_spec *spec = codec->spec; 6507 int i; 6508 6509 for (i = 0; i < AUTO_PIN_LAST; i++) { 6510 hda_nid_t nid = spec->autocfg.input_pins[i]; 6511 unsigned int vref; 6512 if (!nid) 6513 continue; 6514 vref = PIN_IN; 6515 if (1 /*i <= AUTO_PIN_FRONT_MIC*/) { 6516 unsigned int pincap; 6517 pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP); 6518 if ((pincap >> AC_PINCAP_VREF_SHIFT) & 6519 AC_PINCAP_VREF_80) 6520 vref = PIN_VREF80; 6521 } 6522 snd_hda_codec_write(codec, nid, 0, 6523 AC_VERB_SET_PIN_WIDGET_CONTROL, vref); 6524 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) 6525 snd_hda_codec_write(codec, nid, 0, 6526 AC_VERB_SET_AMP_GAIN_MUTE, 6527 AMP_OUT_MUTE); 6528 } 6529} 6530 6531static void alc882_auto_init_input_src(struct hda_codec *codec) 6532{ 6533 struct alc_spec *spec = codec->spec; 6534 const struct hda_input_mux *imux = spec->input_mux; 6535 int c; 6536 6537 for (c = 0; c < spec->num_adc_nids; c++) { 6538 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS]; 6539 hda_nid_t nid = spec->capsrc_nids[c]; 6540 int conns, mute, idx, item; 6541 6542 conns = snd_hda_get_connections(codec, nid, conn_list, 6543 ARRAY_SIZE(conn_list)); 6544 if (conns < 0) 6545 continue; 6546 for (idx = 0; idx < conns; idx++) { 6547 /* if the current connection is the selected one, 6548 * unmute it as default - otherwise mute it 6549 */ 6550 mute = AMP_IN_MUTE(idx); 6551 for (item = 0; item < imux->num_items; item++) { 6552 if (imux->items[item].index == idx) { 6553 if (spec->cur_mux[c] == item) 6554 mute = AMP_IN_UNMUTE(idx); 6555 break; 6556 } 6557 } 6558 snd_hda_codec_write(codec, nid, 0, 6559 AC_VERB_SET_AMP_GAIN_MUTE, mute); 6560 } 6561 } 6562} 6563 6564/* add mic boosts if needed */ 6565static int alc_auto_add_mic_boost(struct hda_codec *codec) 6566{ 6567 struct alc_spec *spec = codec->spec; 6568 int err; 6569 hda_nid_t nid; 6570 6571 nid = spec->autocfg.input_pins[AUTO_PIN_MIC]; 6572 if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) { 6573 err = add_control(spec, ALC_CTL_WIDGET_VOL, 6574 "Mic Boost", 6575 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT)); 6576 if (err < 0) 6577 return err; 6578 } 6579 nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC]; 6580 if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) { 6581 err = add_control(spec, ALC_CTL_WIDGET_VOL, 6582 "Front Mic Boost", 6583 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT)); 6584 if (err < 0) 6585 return err; 6586 } 6587 return 0; 6588} 6589 6590/* almost identical with ALC880 parser... */ 6591static int alc882_parse_auto_config(struct hda_codec *codec) 6592{ 6593 struct alc_spec *spec = codec->spec; 6594 int err = alc880_parse_auto_config(codec); 6595 6596 if (err < 0) 6597 return err; 6598 else if (!err) 6599 return 0; /* no config found */ 6600 6601 err = alc_auto_add_mic_boost(codec); 6602 if (err < 0) 6603 return err; 6604 6605 /* hack - override the init verbs */ 6606 spec->init_verbs[0] = alc882_auto_init_verbs; 6607 6608 return 1; /* config found */ 6609} 6610 6611/* additional initialization for auto-configuration model */ 6612static void alc882_auto_init(struct hda_codec *codec) 6613{ 6614 struct alc_spec *spec = codec->spec; 6615 alc882_auto_init_multi_out(codec); 6616 alc882_auto_init_hp_out(codec); 6617 alc882_auto_init_analog_input(codec); 6618 alc882_auto_init_input_src(codec); 6619 if (spec->unsol_event) 6620 alc_sku_automute(codec); 6621} 6622 6623static int patch_alc883(struct hda_codec *codec); /* called in patch_alc882() */ 6624 6625static int patch_alc882(struct hda_codec *codec) 6626{ 6627 struct alc_spec *spec; 6628 int err, board_config; 6629 6630 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 6631 if (spec == NULL) 6632 return -ENOMEM; 6633 6634 codec->spec = spec; 6635 6636 board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST, 6637 alc882_models, 6638 alc882_cfg_tbl); 6639 6640 if (board_config < 0 || board_config >= ALC882_MODEL_LAST) { 6641 /* Pick up systems that don't supply PCI SSID */ 6642 switch (codec->subsystem_id) { 6643 case 0x106b0c00: /* Mac Pro */ 6644 board_config = ALC885_MACPRO; 6645 break; 6646 case 0x106b1000: /* iMac 24 */ 6647 board_config = ALC885_IMAC24; 6648 break; 6649 case 0x106b00a1: /* Macbook (might be wrong - PCI SSID?) */ 6650 case 0x106b2c00: /* Macbook Pro rev3 */ 6651 case 0x106b3600: /* Macbook 3.1 */ 6652 board_config = ALC885_MBP3; 6653 break; 6654 default: 6655 /* ALC889A is handled better as ALC888-compatible */ 6656 if (codec->revision_id == 0x100103) { 6657 alc_free(codec); 6658 return patch_alc883(codec); 6659 } 6660 printk(KERN_INFO "hda_codec: Unknown model for ALC882, " 6661 "trying auto-probe from BIOS...\n"); 6662 board_config = ALC882_AUTO; 6663 } 6664 } 6665 6666 alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes); 6667 6668 if (board_config == ALC882_AUTO) { 6669 /* automatic parse from the BIOS config */ 6670 err = alc882_parse_auto_config(codec); 6671 if (err < 0) { 6672 alc_free(codec); 6673 return err; 6674 } else if (!err) { 6675 printk(KERN_INFO 6676 "hda_codec: Cannot set up configuration " 6677 "from BIOS. Using base mode...\n"); 6678 board_config = ALC882_3ST_DIG; 6679 } 6680 } 6681 6682 if (board_config != ALC882_AUTO) 6683 setup_preset(spec, &alc882_presets[board_config]); 6684 6685 if (codec->vendor_id == 0x10ec0885) { 6686 spec->stream_name_analog = "ALC885 Analog"; 6687 spec->stream_name_digital = "ALC885 Digital"; 6688 } else { 6689 spec->stream_name_analog = "ALC882 Analog"; 6690 spec->stream_name_digital = "ALC882 Digital"; 6691 } 6692 6693 spec->stream_analog_playback = &alc882_pcm_analog_playback; 6694 spec->stream_analog_capture = &alc882_pcm_analog_capture; 6695 /* FIXME: setup DAC5 */ 6696 /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/ 6697 spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture; 6698 6699 spec->stream_digital_playback = &alc882_pcm_digital_playback; 6700 spec->stream_digital_capture = &alc882_pcm_digital_capture; 6701 6702 if (!spec->adc_nids && spec->input_mux) { 6703 /* check whether NID 0x07 is valid */ 6704 unsigned int wcap = get_wcaps(codec, 0x07); 6705 /* get type */ 6706 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 6707 if (wcap != AC_WID_AUD_IN) { 6708 spec->adc_nids = alc882_adc_nids_alt; 6709 spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt); 6710 spec->capsrc_nids = alc882_capsrc_nids_alt; 6711 spec->mixers[spec->num_mixers] = 6712 alc882_capture_alt_mixer; 6713 spec->num_mixers++; 6714 } else { 6715 spec->adc_nids = alc882_adc_nids; 6716 spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids); 6717 spec->capsrc_nids = alc882_capsrc_nids; 6718 spec->mixers[spec->num_mixers] = alc882_capture_mixer; 6719 spec->num_mixers++; 6720 } 6721 } 6722 6723 spec->vmaster_nid = 0x0c; 6724 6725 codec->patch_ops = alc_patch_ops; 6726 if (board_config == ALC882_AUTO) 6727 spec->init_hook = alc882_auto_init; 6728#ifdef CONFIG_SND_HDA_POWER_SAVE 6729 if (!spec->loopback.amplist) 6730 spec->loopback.amplist = alc882_loopbacks; 6731#endif 6732 6733 return 0; 6734} 6735 6736/* 6737 * ALC883 support 6738 * 6739 * ALC883 is almost identical with ALC880 but has cleaner and more flexible 6740 * configuration. Each pin widget can choose any input DACs and a mixer. 6741 * Each ADC is connected from a mixer of all inputs. This makes possible 6742 * 6-channel independent captures. 6743 * 6744 * In addition, an independent DAC for the multi-playback (not used in this 6745 * driver yet). 6746 */ 6747#define ALC883_DIGOUT_NID 0x06 6748#define ALC883_DIGIN_NID 0x0a 6749 6750static hda_nid_t alc883_dac_nids[4] = { 6751 /* front, rear, clfe, rear_surr */ 6752 0x02, 0x03, 0x04, 0x05 6753}; 6754 6755static hda_nid_t alc883_adc_nids[2] = { 6756 /* ADC1-2 */ 6757 0x08, 0x09, 6758}; 6759 6760static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 }; 6761 6762/* input MUX */ 6763/* FIXME: should be a matrix-type input source selection */ 6764 6765static struct hda_input_mux alc883_capture_source = { 6766 .num_items = 4, 6767 .items = { 6768 { "Mic", 0x0 }, 6769 { "Front Mic", 0x1 }, 6770 { "Line", 0x2 }, 6771 { "CD", 0x4 }, 6772 }, 6773}; 6774 6775static struct hda_input_mux alc883_3stack_6ch_intel = { 6776 .num_items = 4, 6777 .items = { 6778 { "Mic", 0x1 }, 6779 { "Front Mic", 0x0 }, 6780 { "Line", 0x2 }, 6781 { "CD", 0x4 }, 6782 }, 6783}; 6784 6785static struct hda_input_mux alc883_lenovo_101e_capture_source = { 6786 .num_items = 2, 6787 .items = { 6788 { "Mic", 0x1 }, 6789 { "Line", 0x2 }, 6790 }, 6791}; 6792 6793static struct hda_input_mux alc883_lenovo_nb0763_capture_source = { 6794 .num_items = 4, 6795 .items = { 6796 { "Mic", 0x0 }, 6797 { "iMic", 0x1 }, 6798 { "Line", 0x2 }, 6799 { "CD", 0x4 }, 6800 }, 6801}; 6802 6803static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = { 6804 .num_items = 2, 6805 .items = { 6806 { "Mic", 0x0 }, 6807 { "Int Mic", 0x1 }, 6808 }, 6809}; 6810 6811#define alc883_mux_enum_info alc_mux_enum_info 6812#define alc883_mux_enum_get alc_mux_enum_get 6813/* ALC883 has the ALC882-type input selection */ 6814#define alc883_mux_enum_put alc882_mux_enum_put 6815 6816/* 6817 * 2ch mode 6818 */ 6819static struct hda_channel_mode alc883_3ST_2ch_modes[1] = { 6820 { 2, NULL } 6821}; 6822 6823/* 6824 * 2ch mode 6825 */ 6826static struct hda_verb alc883_3ST_ch2_init[] = { 6827 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 6828 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 6829 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 6830 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 6831 { } /* end */ 6832}; 6833 6834/* 6835 * 4ch mode 6836 */ 6837static struct hda_verb alc883_3ST_ch4_init[] = { 6838 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 6839 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 6840 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6841 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 6842 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 6843 { } /* end */ 6844}; 6845 6846/* 6847 * 6ch mode 6848 */ 6849static struct hda_verb alc883_3ST_ch6_init[] = { 6850 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6851 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 6852 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 }, 6853 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6854 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 6855 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 6856 { } /* end */ 6857}; 6858 6859static struct hda_channel_mode alc883_3ST_6ch_modes[3] = { 6860 { 2, alc883_3ST_ch2_init }, 6861 { 4, alc883_3ST_ch4_init }, 6862 { 6, alc883_3ST_ch6_init }, 6863}; 6864 6865/* 6866 * 2ch mode 6867 */ 6868static struct hda_verb alc883_3ST_ch2_intel_init[] = { 6869 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 6870 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 6871 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 6872 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 6873 { } /* end */ 6874}; 6875 6876/* 6877 * 4ch mode 6878 */ 6879static struct hda_verb alc883_3ST_ch4_intel_init[] = { 6880 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 6881 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 6882 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6883 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 6884 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 6885 { } /* end */ 6886}; 6887 6888/* 6889 * 6ch mode 6890 */ 6891static struct hda_verb alc883_3ST_ch6_intel_init[] = { 6892 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6893 { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 6894 { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 }, 6895 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6896 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 6897 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 6898 { } /* end */ 6899}; 6900 6901static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = { 6902 { 2, alc883_3ST_ch2_intel_init }, 6903 { 4, alc883_3ST_ch4_intel_init }, 6904 { 6, alc883_3ST_ch6_intel_init }, 6905}; 6906 6907/* 6908 * 6ch mode 6909 */ 6910static struct hda_verb alc883_sixstack_ch6_init[] = { 6911 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 6912 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6913 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6914 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6915 { } /* end */ 6916}; 6917 6918/* 6919 * 8ch mode 6920 */ 6921static struct hda_verb alc883_sixstack_ch8_init[] = { 6922 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6923 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6924 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6925 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 6926 { } /* end */ 6927}; 6928 6929static struct hda_channel_mode alc883_sixstack_modes[2] = { 6930 { 6, alc883_sixstack_ch6_init }, 6931 { 8, alc883_sixstack_ch8_init }, 6932}; 6933 6934static struct hda_verb alc883_medion_eapd_verbs[] = { 6935 /* eanable EAPD on medion laptop */ 6936 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 6937 {0x20, AC_VERB_SET_PROC_COEF, 0x3070}, 6938 { } 6939}; 6940 6941/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17 6942 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b 6943 */ 6944 6945static struct snd_kcontrol_new alc883_base_mixer[] = { 6946 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 6947 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 6948 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 6949 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 6950 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 6951 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 6952 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 6953 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 6954 HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT), 6955 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 6956 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 6957 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 6958 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 6959 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 6960 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 6961 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 6962 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 6963 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 6964 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 6965 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 6966 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 6967 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 6968 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 6969 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 6970 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 6971 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 6972 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 6973 { 6974 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6975 /* .name = "Capture Source", */ 6976 .name = "Input Source", 6977 .count = 2, 6978 .info = alc883_mux_enum_info, 6979 .get = alc883_mux_enum_get, 6980 .put = alc883_mux_enum_put, 6981 }, 6982 { } /* end */ 6983}; 6984 6985static struct snd_kcontrol_new alc883_mitac_mixer[] = { 6986 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 6987 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 6988 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 6989 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 6990 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 6991 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 6992 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 6993 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 6994 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 6995 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 6996 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 6997 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 6998 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 6999 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7000 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7001 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 7002 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 7003 { 7004 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7005 /* .name = "Capture Source", */ 7006 .name = "Input Source", 7007 .count = 2, 7008 .info = alc883_mux_enum_info, 7009 .get = alc883_mux_enum_get, 7010 .put = alc883_mux_enum_put, 7011 }, 7012 { } /* end */ 7013}; 7014 7015static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = { 7016 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7017 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 7018 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7019 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 7020 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7021 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7022 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7023 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7024 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 7025 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7026 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7027 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7028 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 7029 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 7030 { 7031 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7032 /* .name = "Capture Source", */ 7033 .name = "Input Source", 7034 .count = 2, 7035 .info = alc883_mux_enum_info, 7036 .get = alc883_mux_enum_get, 7037 .put = alc883_mux_enum_put, 7038 }, 7039 { } /* end */ 7040}; 7041 7042static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = { 7043 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7044 HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), 7045 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7046 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 7047 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7048 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7049 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7050 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7051 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 7052 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7053 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7054 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7055 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 7056 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 7057 { 7058 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7059 /* .name = "Capture Source", */ 7060 .name = "Input Source", 7061 .count = 2, 7062 .info = alc883_mux_enum_info, 7063 .get = alc883_mux_enum_get, 7064 .put = alc883_mux_enum_put, 7065 }, 7066 { } /* end */ 7067}; 7068 7069static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = { 7070 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7071 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7072 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7073 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7074 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7075 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7076 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7077 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7078 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7079 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7080 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7081 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 7082 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7083 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 7084 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 7085 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7086 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7087 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 7088 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 7089 { 7090 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7091 /* .name = "Capture Source", */ 7092 .name = "Input Source", 7093 .count = 2, 7094 .info = alc883_mux_enum_info, 7095 .get = alc883_mux_enum_get, 7096 .put = alc883_mux_enum_put, 7097 }, 7098 { } /* end */ 7099}; 7100 7101static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = { 7102 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7103 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7104 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7105 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 7106 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 7107 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 7108 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 7109 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 7110 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7111 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7112 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7113 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7114 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7115 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7116 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7117 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7118 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7119 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 7120 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7121 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 7122 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 7123 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7124 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7125 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 7126 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 7127 { 7128 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7129 /* .name = "Capture Source", */ 7130 .name = "Input Source", 7131 .count = 2, 7132 .info = alc883_mux_enum_info, 7133 .get = alc883_mux_enum_get, 7134 .put = alc883_mux_enum_put, 7135 }, 7136 { } /* end */ 7137}; 7138 7139static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = { 7140 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7141 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7142 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7143 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 7144 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, 7145 HDA_OUTPUT), 7146 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 7147 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 7148 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 7149 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 7150 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7151 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7152 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7153 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7154 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7155 HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT), 7156 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7157 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7158 HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT), 7159 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7160 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 7161 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 7162 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7163 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7164 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 7165 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 7166 { 7167 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7168 /* .name = "Capture Source", */ 7169 .name = "Input Source", 7170 .count = 2, 7171 .info = alc883_mux_enum_info, 7172 .get = alc883_mux_enum_get, 7173 .put = alc883_mux_enum_put, 7174 }, 7175 { } /* end */ 7176}; 7177 7178static struct snd_kcontrol_new alc883_fivestack_mixer[] = { 7179 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7180 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7181 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7182 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 7183 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 7184 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 7185 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 7186 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 7187 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7188 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7189 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7190 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7191 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7192 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7193 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7194 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7195 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7196 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 7197 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7198 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 7199 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 7200 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7201 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7202 7203 { 7204 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7205 /* .name = "Capture Source", */ 7206 .name = "Input Source", 7207 .count = 1, 7208 .info = alc883_mux_enum_info, 7209 .get = alc883_mux_enum_get, 7210 .put = alc883_mux_enum_put, 7211 }, 7212 { } /* end */ 7213}; 7214 7215static struct snd_kcontrol_new alc883_tagra_mixer[] = { 7216 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7217 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 7218 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7219 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7220 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 7221 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 7222 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 7223 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 7224 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 7225 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7226 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7227 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7228 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7229 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7230 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7231 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7232 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7233 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7234 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 7235 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 7236 { 7237 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7238 /* .name = "Capture Source", */ 7239 .name = "Input Source", 7240 .count = 2, 7241 .info = alc883_mux_enum_info, 7242 .get = alc883_mux_enum_get, 7243 .put = alc883_mux_enum_put, 7244 }, 7245 { } /* end */ 7246}; 7247 7248static struct snd_kcontrol_new alc883_tagra_2ch_mixer[] = { 7249 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7250 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 7251 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7252 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7253 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7254 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7255 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7256 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7257 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7258 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 7259 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7260 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7261 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7262 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 7263 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 7264 { 7265 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7266 /* .name = "Capture Source", */ 7267 .name = "Input Source", 7268 .count = 2, 7269 .info = alc883_mux_enum_info, 7270 .get = alc883_mux_enum_get, 7271 .put = alc883_mux_enum_put, 7272 }, 7273 { } /* end */ 7274}; 7275 7276static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = { 7277 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7278 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7279 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 7280 HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT), 7281 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 7282 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7283 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7284 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7285 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7286 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7287 { 7288 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7289 /* .name = "Capture Source", */ 7290 .name = "Input Source", 7291 .count = 1, 7292 .info = alc883_mux_enum_info, 7293 .get = alc883_mux_enum_get, 7294 .put = alc883_mux_enum_put, 7295 }, 7296 { } /* end */ 7297}; 7298 7299static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = { 7300 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7301 HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT), 7302 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 7303 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7304 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7305 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7306 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7307 HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT), 7308 HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT), 7309 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7310 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7311 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 7312 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 7313 { 7314 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7315 /* .name = "Capture Source", */ 7316 .name = "Input Source", 7317 .count = 2, 7318 .info = alc883_mux_enum_info, 7319 .get = alc883_mux_enum_get, 7320 .put = alc883_mux_enum_put, 7321 }, 7322 { } /* end */ 7323}; 7324 7325static struct snd_kcontrol_new alc883_medion_md2_mixer[] = { 7326 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7327 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 7328 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT), 7329 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 7330 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 7331 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7332 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7333 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7334 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7335 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7336 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7337 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 7338 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 7339 { 7340 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7341 /* .name = "Capture Source", */ 7342 .name = "Input Source", 7343 .count = 2, 7344 .info = alc883_mux_enum_info, 7345 .get = alc883_mux_enum_get, 7346 .put = alc883_mux_enum_put, 7347 }, 7348 { } /* end */ 7349}; 7350 7351static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = { 7352 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 7353 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 7354 HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), 7355 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 7356 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 7357 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 7358 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 7359 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 7360 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7361 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7362 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 7363 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 7364 { 7365 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7366 /* .name = "Capture Source", */ 7367 .name = "Input Source", 7368 .count = 2, 7369 .info = alc883_mux_enum_info, 7370 .get = alc883_mux_enum_get, 7371 .put = alc883_mux_enum_put, 7372 }, 7373 { } /* end */ 7374}; 7375 7376static struct snd_kcontrol_new alc883_chmode_mixer[] = { 7377 { 7378 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7379 .name = "Channel Mode", 7380 .info = alc_ch_mode_info, 7381 .get = alc_ch_mode_get, 7382 .put = alc_ch_mode_put, 7383 }, 7384 { } /* end */ 7385}; 7386 7387static struct hda_verb alc883_init_verbs[] = { 7388 /* ADC1: mute amp left and right */ 7389 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7390 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 7391 /* ADC2: mute amp left and right */ 7392 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7393 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 7394 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 7395 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7396 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7397 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7398 /* Rear mixer */ 7399 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7400 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7401 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7402 /* CLFE mixer */ 7403 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7404 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7405 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7406 /* Side mixer */ 7407 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7408 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7409 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7410 7411 /* mute analog input loopbacks */ 7412 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7413 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7414 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 7415 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 7416 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 7417 7418 /* Front Pin: output 0 (0x0c) */ 7419 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7420 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7421 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 7422 /* Rear Pin: output 1 (0x0d) */ 7423 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7424 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7425 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 7426 /* CLFE Pin: output 2 (0x0e) */ 7427 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7428 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7429 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02}, 7430 /* Side Pin: output 3 (0x0f) */ 7431 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7432 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7433 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 7434 /* Mic (rear) pin: input vref at 80% */ 7435 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 7436 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 7437 /* Front Mic pin: input vref at 80% */ 7438 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 7439 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 7440 /* Line In pin: input */ 7441 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 7442 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 7443 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 7444 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7445 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7446 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 7447 /* CD pin widget for input */ 7448 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 7449 7450 /* FIXME: use matrix-type input source selection */ 7451 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 7452 /* Input mixer2 */ 7453 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7454 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7455 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 7456 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 7457 /* Input mixer3 */ 7458 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7459 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7460 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 7461 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 7462 { } 7463}; 7464 7465/* toggle speaker-output according to the hp-jack state */ 7466static void alc883_mitac_hp_automute(struct hda_codec *codec) 7467{ 7468 unsigned int present; 7469 7470 present = snd_hda_codec_read(codec, 0x15, 0, 7471 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7472 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 7473 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7474 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0, 7475 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7476} 7477 7478/* auto-toggle front mic */ 7479/* 7480static void alc883_mitac_mic_automute(struct hda_codec *codec) 7481{ 7482 unsigned int present; 7483 unsigned char bits; 7484 7485 present = snd_hda_codec_read(codec, 0x18, 0, 7486 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7487 bits = present ? HDA_AMP_MUTE : 0; 7488 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits); 7489} 7490*/ 7491 7492static void alc883_mitac_automute(struct hda_codec *codec) 7493{ 7494 alc883_mitac_hp_automute(codec); 7495 /* alc883_mitac_mic_automute(codec); */ 7496} 7497 7498static void alc883_mitac_unsol_event(struct hda_codec *codec, 7499 unsigned int res) 7500{ 7501 switch (res >> 26) { 7502 case ALC880_HP_EVENT: 7503 alc883_mitac_hp_automute(codec); 7504 break; 7505 case ALC880_MIC_EVENT: 7506 /* alc883_mitac_mic_automute(codec); */ 7507 break; 7508 } 7509} 7510 7511static struct hda_verb alc883_mitac_verbs[] = { 7512 /* HP */ 7513 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 7514 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7515 /* Subwoofer */ 7516 {0x17, AC_VERB_SET_CONNECT_SEL, 0x02}, 7517 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7518 7519 /* enable unsolicited event */ 7520 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7521 /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */ 7522 7523 { } /* end */ 7524}; 7525 7526static struct hda_verb alc883_clevo_m720_verbs[] = { 7527 /* HP */ 7528 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 7529 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7530 /* Int speaker */ 7531 {0x14, AC_VERB_SET_CONNECT_SEL, 0x01}, 7532 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7533 7534 /* enable unsolicited event */ 7535 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7536 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, 7537 7538 { } /* end */ 7539}; 7540 7541static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = { 7542 /* HP */ 7543 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 7544 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7545 /* Subwoofer */ 7546 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 7547 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7548 7549 /* enable unsolicited event */ 7550 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7551 7552 { } /* end */ 7553}; 7554 7555static struct hda_verb alc883_tagra_verbs[] = { 7556 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7557 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7558 7559 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7560 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7561 7562 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */ 7563 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */ 7564 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */ 7565 7566 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7567 {0x01, AC_VERB_SET_GPIO_MASK, 0x03}, 7568 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03}, 7569 {0x01, AC_VERB_SET_GPIO_DATA, 0x03}, 7570 7571 { } /* end */ 7572}; 7573 7574static struct hda_verb alc883_lenovo_101e_verbs[] = { 7575 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 7576 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN}, 7577 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN}, 7578 { } /* end */ 7579}; 7580 7581static struct hda_verb alc883_lenovo_nb0763_verbs[] = { 7582 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 7583 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7584 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7585 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7586 { } /* end */ 7587}; 7588 7589static struct hda_verb alc888_lenovo_ms7195_verbs[] = { 7590 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7591 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7592 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 7593 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN}, 7594 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7595 { } /* end */ 7596}; 7597 7598static struct hda_verb alc883_haier_w66_verbs[] = { 7599 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7600 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7601 7602 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7603 7604 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 7605 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7606 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7607 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7608 { } /* end */ 7609}; 7610 7611static struct hda_verb alc888_3st_hp_verbs[] = { 7612 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front: output 0 (0x0c) */ 7613 {0x16, AC_VERB_SET_CONNECT_SEL, 0x01}, /* Rear : output 1 (0x0d) */ 7614 {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* CLFE : output 2 (0x0e) */ 7615 { } 7616}; 7617 7618static struct hda_verb alc888_6st_dell_verbs[] = { 7619 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7620 { } 7621}; 7622 7623static struct hda_verb alc888_3st_hp_2ch_init[] = { 7624 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 7625 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7626 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 7627 { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 7628 { } 7629}; 7630 7631static struct hda_verb alc888_3st_hp_6ch_init[] = { 7632 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7633 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7634 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 7635 { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 7636 { } 7637}; 7638 7639static struct hda_channel_mode alc888_3st_hp_modes[2] = { 7640 { 2, alc888_3st_hp_2ch_init }, 7641 { 6, alc888_3st_hp_6ch_init }, 7642}; 7643 7644/* toggle front-jack and RCA according to the hp-jack state */ 7645static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec) 7646{ 7647 unsigned int present; 7648 7649 present = snd_hda_codec_read(codec, 0x1b, 0, 7650 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7651 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 7652 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7653 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 7654 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7655} 7656 7657/* toggle RCA according to the front-jack state */ 7658static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec) 7659{ 7660 unsigned int present; 7661 7662 present = snd_hda_codec_read(codec, 0x14, 0, 7663 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7664 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 7665 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7666} 7667 7668static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec, 7669 unsigned int res) 7670{ 7671 if ((res >> 26) == ALC880_HP_EVENT) 7672 alc888_lenovo_ms7195_front_automute(codec); 7673 if ((res >> 26) == ALC880_FRONT_EVENT) 7674 alc888_lenovo_ms7195_rca_automute(codec); 7675} 7676 7677static struct hda_verb alc883_medion_md2_verbs[] = { 7678 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7679 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7680 7681 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7682 7683 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7684 { } /* end */ 7685}; 7686 7687/* toggle speaker-output according to the hp-jack state */ 7688static void alc883_medion_md2_automute(struct hda_codec *codec) 7689{ 7690 unsigned int present; 7691 7692 present = snd_hda_codec_read(codec, 0x14, 0, 7693 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7694 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 7695 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7696} 7697 7698static void alc883_medion_md2_unsol_event(struct hda_codec *codec, 7699 unsigned int res) 7700{ 7701 if ((res >> 26) == ALC880_HP_EVENT) 7702 alc883_medion_md2_automute(codec); 7703} 7704 7705/* toggle speaker-output according to the hp-jack state */ 7706static void alc883_tagra_automute(struct hda_codec *codec) 7707{ 7708 unsigned int present; 7709 unsigned char bits; 7710 7711 present = snd_hda_codec_read(codec, 0x14, 0, 7712 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7713 bits = present ? HDA_AMP_MUTE : 0; 7714 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 7715 HDA_AMP_MUTE, bits); 7716 snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA, 7717 present ? 1 : 3); 7718} 7719 7720static void alc883_tagra_unsol_event(struct hda_codec *codec, unsigned int res) 7721{ 7722 if ((res >> 26) == ALC880_HP_EVENT) 7723 alc883_tagra_automute(codec); 7724} 7725 7726/* toggle speaker-output according to the hp-jack state */ 7727static void alc883_clevo_m720_hp_automute(struct hda_codec *codec) 7728{ 7729 unsigned int present; 7730 unsigned char bits; 7731 7732 present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0) 7733 & AC_PINSENSE_PRESENCE; 7734 bits = present ? HDA_AMP_MUTE : 0; 7735 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 7736 HDA_AMP_MUTE, bits); 7737} 7738 7739static void alc883_clevo_m720_mic_automute(struct hda_codec *codec) 7740{ 7741 unsigned int present; 7742 7743 present = snd_hda_codec_read(codec, 0x18, 0, 7744 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7745 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, 7746 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7747} 7748 7749static void alc883_clevo_m720_automute(struct hda_codec *codec) 7750{ 7751 alc883_clevo_m720_hp_automute(codec); 7752 alc883_clevo_m720_mic_automute(codec); 7753} 7754 7755static void alc883_clevo_m720_unsol_event(struct hda_codec *codec, 7756 unsigned int res) 7757{ 7758 switch (res >> 26) { 7759 case ALC880_HP_EVENT: 7760 alc883_clevo_m720_hp_automute(codec); 7761 break; 7762 case ALC880_MIC_EVENT: 7763 alc883_clevo_m720_mic_automute(codec); 7764 break; 7765 } 7766} 7767 7768/* toggle speaker-output according to the hp-jack state */ 7769static void alc883_2ch_fujitsu_pi2515_automute(struct hda_codec *codec) 7770{ 7771 unsigned int present; 7772 unsigned char bits; 7773 7774 present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0) 7775 & AC_PINSENSE_PRESENCE; 7776 bits = present ? HDA_AMP_MUTE : 0; 7777 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 7778 HDA_AMP_MUTE, bits); 7779} 7780 7781static void alc883_2ch_fujitsu_pi2515_unsol_event(struct hda_codec *codec, 7782 unsigned int res) 7783{ 7784 if ((res >> 26) == ALC880_HP_EVENT) 7785 alc883_2ch_fujitsu_pi2515_automute(codec); 7786} 7787 7788static void alc883_haier_w66_automute(struct hda_codec *codec) 7789{ 7790 unsigned int present; 7791 unsigned char bits; 7792 7793 present = snd_hda_codec_read(codec, 0x1b, 0, 7794 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7795 bits = present ? 0x80 : 0; 7796 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 7797 0x80, bits); 7798} 7799 7800static void alc883_haier_w66_unsol_event(struct hda_codec *codec, 7801 unsigned int res) 7802{ 7803 if ((res >> 26) == ALC880_HP_EVENT) 7804 alc883_haier_w66_automute(codec); 7805} 7806 7807static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec) 7808{ 7809 unsigned int present; 7810 unsigned char bits; 7811 7812 present = snd_hda_codec_read(codec, 0x14, 0, 7813 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7814 bits = present ? HDA_AMP_MUTE : 0; 7815 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 7816 HDA_AMP_MUTE, bits); 7817} 7818 7819static void alc883_lenovo_101e_all_automute(struct hda_codec *codec) 7820{ 7821 unsigned int present; 7822 unsigned char bits; 7823 7824 present = snd_hda_codec_read(codec, 0x1b, 0, 7825 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7826 bits = present ? HDA_AMP_MUTE : 0; 7827 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 7828 HDA_AMP_MUTE, bits); 7829 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 7830 HDA_AMP_MUTE, bits); 7831} 7832 7833static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec, 7834 unsigned int res) 7835{ 7836 if ((res >> 26) == ALC880_HP_EVENT) 7837 alc883_lenovo_101e_all_automute(codec); 7838 if ((res >> 26) == ALC880_FRONT_EVENT) 7839 alc883_lenovo_101e_ispeaker_automute(codec); 7840} 7841 7842/* toggle speaker-output according to the hp-jack state */ 7843static void alc883_acer_aspire_automute(struct hda_codec *codec) 7844{ 7845 unsigned int present; 7846 7847 present = snd_hda_codec_read(codec, 0x14, 0, 7848 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7849 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 7850 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7851 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 7852 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7853} 7854 7855static void alc883_acer_aspire_unsol_event(struct hda_codec *codec, 7856 unsigned int res) 7857{ 7858 if ((res >> 26) == ALC880_HP_EVENT) 7859 alc883_acer_aspire_automute(codec); 7860} 7861 7862static struct hda_verb alc883_acer_eapd_verbs[] = { 7863 /* HP Pin: output 0 (0x0c) */ 7864 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 7865 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 7866 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 7867 /* Front Pin: output 0 (0x0c) */ 7868 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7869 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 7870 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 7871 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, 7872 /* eanable EAPD on medion laptop */ 7873 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 7874 {0x20, AC_VERB_SET_PROC_COEF, 0x3050}, 7875 /* enable unsolicited event */ 7876 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 7877 { } 7878}; 7879 7880static void alc888_6st_dell_front_automute(struct hda_codec *codec) 7881{ 7882 unsigned int present; 7883 7884 present = snd_hda_codec_read(codec, 0x1b, 0, 7885 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 7886 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 7887 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7888 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 7889 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7890 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 7891 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7892 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0, 7893 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 7894} 7895 7896static void alc888_6st_dell_unsol_event(struct hda_codec *codec, 7897 unsigned int res) 7898{ 7899 switch (res >> 26) { 7900 case ALC880_HP_EVENT: 7901 printk("hp_event\n"); 7902 alc888_6st_dell_front_automute(codec); 7903 break; 7904 } 7905} 7906 7907/* 7908 * generic initialization of ADC, input mixers and output mixers 7909 */ 7910static struct hda_verb alc883_auto_init_verbs[] = { 7911 /* 7912 * Unmute ADC0-2 and set the default input to mic-in 7913 */ 7914 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 7915 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7916 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 7917 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7918 7919 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 7920 * mixer widget 7921 * Note: PASD motherboards uses the Line In 2 as the input for 7922 * front panel mic (mic 2) 7923 */ 7924 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 7925 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 7926 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 7927 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 7928 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 7929 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 7930 7931 /* 7932 * Set up output mixers (0x0c - 0x0f) 7933 */ 7934 /* set vol=0 to output mixers */ 7935 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7936 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7937 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7938 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 7939 /* set up input amps for analog loopback */ 7940 /* Amp Indices: DAC = 0, mixer = 1 */ 7941 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7942 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7943 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7944 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7945 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7946 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7947 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7948 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7949 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7950 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7951 7952 /* FIXME: use matrix-type input source selection */ 7953 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 7954 /* Input mixer1 */ 7955 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7956 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7957 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 7958 /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */ 7959 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 7960 /* Input mixer2 */ 7961 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 7962 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 7963 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 7964 /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */ 7965 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 7966 7967 { } 7968}; 7969 7970/* capture mixer elements */ 7971static struct snd_kcontrol_new alc883_capture_mixer[] = { 7972 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 7973 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 7974 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), 7975 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), 7976 { 7977 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7978 /* The multiple "Capture Source" controls confuse alsamixer 7979 * So call somewhat different.. 7980 */ 7981 /* .name = "Capture Source", */ 7982 .name = "Input Source", 7983 .count = 2, 7984 .info = alc882_mux_enum_info, 7985 .get = alc882_mux_enum_get, 7986 .put = alc882_mux_enum_put, 7987 }, 7988 { } /* end */ 7989}; 7990 7991#ifdef CONFIG_SND_HDA_POWER_SAVE 7992#define alc883_loopbacks alc880_loopbacks 7993#endif 7994 7995/* pcm configuration: identiacal with ALC880 */ 7996#define alc883_pcm_analog_playback alc880_pcm_analog_playback 7997#define alc883_pcm_analog_capture alc880_pcm_analog_capture 7998#define alc883_pcm_analog_alt_capture alc880_pcm_analog_alt_capture 7999#define alc883_pcm_digital_playback alc880_pcm_digital_playback 8000#define alc883_pcm_digital_capture alc880_pcm_digital_capture 8001 8002/* 8003 * configuration and preset 8004 */ 8005static const char *alc883_models[ALC883_MODEL_LAST] = { 8006 [ALC883_3ST_2ch_DIG] = "3stack-dig", 8007 [ALC883_3ST_6ch_DIG] = "3stack-6ch-dig", 8008 [ALC883_3ST_6ch] = "3stack-6ch", 8009 [ALC883_6ST_DIG] = "6stack-dig", 8010 [ALC883_TARGA_DIG] = "targa-dig", 8011 [ALC883_TARGA_2ch_DIG] = "targa-2ch-dig", 8012 [ALC883_ACER] = "acer", 8013 [ALC883_ACER_ASPIRE] = "acer-aspire", 8014 [ALC883_MEDION] = "medion", 8015 [ALC883_MEDION_MD2] = "medion-md2", 8016 [ALC883_LAPTOP_EAPD] = "laptop-eapd", 8017 [ALC883_LENOVO_101E_2ch] = "lenovo-101e", 8018 [ALC883_LENOVO_NB0763] = "lenovo-nb0763", 8019 [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig", 8020 [ALC883_HAIER_W66] = "haier-w66", 8021 [ALC888_3ST_HP] = "3stack-hp", 8022 [ALC888_6ST_DELL] = "6stack-dell", 8023 [ALC883_MITAC] = "mitac", 8024 [ALC883_CLEVO_M720] = "clevo-m720", 8025 [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515", 8026 [ALC883_3ST_6ch_INTEL] = "3stack-6ch-intel", 8027 [ALC883_AUTO] = "auto", 8028}; 8029 8030static struct snd_pci_quirk alc883_cfg_tbl[] = { 8031 SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG), 8032 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE), 8033 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE), 8034 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE), 8035 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE), 8036 SND_PCI_QUIRK(0x1025, 0, "Acer laptop", ALC883_ACER), /* default Acer */ 8037 SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL), 8038 SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG), 8039 SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP), 8040 SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP), 8041 SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG), 8042 SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG), 8043 SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG), 8044 SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG), 8045 SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC), 8046 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD), 8047 SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch), 8048 SND_PCI_QUIRK(0x1458, 0xa002, "MSI", ALC883_6ST_DIG), 8049 SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG), 8050 SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG), 8051 SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG), 8052 SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG), 8053 SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG), 8054 SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG), 8055 SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG), 8056 SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG), 8057 SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG), 8058 SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG), 8059 SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG), 8060 SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG), 8061 SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG), 8062 SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG), 8063 SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG), 8064 SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG), 8065 SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG), 8066 SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG), 8067 SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG), 8068 SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG), 8069 SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG), 8070 SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG), 8071 SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG), 8072 SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720), 8073 SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720), 8074 SND_PCI_QUIRK(0x1558, 0, "Clevo laptop", ALC883_LAPTOP_EAPD), 8075 SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch), 8076 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION), 8077 SND_PCI_QUIRK(0x1734, 0x1108, "Fujitsu AMILO Pi2515", ALC883_FUJITSU_PI2515), 8078 SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch), 8079 SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763), 8080 SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763), 8081 SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763), 8082 SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2), 8083 SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG), 8084 SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66), 8085 SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL), 8086 SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL), 8087 SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch), 8088 {} 8089}; 8090 8091static struct alc_config_preset alc883_presets[] = { 8092 [ALC883_3ST_2ch_DIG] = { 8093 .mixers = { alc883_3ST_2ch_mixer }, 8094 .init_verbs = { alc883_init_verbs }, 8095 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8096 .dac_nids = alc883_dac_nids, 8097 .dig_out_nid = ALC883_DIGOUT_NID, 8098 .dig_in_nid = ALC883_DIGIN_NID, 8099 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8100 .channel_mode = alc883_3ST_2ch_modes, 8101 .input_mux = &alc883_capture_source, 8102 }, 8103 [ALC883_3ST_6ch_DIG] = { 8104 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 8105 .init_verbs = { alc883_init_verbs }, 8106 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8107 .dac_nids = alc883_dac_nids, 8108 .dig_out_nid = ALC883_DIGOUT_NID, 8109 .dig_in_nid = ALC883_DIGIN_NID, 8110 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 8111 .channel_mode = alc883_3ST_6ch_modes, 8112 .need_dac_fix = 1, 8113 .input_mux = &alc883_capture_source, 8114 }, 8115 [ALC883_3ST_6ch] = { 8116 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 8117 .init_verbs = { alc883_init_verbs }, 8118 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8119 .dac_nids = alc883_dac_nids, 8120 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 8121 .channel_mode = alc883_3ST_6ch_modes, 8122 .need_dac_fix = 1, 8123 .input_mux = &alc883_capture_source, 8124 }, 8125 [ALC883_3ST_6ch_INTEL] = { 8126 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer }, 8127 .init_verbs = { alc883_init_verbs }, 8128 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8129 .dac_nids = alc883_dac_nids, 8130 .dig_out_nid = ALC883_DIGOUT_NID, 8131 .dig_in_nid = ALC883_DIGIN_NID, 8132 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes), 8133 .channel_mode = alc883_3ST_6ch_intel_modes, 8134 .need_dac_fix = 1, 8135 .input_mux = &alc883_3stack_6ch_intel, 8136 }, 8137 [ALC883_6ST_DIG] = { 8138 .mixers = { alc883_base_mixer, alc883_chmode_mixer }, 8139 .init_verbs = { alc883_init_verbs }, 8140 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8141 .dac_nids = alc883_dac_nids, 8142 .dig_out_nid = ALC883_DIGOUT_NID, 8143 .dig_in_nid = ALC883_DIGIN_NID, 8144 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes), 8145 .channel_mode = alc883_sixstack_modes, 8146 .input_mux = &alc883_capture_source, 8147 }, 8148 [ALC883_TARGA_DIG] = { 8149 .mixers = { alc883_tagra_mixer, alc883_chmode_mixer }, 8150 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs}, 8151 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8152 .dac_nids = alc883_dac_nids, 8153 .dig_out_nid = ALC883_DIGOUT_NID, 8154 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 8155 .channel_mode = alc883_3ST_6ch_modes, 8156 .need_dac_fix = 1, 8157 .input_mux = &alc883_capture_source, 8158 .unsol_event = alc883_tagra_unsol_event, 8159 .init_hook = alc883_tagra_automute, 8160 }, 8161 [ALC883_TARGA_2ch_DIG] = { 8162 .mixers = { alc883_tagra_2ch_mixer}, 8163 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs}, 8164 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8165 .dac_nids = alc883_dac_nids, 8166 .dig_out_nid = ALC883_DIGOUT_NID, 8167 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8168 .channel_mode = alc883_3ST_2ch_modes, 8169 .input_mux = &alc883_capture_source, 8170 .unsol_event = alc883_tagra_unsol_event, 8171 .init_hook = alc883_tagra_automute, 8172 }, 8173 [ALC883_ACER] = { 8174 .mixers = { alc883_base_mixer }, 8175 /* On TravelMate laptops, GPIO 0 enables the internal speaker 8176 * and the headphone jack. Turn this on and rely on the 8177 * standard mute methods whenever the user wants to turn 8178 * these outputs off. 8179 */ 8180 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs }, 8181 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8182 .dac_nids = alc883_dac_nids, 8183 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8184 .channel_mode = alc883_3ST_2ch_modes, 8185 .input_mux = &alc883_capture_source, 8186 }, 8187 [ALC883_ACER_ASPIRE] = { 8188 .mixers = { alc883_acer_aspire_mixer }, 8189 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs }, 8190 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8191 .dac_nids = alc883_dac_nids, 8192 .dig_out_nid = ALC883_DIGOUT_NID, 8193 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8194 .channel_mode = alc883_3ST_2ch_modes, 8195 .input_mux = &alc883_capture_source, 8196 .unsol_event = alc883_acer_aspire_unsol_event, 8197 .init_hook = alc883_acer_aspire_automute, 8198 }, 8199 [ALC883_MEDION] = { 8200 .mixers = { alc883_fivestack_mixer, 8201 alc883_chmode_mixer }, 8202 .init_verbs = { alc883_init_verbs, 8203 alc883_medion_eapd_verbs }, 8204 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8205 .dac_nids = alc883_dac_nids, 8206 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes), 8207 .channel_mode = alc883_sixstack_modes, 8208 .input_mux = &alc883_capture_source, 8209 }, 8210 [ALC883_MEDION_MD2] = { 8211 .mixers = { alc883_medion_md2_mixer}, 8212 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs}, 8213 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8214 .dac_nids = alc883_dac_nids, 8215 .dig_out_nid = ALC883_DIGOUT_NID, 8216 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8217 .channel_mode = alc883_3ST_2ch_modes, 8218 .input_mux = &alc883_capture_source, 8219 .unsol_event = alc883_medion_md2_unsol_event, 8220 .init_hook = alc883_medion_md2_automute, 8221 }, 8222 [ALC883_LAPTOP_EAPD] = { 8223 .mixers = { alc883_base_mixer }, 8224 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs }, 8225 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8226 .dac_nids = alc883_dac_nids, 8227 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8228 .channel_mode = alc883_3ST_2ch_modes, 8229 .input_mux = &alc883_capture_source, 8230 }, 8231 [ALC883_CLEVO_M720] = { 8232 .mixers = { alc883_clevo_m720_mixer }, 8233 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs }, 8234 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8235 .dac_nids = alc883_dac_nids, 8236 .dig_out_nid = ALC883_DIGOUT_NID, 8237 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8238 .channel_mode = alc883_3ST_2ch_modes, 8239 .input_mux = &alc883_capture_source, 8240 .unsol_event = alc883_clevo_m720_unsol_event, 8241 .init_hook = alc883_clevo_m720_automute, 8242 }, 8243 [ALC883_LENOVO_101E_2ch] = { 8244 .mixers = { alc883_lenovo_101e_2ch_mixer}, 8245 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs}, 8246 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8247 .dac_nids = alc883_dac_nids, 8248 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8249 .channel_mode = alc883_3ST_2ch_modes, 8250 .input_mux = &alc883_lenovo_101e_capture_source, 8251 .unsol_event = alc883_lenovo_101e_unsol_event, 8252 .init_hook = alc883_lenovo_101e_all_automute, 8253 }, 8254 [ALC883_LENOVO_NB0763] = { 8255 .mixers = { alc883_lenovo_nb0763_mixer }, 8256 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs}, 8257 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8258 .dac_nids = alc883_dac_nids, 8259 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8260 .channel_mode = alc883_3ST_2ch_modes, 8261 .need_dac_fix = 1, 8262 .input_mux = &alc883_lenovo_nb0763_capture_source, 8263 .unsol_event = alc883_medion_md2_unsol_event, 8264 .init_hook = alc883_medion_md2_automute, 8265 }, 8266 [ALC888_LENOVO_MS7195_DIG] = { 8267 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 8268 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs}, 8269 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8270 .dac_nids = alc883_dac_nids, 8271 .dig_out_nid = ALC883_DIGOUT_NID, 8272 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes), 8273 .channel_mode = alc883_3ST_6ch_modes, 8274 .need_dac_fix = 1, 8275 .input_mux = &alc883_capture_source, 8276 .unsol_event = alc883_lenovo_ms7195_unsol_event, 8277 .init_hook = alc888_lenovo_ms7195_front_automute, 8278 }, 8279 [ALC883_HAIER_W66] = { 8280 .mixers = { alc883_tagra_2ch_mixer}, 8281 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs}, 8282 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8283 .dac_nids = alc883_dac_nids, 8284 .dig_out_nid = ALC883_DIGOUT_NID, 8285 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8286 .channel_mode = alc883_3ST_2ch_modes, 8287 .input_mux = &alc883_capture_source, 8288 .unsol_event = alc883_haier_w66_unsol_event, 8289 .init_hook = alc883_haier_w66_automute, 8290 }, 8291 [ALC888_3ST_HP] = { 8292 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer }, 8293 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs }, 8294 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8295 .dac_nids = alc883_dac_nids, 8296 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes), 8297 .channel_mode = alc888_3st_hp_modes, 8298 .need_dac_fix = 1, 8299 .input_mux = &alc883_capture_source, 8300 }, 8301 [ALC888_6ST_DELL] = { 8302 .mixers = { alc883_base_mixer, alc883_chmode_mixer }, 8303 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs }, 8304 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8305 .dac_nids = alc883_dac_nids, 8306 .dig_out_nid = ALC883_DIGOUT_NID, 8307 .dig_in_nid = ALC883_DIGIN_NID, 8308 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes), 8309 .channel_mode = alc883_sixstack_modes, 8310 .input_mux = &alc883_capture_source, 8311 .unsol_event = alc888_6st_dell_unsol_event, 8312 .init_hook = alc888_6st_dell_front_automute, 8313 }, 8314 [ALC883_MITAC] = { 8315 .mixers = { alc883_mitac_mixer }, 8316 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs }, 8317 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8318 .dac_nids = alc883_dac_nids, 8319 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8320 .channel_mode = alc883_3ST_2ch_modes, 8321 .input_mux = &alc883_capture_source, 8322 .unsol_event = alc883_mitac_unsol_event, 8323 .init_hook = alc883_mitac_automute, 8324 }, 8325 [ALC883_FUJITSU_PI2515] = { 8326 .mixers = { alc883_2ch_fujitsu_pi2515_mixer }, 8327 .init_verbs = { alc883_init_verbs, 8328 alc883_2ch_fujitsu_pi2515_verbs}, 8329 .num_dacs = ARRAY_SIZE(alc883_dac_nids), 8330 .dac_nids = alc883_dac_nids, 8331 .dig_out_nid = ALC883_DIGOUT_NID, 8332 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 8333 .channel_mode = alc883_3ST_2ch_modes, 8334 .input_mux = &alc883_fujitsu_pi2515_capture_source, 8335 .unsol_event = alc883_2ch_fujitsu_pi2515_unsol_event, 8336 .init_hook = alc883_2ch_fujitsu_pi2515_automute, 8337 }, 8338}; 8339 8340 8341/* 8342 * BIOS auto configuration 8343 */ 8344static void alc883_auto_set_output_and_unmute(struct hda_codec *codec, 8345 hda_nid_t nid, int pin_type, 8346 int dac_idx) 8347{ 8348 /* set as output */ 8349 struct alc_spec *spec = codec->spec; 8350 int idx; 8351 8352 alc_set_pin_output(codec, nid, pin_type); 8353 if (spec->multiout.dac_nids[dac_idx] == 0x25) 8354 idx = 4; 8355 else 8356 idx = spec->multiout.dac_nids[dac_idx] - 2; 8357 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx); 8358 8359} 8360 8361static void alc883_auto_init_multi_out(struct hda_codec *codec) 8362{ 8363 struct alc_spec *spec = codec->spec; 8364 int i; 8365 8366 alc_subsystem_id(codec, 0x15, 0x1b, 0x14); 8367 for (i = 0; i <= HDA_SIDE; i++) { 8368 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 8369 int pin_type = get_pin_type(spec->autocfg.line_out_type); 8370 if (nid) 8371 alc883_auto_set_output_and_unmute(codec, nid, pin_type, 8372 i); 8373 } 8374} 8375 8376static void alc883_auto_init_hp_out(struct hda_codec *codec) 8377{ 8378 struct alc_spec *spec = codec->spec; 8379 hda_nid_t pin; 8380 8381 pin = spec->autocfg.hp_pins[0]; 8382 if (pin) /* connect to front */ 8383 /* use dac 0 */ 8384 alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 8385 pin = spec->autocfg.speaker_pins[0]; 8386 if (pin) 8387 alc883_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 8388} 8389 8390#define alc883_is_input_pin(nid) alc880_is_input_pin(nid) 8391#define ALC883_PIN_CD_NID ALC880_PIN_CD_NID 8392 8393static void alc883_auto_init_analog_input(struct hda_codec *codec) 8394{ 8395 struct alc_spec *spec = codec->spec; 8396 int i; 8397 8398 for (i = 0; i < AUTO_PIN_LAST; i++) { 8399 hda_nid_t nid = spec->autocfg.input_pins[i]; 8400 if (alc883_is_input_pin(nid)) { 8401 snd_hda_codec_write(codec, nid, 0, 8402 AC_VERB_SET_PIN_WIDGET_CONTROL, 8403 (i <= AUTO_PIN_FRONT_MIC ? 8404 PIN_VREF80 : PIN_IN)); 8405 if (nid != ALC883_PIN_CD_NID) 8406 snd_hda_codec_write(codec, nid, 0, 8407 AC_VERB_SET_AMP_GAIN_MUTE, 8408 AMP_OUT_MUTE); 8409 } 8410 } 8411} 8412 8413#define alc883_auto_init_input_src alc882_auto_init_input_src 8414 8415/* almost identical with ALC880 parser... */ 8416static int alc883_parse_auto_config(struct hda_codec *codec) 8417{ 8418 struct alc_spec *spec = codec->spec; 8419 int err = alc880_parse_auto_config(codec); 8420 8421 if (err < 0) 8422 return err; 8423 else if (!err) 8424 return 0; /* no config found */ 8425 8426 err = alc_auto_add_mic_boost(codec); 8427 if (err < 0) 8428 return err; 8429 8430 /* hack - override the init verbs */ 8431 spec->init_verbs[0] = alc883_auto_init_verbs; 8432 spec->mixers[spec->num_mixers] = alc883_capture_mixer; 8433 spec->num_mixers++; 8434 8435 return 1; /* config found */ 8436} 8437 8438/* additional initialization for auto-configuration model */ 8439static void alc883_auto_init(struct hda_codec *codec) 8440{ 8441 struct alc_spec *spec = codec->spec; 8442 alc883_auto_init_multi_out(codec); 8443 alc883_auto_init_hp_out(codec); 8444 alc883_auto_init_analog_input(codec); 8445 alc883_auto_init_input_src(codec); 8446 if (spec->unsol_event) 8447 alc_sku_automute(codec); 8448} 8449 8450static int patch_alc883(struct hda_codec *codec) 8451{ 8452 struct alc_spec *spec; 8453 int err, board_config; 8454 8455 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 8456 if (spec == NULL) 8457 return -ENOMEM; 8458 8459 codec->spec = spec; 8460 8461 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 8462 8463 board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST, 8464 alc883_models, 8465 alc883_cfg_tbl); 8466 if (board_config < 0) { 8467 printk(KERN_INFO "hda_codec: Unknown model for ALC883, " 8468 "trying auto-probe from BIOS...\n"); 8469 board_config = ALC883_AUTO; 8470 } 8471 8472 if (board_config == ALC883_AUTO) { 8473 /* automatic parse from the BIOS config */ 8474 err = alc883_parse_auto_config(codec); 8475 if (err < 0) { 8476 alc_free(codec); 8477 return err; 8478 } else if (!err) { 8479 printk(KERN_INFO 8480 "hda_codec: Cannot set up configuration " 8481 "from BIOS. Using base mode...\n"); 8482 board_config = ALC883_3ST_2ch_DIG; 8483 } 8484 } 8485 8486 if (board_config != ALC883_AUTO) 8487 setup_preset(spec, &alc883_presets[board_config]); 8488 8489 switch (codec->vendor_id) { 8490 case 0x10ec0888: 8491 spec->stream_name_analog = "ALC888 Analog"; 8492 spec->stream_name_digital = "ALC888 Digital"; 8493 break; 8494 case 0x10ec0889: 8495 spec->stream_name_analog = "ALC889 Analog"; 8496 spec->stream_name_digital = "ALC889 Digital"; 8497 break; 8498 default: 8499 spec->stream_name_analog = "ALC883 Analog"; 8500 spec->stream_name_digital = "ALC883 Digital"; 8501 break; 8502 } 8503 8504 spec->stream_analog_playback = &alc883_pcm_analog_playback; 8505 spec->stream_analog_capture = &alc883_pcm_analog_capture; 8506 spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture; 8507 8508 spec->stream_digital_playback = &alc883_pcm_digital_playback; 8509 spec->stream_digital_capture = &alc883_pcm_digital_capture; 8510 8511 spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids); 8512 spec->adc_nids = alc883_adc_nids; 8513 spec->capsrc_nids = alc883_capsrc_nids; 8514 8515 spec->vmaster_nid = 0x0c; 8516 8517 codec->patch_ops = alc_patch_ops; 8518 if (board_config == ALC883_AUTO) 8519 spec->init_hook = alc883_auto_init; 8520 8521#ifdef CONFIG_SND_HDA_POWER_SAVE 8522 if (!spec->loopback.amplist) 8523 spec->loopback.amplist = alc883_loopbacks; 8524#endif 8525 8526 return 0; 8527} 8528 8529/* 8530 * ALC262 support 8531 */ 8532 8533#define ALC262_DIGOUT_NID ALC880_DIGOUT_NID 8534#define ALC262_DIGIN_NID ALC880_DIGIN_NID 8535 8536#define alc262_dac_nids alc260_dac_nids 8537#define alc262_adc_nids alc882_adc_nids 8538#define alc262_adc_nids_alt alc882_adc_nids_alt 8539#define alc262_capsrc_nids alc882_capsrc_nids 8540#define alc262_capsrc_nids_alt alc882_capsrc_nids_alt 8541 8542#define alc262_modes alc260_modes 8543#define alc262_capture_source alc882_capture_source 8544 8545static hda_nid_t alc262_dmic_adc_nids[1] = { 8546 /* ADC0 */ 8547 0x09 8548}; 8549 8550static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 }; 8551 8552static struct snd_kcontrol_new alc262_base_mixer[] = { 8553 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8554 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 8555 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 8556 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 8557 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 8558 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 8559 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8560 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8561 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 8562 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 8563 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 8564 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 8565 /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT), 8566 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */ 8567 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT), 8568 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 8569 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), 8570 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT), 8571 { } /* end */ 8572}; 8573 8574static struct snd_kcontrol_new alc262_hippo1_mixer[] = { 8575 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8576 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 8577 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 8578 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 8579 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 8580 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 8581 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8582 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8583 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 8584 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 8585 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 8586 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 8587 /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT), 8588 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */ 8589 /*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/ 8590 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 8591 { } /* end */ 8592}; 8593 8594/* update HP, line and mono-out pins according to the master switch */ 8595static void alc262_hp_master_update(struct hda_codec *codec) 8596{ 8597 struct alc_spec *spec = codec->spec; 8598 int val = spec->master_sw; 8599 8600 /* HP & line-out */ 8601 snd_hda_codec_write_cache(codec, 0x1b, 0, 8602 AC_VERB_SET_PIN_WIDGET_CONTROL, 8603 val ? PIN_HP : 0); 8604 snd_hda_codec_write_cache(codec, 0x15, 0, 8605 AC_VERB_SET_PIN_WIDGET_CONTROL, 8606 val ? PIN_HP : 0); 8607 /* mono (speaker) depending on the HP jack sense */ 8608 val = val && !spec->jack_present; 8609 snd_hda_codec_write_cache(codec, 0x16, 0, 8610 AC_VERB_SET_PIN_WIDGET_CONTROL, 8611 val ? PIN_OUT : 0); 8612} 8613 8614static void alc262_hp_bpc_automute(struct hda_codec *codec) 8615{ 8616 struct alc_spec *spec = codec->spec; 8617 unsigned int presence; 8618 presence = snd_hda_codec_read(codec, 0x1b, 0, 8619 AC_VERB_GET_PIN_SENSE, 0); 8620 spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE); 8621 alc262_hp_master_update(codec); 8622} 8623 8624static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res) 8625{ 8626 if ((res >> 26) != ALC880_HP_EVENT) 8627 return; 8628 alc262_hp_bpc_automute(codec); 8629} 8630 8631static void alc262_hp_wildwest_automute(struct hda_codec *codec) 8632{ 8633 struct alc_spec *spec = codec->spec; 8634 unsigned int presence; 8635 presence = snd_hda_codec_read(codec, 0x15, 0, 8636 AC_VERB_GET_PIN_SENSE, 0); 8637 spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE); 8638 alc262_hp_master_update(codec); 8639} 8640 8641static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec, 8642 unsigned int res) 8643{ 8644 if ((res >> 26) != ALC880_HP_EVENT) 8645 return; 8646 alc262_hp_wildwest_automute(codec); 8647} 8648 8649static int alc262_hp_master_sw_get(struct snd_kcontrol *kcontrol, 8650 struct snd_ctl_elem_value *ucontrol) 8651{ 8652 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 8653 struct alc_spec *spec = codec->spec; 8654 *ucontrol->value.integer.value = spec->master_sw; 8655 return 0; 8656} 8657 8658static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol, 8659 struct snd_ctl_elem_value *ucontrol) 8660{ 8661 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 8662 struct alc_spec *spec = codec->spec; 8663 int val = !!*ucontrol->value.integer.value; 8664 8665 if (val == spec->master_sw) 8666 return 0; 8667 spec->master_sw = val; 8668 alc262_hp_master_update(codec); 8669 return 1; 8670} 8671 8672static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = { 8673 { 8674 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 8675 .name = "Master Playback Switch", 8676 .info = snd_ctl_boolean_mono_info, 8677 .get = alc262_hp_master_sw_get, 8678 .put = alc262_hp_master_sw_put, 8679 }, 8680 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8681 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT), 8682 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 8683 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0, 8684 HDA_OUTPUT), 8685 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0, 8686 HDA_OUTPUT), 8687 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8688 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8689 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 8690 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 8691 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 8692 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 8693 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 8694 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 8695 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 8696 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 8697 HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT), 8698 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), 8699 HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT), 8700 HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT), 8701 { } /* end */ 8702}; 8703 8704static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = { 8705 { 8706 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 8707 .name = "Master Playback Switch", 8708 .info = snd_ctl_boolean_mono_info, 8709 .get = alc262_hp_master_sw_get, 8710 .put = alc262_hp_master_sw_put, 8711 }, 8712 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8713 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 8714 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 8715 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 8716 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0, 8717 HDA_OUTPUT), 8718 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0, 8719 HDA_OUTPUT), 8720 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT), 8721 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT), 8722 HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT), 8723 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT), 8724 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT), 8725 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 8726 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 8727 HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT), 8728 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), 8729 { } /* end */ 8730}; 8731 8732static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = { 8733 HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8734 HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8735 HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT), 8736 { } /* end */ 8737}; 8738 8739/* mute/unmute internal speaker according to the hp jack and mute state */ 8740static void alc262_hp_t5735_automute(struct hda_codec *codec, int force) 8741{ 8742 struct alc_spec *spec = codec->spec; 8743 8744 if (force || !spec->sense_updated) { 8745 unsigned int present; 8746 present = snd_hda_codec_read(codec, 0x15, 0, 8747 AC_VERB_GET_PIN_SENSE, 0); 8748 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0; 8749 spec->sense_updated = 1; 8750 } 8751 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, HDA_AMP_MUTE, 8752 spec->jack_present ? HDA_AMP_MUTE : 0); 8753} 8754 8755static void alc262_hp_t5735_unsol_event(struct hda_codec *codec, 8756 unsigned int res) 8757{ 8758 if ((res >> 26) != ALC880_HP_EVENT) 8759 return; 8760 alc262_hp_t5735_automute(codec, 1); 8761} 8762 8763static void alc262_hp_t5735_init_hook(struct hda_codec *codec) 8764{ 8765 alc262_hp_t5735_automute(codec, 1); 8766} 8767 8768static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = { 8769 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8770 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 8771 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 8772 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 8773 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8774 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8775 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 8776 { } /* end */ 8777}; 8778 8779static struct hda_verb alc262_hp_t5735_verbs[] = { 8780 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8781 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8782 8783 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 8784 { } 8785}; 8786 8787static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = { 8788 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8789 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 8790 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT), 8791 HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT), 8792 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT), 8793 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT), 8794 { } /* end */ 8795}; 8796 8797static struct hda_verb alc262_hp_rp5700_verbs[] = { 8798 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8799 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 8800 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8801 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 8802 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 8803 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 8804 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 8805 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 8806 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))}, 8807 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))}, 8808 {} 8809}; 8810 8811static struct hda_input_mux alc262_hp_rp5700_capture_source = { 8812 .num_items = 1, 8813 .items = { 8814 { "Line", 0x1 }, 8815 }, 8816}; 8817 8818/* bind hp and internal speaker mute (with plug check) */ 8819static int alc262_sony_master_sw_put(struct snd_kcontrol *kcontrol, 8820 struct snd_ctl_elem_value *ucontrol) 8821{ 8822 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 8823 long *valp = ucontrol->value.integer.value; 8824 int change; 8825 8826 /* change hp mute */ 8827 change = snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0, 8828 HDA_AMP_MUTE, 8829 valp[0] ? 0 : HDA_AMP_MUTE); 8830 change |= snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0, 8831 HDA_AMP_MUTE, 8832 valp[1] ? 0 : HDA_AMP_MUTE); 8833 if (change) { 8834 /* change speaker according to HP jack state */ 8835 struct alc_spec *spec = codec->spec; 8836 unsigned int mute; 8837 if (spec->jack_present) 8838 mute = HDA_AMP_MUTE; 8839 else 8840 mute = snd_hda_codec_amp_read(codec, 0x15, 0, 8841 HDA_OUTPUT, 0); 8842 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 8843 HDA_AMP_MUTE, mute); 8844 } 8845 return change; 8846} 8847 8848static struct snd_kcontrol_new alc262_sony_mixer[] = { 8849 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8850 { 8851 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 8852 .name = "Master Playback Switch", 8853 .info = snd_hda_mixer_amp_switch_info, 8854 .get = snd_hda_mixer_amp_switch_get, 8855 .put = alc262_sony_master_sw_put, 8856 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT), 8857 }, 8858 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8859 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8860 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 8861 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 8862 { } /* end */ 8863}; 8864 8865static struct snd_kcontrol_new alc262_benq_t31_mixer[] = { 8866 HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 8867 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 8868 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 8869 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 8870 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 8871 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 8872 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 8873 { } /* end */ 8874}; 8875 8876#define alc262_capture_mixer alc882_capture_mixer 8877#define alc262_capture_alt_mixer alc882_capture_alt_mixer 8878 8879/* 8880 * generic initialization of ADC, input mixers and output mixers 8881 */ 8882static struct hda_verb alc262_init_verbs[] = { 8883 /* 8884 * Unmute ADC0-2 and set the default input to mic-in 8885 */ 8886 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 8887 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8888 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 8889 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8890 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 8891 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8892 8893 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 8894 * mixer widget 8895 * Note: PASD motherboards uses the Line In 2 as the input for 8896 * front panel mic (mic 2) 8897 */ 8898 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 8899 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 8900 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 8901 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 8902 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 8903 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 8904 8905 /* 8906 * Set up output mixers (0x0c - 0x0e) 8907 */ 8908 /* set vol=0 to output mixers */ 8909 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8910 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8911 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 8912 /* set up input amps for analog loopback */ 8913 /* Amp Indices: DAC = 0, mixer = 1 */ 8914 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8915 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8916 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8917 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8918 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 8919 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 8920 8921 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 8922 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 8923 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 8924 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 8925 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 8926 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 8927 8928 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 8929 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 8930 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 8931 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 8932 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 8933 8934 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 8935 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 8936 8937 /* FIXME: use matrix-type input source selection */ 8938 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 8939 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 8940 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 8941 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 8942 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 8943 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 8944 /* Input mixer2 */ 8945 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 8946 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 8947 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 8948 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 8949 /* Input mixer3 */ 8950 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 8951 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 8952 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 8953 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 8954 8955 { } 8956}; 8957 8958static struct hda_verb alc262_eapd_verbs[] = { 8959 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 8960 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 8961 { } 8962}; 8963 8964static struct hda_verb alc262_hippo_unsol_verbs[] = { 8965 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 8966 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8967 {} 8968}; 8969 8970static struct hda_verb alc262_hippo1_unsol_verbs[] = { 8971 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 8972 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 8973 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, 8974 8975 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 8976 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8977 {} 8978}; 8979 8980static struct hda_verb alc262_sony_unsol_verbs[] = { 8981 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 8982 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 8983 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, // Front Mic 8984 8985 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 8986 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 8987 {} 8988}; 8989 8990static struct hda_input_mux alc262_dmic_capture_source = { 8991 .num_items = 2, 8992 .items = { 8993 { "Int DMic", 0x9 }, 8994 { "Mic", 0x0 }, 8995 }, 8996}; 8997 8998static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = { 8999 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9000 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 9001 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 9002 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9003 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9004 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT), 9005 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT), 9006 { 9007 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 9008 /* The multiple "Capture Source" controls confuse alsamixer 9009 * So call somewhat different.. 9010 */ 9011 /* .name = "Capture Source", */ 9012 .name = "Input Source", 9013 .count = 1, 9014 .info = alc_mux_enum_info, 9015 .get = alc_mux_enum_get, 9016 .put = alc_mux_enum_put, 9017 }, 9018 { } /* end */ 9019}; 9020 9021static struct hda_verb alc262_toshiba_s06_verbs[] = { 9022 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 9023 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9024 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9025 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 9026 {0x22, AC_VERB_SET_CONNECT_SEL, 0x09}, 9027 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 9028 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 9029 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 9030 {} 9031}; 9032 9033static void alc262_dmic_automute(struct hda_codec *codec) 9034{ 9035 unsigned int present; 9036 9037 present = snd_hda_codec_read(codec, 0x18, 0, 9038 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 9039 snd_hda_codec_write(codec, 0x22, 0, 9040 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x09); 9041} 9042 9043/* toggle speaker-output according to the hp-jack state */ 9044static void alc262_toshiba_s06_speaker_automute(struct hda_codec *codec) 9045{ 9046 unsigned int present; 9047 unsigned char bits; 9048 9049 present = snd_hda_codec_read(codec, 0x15, 0, 9050 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 9051 bits = present ? 0 : PIN_OUT; 9052 snd_hda_codec_write(codec, 0x14, 0, 9053 AC_VERB_SET_PIN_WIDGET_CONTROL, bits); 9054} 9055 9056 9057 9058/* unsolicited event for HP jack sensing */ 9059static void alc262_toshiba_s06_unsol_event(struct hda_codec *codec, 9060 unsigned int res) 9061{ 9062 if ((res >> 26) == ALC880_HP_EVENT) 9063 alc262_toshiba_s06_speaker_automute(codec); 9064 if ((res >> 26) == ALC880_MIC_EVENT) 9065 alc262_dmic_automute(codec); 9066 9067} 9068 9069static void alc262_toshiba_s06_init_hook(struct hda_codec *codec) 9070{ 9071 alc262_toshiba_s06_speaker_automute(codec); 9072 alc262_dmic_automute(codec); 9073} 9074 9075/* mute/unmute internal speaker according to the hp jack and mute state */ 9076static void alc262_hippo_automute(struct hda_codec *codec) 9077{ 9078 struct alc_spec *spec = codec->spec; 9079 unsigned int mute; 9080 unsigned int present; 9081 9082 /* need to execute and sync at first */ 9083 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0); 9084 present = snd_hda_codec_read(codec, 0x15, 0, 9085 AC_VERB_GET_PIN_SENSE, 0); 9086 spec->jack_present = (present & 0x80000000) != 0; 9087 if (spec->jack_present) { 9088 /* mute internal speaker */ 9089 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9090 HDA_AMP_MUTE, HDA_AMP_MUTE); 9091 } else { 9092 /* unmute internal speaker if necessary */ 9093 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0); 9094 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9095 HDA_AMP_MUTE, mute); 9096 } 9097} 9098 9099/* unsolicited event for HP jack sensing */ 9100static void alc262_hippo_unsol_event(struct hda_codec *codec, 9101 unsigned int res) 9102{ 9103 if ((res >> 26) != ALC880_HP_EVENT) 9104 return; 9105 alc262_hippo_automute(codec); 9106} 9107 9108static void alc262_hippo1_automute(struct hda_codec *codec) 9109{ 9110 unsigned int mute; 9111 unsigned int present; 9112 9113 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0); 9114 present = snd_hda_codec_read(codec, 0x1b, 0, 9115 AC_VERB_GET_PIN_SENSE, 0); 9116 present = (present & 0x80000000) != 0; 9117 if (present) { 9118 /* mute internal speaker */ 9119 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9120 HDA_AMP_MUTE, HDA_AMP_MUTE); 9121 } else { 9122 /* unmute internal speaker if necessary */ 9123 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0); 9124 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9125 HDA_AMP_MUTE, mute); 9126 } 9127} 9128 9129/* unsolicited event for HP jack sensing */ 9130static void alc262_hippo1_unsol_event(struct hda_codec *codec, 9131 unsigned int res) 9132{ 9133 if ((res >> 26) != ALC880_HP_EVENT) 9134 return; 9135 alc262_hippo1_automute(codec); 9136} 9137 9138/* 9139 * nec model 9140 * 0x15 = headphone 9141 * 0x16 = internal speaker 9142 * 0x18 = external mic 9143 */ 9144 9145static struct snd_kcontrol_new alc262_nec_mixer[] = { 9146 HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT), 9147 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT), 9148 9149 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9150 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9151 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 9152 9153 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT), 9154 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 9155 { } /* end */ 9156}; 9157 9158static struct hda_verb alc262_nec_verbs[] = { 9159 /* Unmute Speaker */ 9160 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 9161 9162 /* Headphone */ 9163 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 9164 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9165 9166 /* External mic to headphone */ 9167 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9168 /* External mic to speaker */ 9169 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9170 {} 9171}; 9172 9173/* 9174 * fujitsu model 9175 * 0x14 = headphone/spdif-out, 0x15 = internal speaker, 9176 * 0x1b = port replicator headphone out 9177 */ 9178 9179#define ALC_HP_EVENT 0x37 9180 9181static struct hda_verb alc262_fujitsu_unsol_verbs[] = { 9182 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT}, 9183 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9184 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT}, 9185 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9186 {} 9187}; 9188 9189static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = { 9190 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT}, 9191 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9192 {} 9193}; 9194 9195static struct hda_input_mux alc262_fujitsu_capture_source = { 9196 .num_items = 3, 9197 .items = { 9198 { "Mic", 0x0 }, 9199 { "Int Mic", 0x1 }, 9200 { "CD", 0x4 }, 9201 }, 9202}; 9203 9204static struct hda_input_mux alc262_HP_capture_source = { 9205 .num_items = 5, 9206 .items = { 9207 { "Mic", 0x0 }, 9208 { "Front Mic", 0x1 }, 9209 { "Line", 0x2 }, 9210 { "CD", 0x4 }, 9211 { "AUX IN", 0x6 }, 9212 }, 9213}; 9214 9215static struct hda_input_mux alc262_HP_D7000_capture_source = { 9216 .num_items = 4, 9217 .items = { 9218 { "Mic", 0x0 }, 9219 { "Front Mic", 0x2 }, 9220 { "Line", 0x1 }, 9221 { "CD", 0x4 }, 9222 }, 9223}; 9224 9225/* mute/unmute internal speaker according to the hp jacks and mute state */ 9226static void alc262_fujitsu_automute(struct hda_codec *codec, int force) 9227{ 9228 struct alc_spec *spec = codec->spec; 9229 unsigned int mute; 9230 9231 if (force || !spec->sense_updated) { 9232 unsigned int present; 9233 /* need to execute and sync at first */ 9234 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0); 9235 /* check laptop HP jack */ 9236 present = snd_hda_codec_read(codec, 0x14, 0, 9237 AC_VERB_GET_PIN_SENSE, 0); 9238 /* need to execute and sync at first */ 9239 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0); 9240 /* check docking HP jack */ 9241 present |= snd_hda_codec_read(codec, 0x1b, 0, 9242 AC_VERB_GET_PIN_SENSE, 0); 9243 if (present & AC_PINSENSE_PRESENCE) 9244 spec->jack_present = 1; 9245 else 9246 spec->jack_present = 0; 9247 spec->sense_updated = 1; 9248 } 9249 /* unmute internal speaker only if both HPs are unplugged and 9250 * master switch is on 9251 */ 9252 if (spec->jack_present) 9253 mute = HDA_AMP_MUTE; 9254 else 9255 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0); 9256 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 9257 HDA_AMP_MUTE, mute); 9258} 9259 9260/* unsolicited event for HP jack sensing */ 9261static void alc262_fujitsu_unsol_event(struct hda_codec *codec, 9262 unsigned int res) 9263{ 9264 if ((res >> 26) != ALC_HP_EVENT) 9265 return; 9266 alc262_fujitsu_automute(codec, 1); 9267} 9268 9269static void alc262_fujitsu_init_hook(struct hda_codec *codec) 9270{ 9271 alc262_fujitsu_automute(codec, 1); 9272} 9273 9274/* bind volumes of both NID 0x0c and 0x0d */ 9275static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = { 9276 .ops = &snd_hda_bind_vol, 9277 .values = { 9278 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT), 9279 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT), 9280 0 9281 }, 9282}; 9283 9284/* mute/unmute internal speaker according to the hp jack and mute state */ 9285static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force) 9286{ 9287 struct alc_spec *spec = codec->spec; 9288 unsigned int mute; 9289 9290 if (force || !spec->sense_updated) { 9291 unsigned int present_int_hp; 9292 /* need to execute and sync at first */ 9293 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0); 9294 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0, 9295 AC_VERB_GET_PIN_SENSE, 0); 9296 spec->jack_present = (present_int_hp & 0x80000000) != 0; 9297 spec->sense_updated = 1; 9298 } 9299 if (spec->jack_present) { 9300 /* mute internal speaker */ 9301 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9302 HDA_AMP_MUTE, HDA_AMP_MUTE); 9303 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 9304 HDA_AMP_MUTE, HDA_AMP_MUTE); 9305 } else { 9306 /* unmute internal speaker if necessary */ 9307 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0); 9308 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9309 HDA_AMP_MUTE, mute); 9310 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 9311 HDA_AMP_MUTE, mute); 9312 } 9313} 9314 9315/* unsolicited event for HP jack sensing */ 9316static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec, 9317 unsigned int res) 9318{ 9319 if ((res >> 26) != ALC_HP_EVENT) 9320 return; 9321 alc262_lenovo_3000_automute(codec, 1); 9322} 9323 9324/* bind hp and internal speaker mute (with plug check) */ 9325static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol, 9326 struct snd_ctl_elem_value *ucontrol) 9327{ 9328 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 9329 long *valp = ucontrol->value.integer.value; 9330 int change; 9331 9332 change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9333 HDA_AMP_MUTE, 9334 valp ? 0 : HDA_AMP_MUTE); 9335 change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 9336 HDA_AMP_MUTE, 9337 valp ? 0 : HDA_AMP_MUTE); 9338 9339 if (change) 9340 alc262_fujitsu_automute(codec, 0); 9341 return change; 9342} 9343 9344static struct snd_kcontrol_new alc262_fujitsu_mixer[] = { 9345 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol), 9346 { 9347 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 9348 .name = "Master Playback Switch", 9349 .info = snd_hda_mixer_amp_switch_info, 9350 .get = snd_hda_mixer_amp_switch_get, 9351 .put = alc262_fujitsu_master_sw_put, 9352 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 9353 }, 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("PC Speaker Volume", 0x0b, 0x05, HDA_INPUT), 9357 HDA_CODEC_MUTE("PC Speaker Switch", 0x0b, 0x05, HDA_INPUT), 9358 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 9359 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9360 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9361 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 9362 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 9363 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 9364 { } /* end */ 9365}; 9366 9367/* bind hp and internal speaker mute (with plug check) */ 9368static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol, 9369 struct snd_ctl_elem_value *ucontrol) 9370{ 9371 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 9372 long *valp = ucontrol->value.integer.value; 9373 int change; 9374 9375 change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 9376 HDA_AMP_MUTE, 9377 valp ? 0 : HDA_AMP_MUTE); 9378 9379 if (change) 9380 alc262_lenovo_3000_automute(codec, 0); 9381 return change; 9382} 9383 9384static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = { 9385 HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol), 9386 { 9387 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 9388 .name = "Master Playback Switch", 9389 .info = snd_hda_mixer_amp_switch_info, 9390 .get = snd_hda_mixer_amp_switch_get, 9391 .put = alc262_lenovo_3000_master_sw_put, 9392 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT), 9393 }, 9394 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 9395 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 9396 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 9397 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 9398 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 9399 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 9400 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 9401 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 9402 { } /* end */ 9403}; 9404 9405/* additional init verbs for Benq laptops */ 9406static struct hda_verb alc262_EAPD_verbs[] = { 9407 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 9408 {0x20, AC_VERB_SET_PROC_COEF, 0x3070}, 9409 {} 9410}; 9411 9412static struct hda_verb alc262_benq_t31_EAPD_verbs[] = { 9413 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 9414 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 9415 9416 {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, 9417 {0x20, AC_VERB_SET_PROC_COEF, 0x3050}, 9418 {} 9419}; 9420 9421/* Samsung Q1 Ultra Vista model setup */ 9422static struct snd_kcontrol_new alc262_ultra_mixer[] = { 9423 HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT), 9424 HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT), 9425 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 9426 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 9427 HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT), 9428 HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT), 9429 { } /* end */ 9430}; 9431 9432static struct hda_verb alc262_ultra_verbs[] = { 9433 /* output mixer */ 9434 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 9435 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 9436 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9437 /* speaker */ 9438 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 9439 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 9440 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9441 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 9442 /* HP */ 9443 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9444 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 9445 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9446 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 9447 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 9448 /* internal mic */ 9449 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 9450 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 9451 /* ADC, choose mic */ 9452 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 9453 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 9454 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9455 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 9456 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 9457 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 9458 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 9459 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 9460 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 9461 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)}, 9462 {} 9463}; 9464 9465/* mute/unmute internal speaker according to the hp jack and mute state */ 9466static void alc262_ultra_automute(struct hda_codec *codec) 9467{ 9468 struct alc_spec *spec = codec->spec; 9469 unsigned int mute; 9470 9471 mute = 0; 9472 /* auto-mute only when HP is used as HP */ 9473 if (!spec->cur_mux[0]) { 9474 unsigned int present; 9475 /* need to execute and sync at first */ 9476 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0); 9477 present = snd_hda_codec_read(codec, 0x15, 0, 9478 AC_VERB_GET_PIN_SENSE, 0); 9479 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0; 9480 if (spec->jack_present) 9481 mute = HDA_AMP_MUTE; 9482 } 9483 /* mute/unmute internal speaker */ 9484 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 9485 HDA_AMP_MUTE, mute); 9486 /* mute/unmute HP */ 9487 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 9488 HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE); 9489} 9490 9491/* unsolicited event for HP jack sensing */ 9492static void alc262_ultra_unsol_event(struct hda_codec *codec, 9493 unsigned int res) 9494{ 9495 if ((res >> 26) != ALC880_HP_EVENT) 9496 return; 9497 alc262_ultra_automute(codec); 9498} 9499 9500static struct hda_input_mux alc262_ultra_capture_source = { 9501 .num_items = 2, 9502 .items = { 9503 { "Mic", 0x1 }, 9504 { "Headphone", 0x7 }, 9505 }, 9506}; 9507 9508static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol, 9509 struct snd_ctl_elem_value *ucontrol) 9510{ 9511 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 9512 struct alc_spec *spec = codec->spec; 9513 int ret; 9514 9515 ret = alc882_mux_enum_put(kcontrol, ucontrol); 9516 if (!ret) 9517 return 0; 9518 /* reprogram the HP pin as mic or HP according to the input source */ 9519 snd_hda_codec_write_cache(codec, 0x15, 0, 9520 AC_VERB_SET_PIN_WIDGET_CONTROL, 9521 spec->cur_mux[0] ? PIN_VREF80 : PIN_HP); 9522 alc262_ultra_automute(codec); /* mute/unmute HP */ 9523 return ret; 9524} 9525 9526static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = { 9527 HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT), 9528 HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT), 9529 { 9530 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 9531 .name = "Capture Source", 9532 .info = alc882_mux_enum_info, 9533 .get = alc882_mux_enum_get, 9534 .put = alc262_ultra_mux_enum_put, 9535 }, 9536 { } /* end */ 9537}; 9538 9539/* add playback controls from the parsed DAC table */ 9540static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec, 9541 const struct auto_pin_cfg *cfg) 9542{ 9543 hda_nid_t nid; 9544 int err; 9545 9546 spec->multiout.num_dacs = 1; /* only use one dac */ 9547 spec->multiout.dac_nids = spec->private_dac_nids; 9548 spec->multiout.dac_nids[0] = 2; 9549 9550 nid = cfg->line_out_pins[0]; 9551 if (nid) { 9552 err = add_control(spec, ALC_CTL_WIDGET_VOL, 9553 "Front Playback Volume", 9554 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT)); 9555 if (err < 0) 9556 return err; 9557 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 9558 "Front Playback Switch", 9559 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 9560 if (err < 0) 9561 return err; 9562 } 9563 9564 nid = cfg->speaker_pins[0]; 9565 if (nid) { 9566 if (nid == 0x16) { 9567 err = add_control(spec, ALC_CTL_WIDGET_VOL, 9568 "Speaker Playback Volume", 9569 HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, 9570 HDA_OUTPUT)); 9571 if (err < 0) 9572 return err; 9573 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 9574 "Speaker Playback Switch", 9575 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 9576 HDA_OUTPUT)); 9577 if (err < 0) 9578 return err; 9579 } else { 9580 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 9581 "Speaker Playback Switch", 9582 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 9583 HDA_OUTPUT)); 9584 if (err < 0) 9585 return err; 9586 } 9587 } 9588 nid = cfg->hp_pins[0]; 9589 if (nid) { 9590 /* spec->multiout.hp_nid = 2; */ 9591 if (nid == 0x16) { 9592 err = add_control(spec, ALC_CTL_WIDGET_VOL, 9593 "Headphone Playback Volume", 9594 HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, 9595 HDA_OUTPUT)); 9596 if (err < 0) 9597 return err; 9598 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 9599 "Headphone Playback Switch", 9600 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 9601 HDA_OUTPUT)); 9602 if (err < 0) 9603 return err; 9604 } else { 9605 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 9606 "Headphone Playback Switch", 9607 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 9608 HDA_OUTPUT)); 9609 if (err < 0) 9610 return err; 9611 } 9612 } 9613 return 0; 9614} 9615 9616/* identical with ALC880 */ 9617#define alc262_auto_create_analog_input_ctls \ 9618 alc880_auto_create_analog_input_ctls 9619 9620/* 9621 * generic initialization of ADC, input mixers and output mixers 9622 */ 9623static struct hda_verb alc262_volume_init_verbs[] = { 9624 /* 9625 * Unmute ADC0-2 and set the default input to mic-in 9626 */ 9627 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 9628 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9629 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 9630 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9631 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 9632 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9633 9634 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 9635 * mixer widget 9636 * Note: PASD motherboards uses the Line In 2 as the input for 9637 * front panel mic (mic 2) 9638 */ 9639 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 9640 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 9641 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 9642 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 9643 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 9644 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 9645 9646 /* 9647 * Set up output mixers (0x0c - 0x0f) 9648 */ 9649 /* set vol=0 to output mixers */ 9650 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9651 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9652 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9653 9654 /* set up input amps for analog loopback */ 9655 /* Amp Indices: DAC = 0, mixer = 1 */ 9656 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9657 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9658 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9659 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9660 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9661 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9662 9663 /* FIXME: use matrix-type input source selection */ 9664 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 9665 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 9666 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 9667 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 9668 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 9669 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 9670 /* Input mixer2 */ 9671 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 9672 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 9673 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 9674 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 9675 /* Input mixer3 */ 9676 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 9677 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, 9678 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, 9679 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, 9680 9681 { } 9682}; 9683 9684static struct hda_verb alc262_HP_BPC_init_verbs[] = { 9685 /* 9686 * Unmute ADC0-2 and set the default input to mic-in 9687 */ 9688 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 9689 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9690 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 9691 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9692 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 9693 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9694 9695 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 9696 * mixer widget 9697 * Note: PASD motherboards uses the Line In 2 as the input for 9698 * front panel mic (mic 2) 9699 */ 9700 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 9701 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 9702 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 9703 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 9704 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 9705 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 9706 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 9707 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 9708 9709 /* 9710 * Set up output mixers (0x0c - 0x0e) 9711 */ 9712 /* set vol=0 to output mixers */ 9713 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9714 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9715 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9716 9717 /* set up input amps for analog loopback */ 9718 /* Amp Indices: DAC = 0, mixer = 1 */ 9719 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9720 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9721 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9722 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9723 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9724 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9725 9726 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 9727 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 9728 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 9729 9730 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 9731 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 9732 9733 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 9734 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 9735 9736 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 9737 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 9738 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 9739 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 9740 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 9741 9742 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, 9743 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 9744 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 9745 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, 9746 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 9747 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 9748 9749 9750 /* FIXME: use matrix-type input source selection */ 9751 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 9752 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 9753 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 9754 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, 9755 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, 9756 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, 9757 /* Input mixer2 */ 9758 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 9759 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, 9760 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, 9761 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, 9762 /* Input mixer3 */ 9763 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 9764 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, 9765 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, 9766 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, 9767 9768 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9769 9770 { } 9771}; 9772 9773static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = { 9774 /* 9775 * Unmute ADC0-2 and set the default input to mic-in 9776 */ 9777 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 9778 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9779 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 9780 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9781 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 9782 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9783 9784 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 9785 * mixer widget 9786 * Note: PASD motherboards uses the Line In 2 as the input for front 9787 * panel mic (mic 2) 9788 */ 9789 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 9790 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 9791 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 9792 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 9793 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 9794 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 9795 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 9796 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 9797 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 9798 /* 9799 * Set up output mixers (0x0c - 0x0e) 9800 */ 9801 /* set vol=0 to output mixers */ 9802 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9803 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9804 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 9805 9806 /* set up input amps for analog loopback */ 9807 /* Amp Indices: DAC = 0, mixer = 1 */ 9808 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9809 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9810 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9811 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9812 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 9813 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 9814 9815 9816 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP */ 9817 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Mono */ 9818 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* rear MIC */ 9819 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* Line in */ 9820 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Front MIC */ 9821 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Line out */ 9822 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD in */ 9823 9824 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 9825 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 9826 9827 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 9828 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 9829 9830 /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */ 9831 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 9832 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 9833 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, 9834 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 9835 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 }, 9836 9837 /* FIXME: use matrix-type input source selection */ 9838 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 9839 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 9840 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/ 9841 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/ 9842 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/ 9843 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/ 9844 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/ 9845 /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */ 9846 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/ 9847 /* Input mixer2 */ 9848 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 9849 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 9850 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, 9851 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, 9852 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, 9853 /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */ 9854 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, 9855 /* Input mixer3 */ 9856 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, 9857 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, 9858 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, 9859 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, 9860 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, 9861 /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */ 9862 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, 9863 9864 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 9865 9866 { } 9867}; 9868 9869#ifdef CONFIG_SND_HDA_POWER_SAVE 9870#define alc262_loopbacks alc880_loopbacks 9871#endif 9872 9873/* pcm configuration: identiacal with ALC880 */ 9874#define alc262_pcm_analog_playback alc880_pcm_analog_playback 9875#define alc262_pcm_analog_capture alc880_pcm_analog_capture 9876#define alc262_pcm_digital_playback alc880_pcm_digital_playback 9877#define alc262_pcm_digital_capture alc880_pcm_digital_capture 9878 9879/* 9880 * BIOS auto configuration 9881 */ 9882static int alc262_parse_auto_config(struct hda_codec *codec) 9883{ 9884 struct alc_spec *spec = codec->spec; 9885 int err; 9886 static hda_nid_t alc262_ignore[] = { 0x1d, 0 }; 9887 9888 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 9889 alc262_ignore); 9890 if (err < 0) 9891 return err; 9892 if (!spec->autocfg.line_outs) 9893 return 0; /* can't find valid BIOS pin config */ 9894 err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg); 9895 if (err < 0) 9896 return err; 9897 err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg); 9898 if (err < 0) 9899 return err; 9900 9901 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 9902 9903 if (spec->autocfg.dig_out_pin) 9904 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID; 9905 if (spec->autocfg.dig_in_pin) 9906 spec->dig_in_nid = ALC262_DIGIN_NID; 9907 9908 if (spec->kctl_alloc) 9909 spec->mixers[spec->num_mixers++] = spec->kctl_alloc; 9910 9911 spec->init_verbs[spec->num_init_verbs++] = alc262_volume_init_verbs; 9912 spec->num_mux_defs = 1; 9913 spec->input_mux = &spec->private_imux; 9914 9915 err = alc_auto_add_mic_boost(codec); 9916 if (err < 0) 9917 return err; 9918 9919 return 1; 9920} 9921 9922#define alc262_auto_init_multi_out alc882_auto_init_multi_out 9923#define alc262_auto_init_hp_out alc882_auto_init_hp_out 9924#define alc262_auto_init_analog_input alc882_auto_init_analog_input 9925#define alc262_auto_init_input_src alc882_auto_init_input_src 9926 9927 9928/* init callback for auto-configuration model -- overriding the default init */ 9929static void alc262_auto_init(struct hda_codec *codec) 9930{ 9931 struct alc_spec *spec = codec->spec; 9932 alc262_auto_init_multi_out(codec); 9933 alc262_auto_init_hp_out(codec); 9934 alc262_auto_init_analog_input(codec); 9935 alc262_auto_init_input_src(codec); 9936 if (spec->unsol_event) 9937 alc_sku_automute(codec); 9938} 9939 9940/* 9941 * configuration and preset 9942 */ 9943static const char *alc262_models[ALC262_MODEL_LAST] = { 9944 [ALC262_BASIC] = "basic", 9945 [ALC262_HIPPO] = "hippo", 9946 [ALC262_HIPPO_1] = "hippo_1", 9947 [ALC262_FUJITSU] = "fujitsu", 9948 [ALC262_HP_BPC] = "hp-bpc", 9949 [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000", 9950 [ALC262_HP_TC_T5735] = "hp-tc-t5735", 9951 [ALC262_HP_RP5700] = "hp-rp5700", 9952 [ALC262_BENQ_ED8] = "benq", 9953 [ALC262_BENQ_T31] = "benq-t31", 9954 [ALC262_SONY_ASSAMD] = "sony-assamd", 9955 [ALC262_ULTRA] = "ultra", 9956 [ALC262_LENOVO_3000] = "lenovo-3000", 9957 [ALC262_NEC] = "nec", 9958 [ALC262_AUTO] = "auto", 9959}; 9960 9961static struct snd_pci_quirk alc262_cfg_tbl[] = { 9962 SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO), 9963 SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC), 9964 SND_PCI_QUIRK(0x103c, 0x12fe, "HP xw9400", ALC262_HP_BPC), 9965 SND_PCI_QUIRK(0x103c, 0x12ff, "HP xw4550", ALC262_HP_BPC), 9966 SND_PCI_QUIRK(0x103c, 0x1306, "HP xw8600", ALC262_HP_BPC), 9967 SND_PCI_QUIRK(0x103c, 0x1307, "HP xw6600", ALC262_HP_BPC), 9968 SND_PCI_QUIRK(0x103c, 0x1308, "HP xw4600", ALC262_HP_BPC), 9969 SND_PCI_QUIRK(0x103c, 0x1309, "HP xw4*00", ALC262_HP_BPC), 9970 SND_PCI_QUIRK(0x103c, 0x130a, "HP xw6*00", ALC262_HP_BPC), 9971 SND_PCI_QUIRK(0x103c, 0x130b, "HP xw8*00", ALC262_HP_BPC), 9972 SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL), 9973 SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF), 9974 SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL), 9975 SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF), 9976 SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL), 9977 SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF), 9978 SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL), 9979 SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF), 9980 SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC), 9981 SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC), 9982 SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC), 9983 SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735", 9984 ALC262_HP_TC_T5735), 9985 SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700), 9986 SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD), 9987 SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO), 9988 SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD), 9989 SND_PCI_QUIRK(0x104d, 0x900e, "Sony ASSAMD", ALC262_SONY_ASSAMD), 9990 SND_PCI_QUIRK(0x104d, 0x9015, "Sony 0x9015", ALC262_SONY_ASSAMD), 9991 SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1", 9992 ALC262_SONY_ASSAMD), 9993 SND_PCI_QUIRK(0x1179, 0x0268, "Toshiba S06", ALC262_TOSHIBA_S06), 9994 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU), 9995 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU), 9996 SND_PCI_QUIRK(0x144d, 0xc032, "Samsung Q1 Ultra", ALC262_ULTRA), 9997 SND_PCI_QUIRK(0x144d, 0xc039, "Samsung Q1U EL", ALC262_ULTRA), 9998 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000), 9999 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8), 10000 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31), 10001 SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1), 10002 {} 10003}; 10004 10005static struct alc_config_preset alc262_presets[] = { 10006 [ALC262_BASIC] = { 10007 .mixers = { alc262_base_mixer }, 10008 .init_verbs = { alc262_init_verbs }, 10009 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10010 .dac_nids = alc262_dac_nids, 10011 .hp_nid = 0x03, 10012 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10013 .channel_mode = alc262_modes, 10014 .input_mux = &alc262_capture_source, 10015 }, 10016 [ALC262_HIPPO] = { 10017 .mixers = { alc262_base_mixer }, 10018 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs}, 10019 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10020 .dac_nids = alc262_dac_nids, 10021 .hp_nid = 0x03, 10022 .dig_out_nid = ALC262_DIGOUT_NID, 10023 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10024 .channel_mode = alc262_modes, 10025 .input_mux = &alc262_capture_source, 10026 .unsol_event = alc262_hippo_unsol_event, 10027 .init_hook = alc262_hippo_automute, 10028 }, 10029 [ALC262_HIPPO_1] = { 10030 .mixers = { alc262_hippo1_mixer }, 10031 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs}, 10032 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10033 .dac_nids = alc262_dac_nids, 10034 .hp_nid = 0x02, 10035 .dig_out_nid = ALC262_DIGOUT_NID, 10036 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10037 .channel_mode = alc262_modes, 10038 .input_mux = &alc262_capture_source, 10039 .unsol_event = alc262_hippo1_unsol_event, 10040 .init_hook = alc262_hippo1_automute, 10041 }, 10042 [ALC262_FUJITSU] = { 10043 .mixers = { alc262_fujitsu_mixer }, 10044 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs, 10045 alc262_fujitsu_unsol_verbs }, 10046 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10047 .dac_nids = alc262_dac_nids, 10048 .hp_nid = 0x03, 10049 .dig_out_nid = ALC262_DIGOUT_NID, 10050 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10051 .channel_mode = alc262_modes, 10052 .input_mux = &alc262_fujitsu_capture_source, 10053 .unsol_event = alc262_fujitsu_unsol_event, 10054 .init_hook = alc262_fujitsu_init_hook, 10055 }, 10056 [ALC262_HP_BPC] = { 10057 .mixers = { alc262_HP_BPC_mixer }, 10058 .init_verbs = { alc262_HP_BPC_init_verbs }, 10059 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10060 .dac_nids = alc262_dac_nids, 10061 .hp_nid = 0x03, 10062 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10063 .channel_mode = alc262_modes, 10064 .input_mux = &alc262_HP_capture_source, 10065 .unsol_event = alc262_hp_bpc_unsol_event, 10066 .init_hook = alc262_hp_bpc_automute, 10067 }, 10068 [ALC262_HP_BPC_D7000_WF] = { 10069 .mixers = { alc262_HP_BPC_WildWest_mixer }, 10070 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs }, 10071 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10072 .dac_nids = alc262_dac_nids, 10073 .hp_nid = 0x03, 10074 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10075 .channel_mode = alc262_modes, 10076 .input_mux = &alc262_HP_D7000_capture_source, 10077 .unsol_event = alc262_hp_wildwest_unsol_event, 10078 .init_hook = alc262_hp_wildwest_automute, 10079 }, 10080 [ALC262_HP_BPC_D7000_WL] = { 10081 .mixers = { alc262_HP_BPC_WildWest_mixer, 10082 alc262_HP_BPC_WildWest_option_mixer }, 10083 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs }, 10084 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10085 .dac_nids = alc262_dac_nids, 10086 .hp_nid = 0x03, 10087 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10088 .channel_mode = alc262_modes, 10089 .input_mux = &alc262_HP_D7000_capture_source, 10090 .unsol_event = alc262_hp_wildwest_unsol_event, 10091 .init_hook = alc262_hp_wildwest_automute, 10092 }, 10093 [ALC262_HP_TC_T5735] = { 10094 .mixers = { alc262_hp_t5735_mixer }, 10095 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs }, 10096 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10097 .dac_nids = alc262_dac_nids, 10098 .hp_nid = 0x03, 10099 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10100 .channel_mode = alc262_modes, 10101 .input_mux = &alc262_capture_source, 10102 .unsol_event = alc262_hp_t5735_unsol_event, 10103 .init_hook = alc262_hp_t5735_init_hook, 10104 }, 10105 [ALC262_HP_RP5700] = { 10106 .mixers = { alc262_hp_rp5700_mixer }, 10107 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs }, 10108 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10109 .dac_nids = alc262_dac_nids, 10110 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10111 .channel_mode = alc262_modes, 10112 .input_mux = &alc262_hp_rp5700_capture_source, 10113 }, 10114 [ALC262_BENQ_ED8] = { 10115 .mixers = { alc262_base_mixer }, 10116 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs }, 10117 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10118 .dac_nids = alc262_dac_nids, 10119 .hp_nid = 0x03, 10120 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10121 .channel_mode = alc262_modes, 10122 .input_mux = &alc262_capture_source, 10123 }, 10124 [ALC262_SONY_ASSAMD] = { 10125 .mixers = { alc262_sony_mixer }, 10126 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs}, 10127 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10128 .dac_nids = alc262_dac_nids, 10129 .hp_nid = 0x02, 10130 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10131 .channel_mode = alc262_modes, 10132 .input_mux = &alc262_capture_source, 10133 .unsol_event = alc262_hippo_unsol_event, 10134 .init_hook = alc262_hippo_automute, 10135 }, 10136 [ALC262_BENQ_T31] = { 10137 .mixers = { alc262_benq_t31_mixer }, 10138 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs }, 10139 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10140 .dac_nids = alc262_dac_nids, 10141 .hp_nid = 0x03, 10142 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10143 .channel_mode = alc262_modes, 10144 .input_mux = &alc262_capture_source, 10145 .unsol_event = alc262_hippo_unsol_event, 10146 .init_hook = alc262_hippo_automute, 10147 }, 10148 [ALC262_ULTRA] = { 10149 .mixers = { alc262_ultra_mixer, alc262_ultra_capture_mixer }, 10150 .init_verbs = { alc262_ultra_verbs }, 10151 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10152 .dac_nids = alc262_dac_nids, 10153 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10154 .channel_mode = alc262_modes, 10155 .input_mux = &alc262_ultra_capture_source, 10156 .adc_nids = alc262_adc_nids, /* ADC0 */ 10157 .capsrc_nids = alc262_capsrc_nids, 10158 .num_adc_nids = 1, /* single ADC */ 10159 .unsol_event = alc262_ultra_unsol_event, 10160 .init_hook = alc262_ultra_automute, 10161 }, 10162 [ALC262_LENOVO_3000] = { 10163 .mixers = { alc262_lenovo_3000_mixer }, 10164 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs, 10165 alc262_lenovo_3000_unsol_verbs }, 10166 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10167 .dac_nids = alc262_dac_nids, 10168 .hp_nid = 0x03, 10169 .dig_out_nid = ALC262_DIGOUT_NID, 10170 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10171 .channel_mode = alc262_modes, 10172 .input_mux = &alc262_fujitsu_capture_source, 10173 .unsol_event = alc262_lenovo_3000_unsol_event, 10174 }, 10175 [ALC262_NEC] = { 10176 .mixers = { alc262_nec_mixer }, 10177 .init_verbs = { alc262_nec_verbs }, 10178 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10179 .dac_nids = alc262_dac_nids, 10180 .hp_nid = 0x03, 10181 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10182 .channel_mode = alc262_modes, 10183 .input_mux = &alc262_capture_source, 10184 }, 10185 [ALC262_TOSHIBA_S06] = { 10186 .mixers = { alc262_toshiba_s06_mixer }, 10187 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs, 10188 alc262_eapd_verbs }, 10189 .num_dacs = ARRAY_SIZE(alc262_dac_nids), 10190 .capsrc_nids = alc262_dmic_capsrc_nids, 10191 .dac_nids = alc262_dac_nids, 10192 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */ 10193 .dig_out_nid = ALC262_DIGOUT_NID, 10194 .num_channel_mode = ARRAY_SIZE(alc262_modes), 10195 .channel_mode = alc262_modes, 10196 .input_mux = &alc262_dmic_capture_source, 10197 .unsol_event = alc262_toshiba_s06_unsol_event, 10198 .init_hook = alc262_toshiba_s06_init_hook, 10199 }, 10200}; 10201 10202static int patch_alc262(struct hda_codec *codec) 10203{ 10204 struct alc_spec *spec; 10205 int board_config; 10206 int err; 10207 10208 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 10209 if (spec == NULL) 10210 return -ENOMEM; 10211 10212 codec->spec = spec; 10213#if 0 10214 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is 10215 * under-run 10216 */ 10217 { 10218 int tmp; 10219 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7); 10220 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0); 10221 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7); 10222 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80); 10223 } 10224#endif 10225 10226 alc_fix_pll_init(codec, 0x20, 0x0a, 10); 10227 10228 board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST, 10229 alc262_models, 10230 alc262_cfg_tbl); 10231 10232 if (board_config < 0) { 10233 printk(KERN_INFO "hda_codec: Unknown model for ALC262, " 10234 "trying auto-probe from BIOS...\n"); 10235 board_config = ALC262_AUTO; 10236 } 10237 10238 if (board_config == ALC262_AUTO) { 10239 /* automatic parse from the BIOS config */ 10240 err = alc262_parse_auto_config(codec); 10241 if (err < 0) { 10242 alc_free(codec); 10243 return err; 10244 } else if (!err) { 10245 printk(KERN_INFO 10246 "hda_codec: Cannot set up configuration " 10247 "from BIOS. Using base mode...\n"); 10248 board_config = ALC262_BASIC; 10249 } 10250 } 10251 10252 if (board_config != ALC262_AUTO) 10253 setup_preset(spec, &alc262_presets[board_config]); 10254 10255 spec->stream_name_analog = "ALC262 Analog"; 10256 spec->stream_analog_playback = &alc262_pcm_analog_playback; 10257 spec->stream_analog_capture = &alc262_pcm_analog_capture; 10258 10259 spec->stream_name_digital = "ALC262 Digital"; 10260 spec->stream_digital_playback = &alc262_pcm_digital_playback; 10261 spec->stream_digital_capture = &alc262_pcm_digital_capture; 10262 10263 if (!spec->adc_nids && spec->input_mux) { 10264 /* check whether NID 0x07 is valid */ 10265 unsigned int wcap = get_wcaps(codec, 0x07); 10266 10267 /* get type */ 10268 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 10269 if (wcap != AC_WID_AUD_IN) { 10270 spec->adc_nids = alc262_adc_nids_alt; 10271 spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt); 10272 spec->capsrc_nids = alc262_capsrc_nids_alt; 10273 spec->mixers[spec->num_mixers] = 10274 alc262_capture_alt_mixer; 10275 spec->num_mixers++; 10276 } else { 10277 spec->adc_nids = alc262_adc_nids; 10278 spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids); 10279 spec->capsrc_nids = alc262_capsrc_nids; 10280 spec->mixers[spec->num_mixers] = alc262_capture_mixer; 10281 spec->num_mixers++; 10282 } 10283 } 10284 10285 spec->vmaster_nid = 0x0c; 10286 10287 codec->patch_ops = alc_patch_ops; 10288 if (board_config == ALC262_AUTO) 10289 spec->init_hook = alc262_auto_init; 10290#ifdef CONFIG_SND_HDA_POWER_SAVE 10291 if (!spec->loopback.amplist) 10292 spec->loopback.amplist = alc262_loopbacks; 10293#endif 10294 10295 return 0; 10296} 10297 10298/* 10299 * ALC268 channel source setting (2 channel) 10300 */ 10301#define ALC268_DIGOUT_NID ALC880_DIGOUT_NID 10302#define alc268_modes alc260_modes 10303 10304static hda_nid_t alc268_dac_nids[2] = { 10305 /* front, hp */ 10306 0x02, 0x03 10307}; 10308 10309static hda_nid_t alc268_adc_nids[2] = { 10310 /* ADC0-1 */ 10311 0x08, 0x07 10312}; 10313 10314static hda_nid_t alc268_adc_nids_alt[1] = { 10315 /* ADC0 */ 10316 0x08 10317}; 10318 10319static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 }; 10320 10321static struct snd_kcontrol_new alc268_base_mixer[] = { 10322 /* output mixer control */ 10323 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT), 10324 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 10325 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT), 10326 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 10327 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 10328 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 10329 HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT), 10330 { } 10331}; 10332 10333/* bind Beep switches of both NID 0x0f and 0x10 */ 10334static struct hda_bind_ctls alc268_bind_beep_sw = { 10335 .ops = &snd_hda_bind_sw, 10336 .values = { 10337 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT), 10338 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT), 10339 0 10340 }, 10341}; 10342 10343static struct snd_kcontrol_new alc268_beep_mixer[] = { 10344 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT), 10345 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw), 10346 { } 10347}; 10348 10349static struct hda_verb alc268_eapd_verbs[] = { 10350 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 10351 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 10352 { } 10353}; 10354 10355/* Toshiba specific */ 10356#define alc268_toshiba_automute alc262_hippo_automute 10357 10358static struct hda_verb alc268_toshiba_verbs[] = { 10359 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 10360 { } /* end */ 10361}; 10362 10363static struct hda_input_mux alc268_acer_lc_capture_source = { 10364 .num_items = 2, 10365 .items = { 10366 { "i-Mic", 0x6 }, 10367 { "E-Mic", 0x0 }, 10368 }, 10369}; 10370 10371/* Acer specific */ 10372/* bind volumes of both NID 0x02 and 0x03 */ 10373static struct hda_bind_ctls alc268_acer_bind_master_vol = { 10374 .ops = &snd_hda_bind_vol, 10375 .values = { 10376 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT), 10377 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT), 10378 0 10379 }, 10380}; 10381 10382/* mute/unmute internal speaker according to the hp jack and mute state */ 10383static void alc268_acer_automute(struct hda_codec *codec, int force) 10384{ 10385 struct alc_spec *spec = codec->spec; 10386 unsigned int mute; 10387 10388 if (force || !spec->sense_updated) { 10389 unsigned int present; 10390 present = snd_hda_codec_read(codec, 0x14, 0, 10391 AC_VERB_GET_PIN_SENSE, 0); 10392 spec->jack_present = (present & 0x80000000) != 0; 10393 spec->sense_updated = 1; 10394 } 10395 if (spec->jack_present) 10396 mute = HDA_AMP_MUTE; /* mute internal speaker */ 10397 else /* unmute internal speaker if necessary */ 10398 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0); 10399 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 10400 HDA_AMP_MUTE, mute); 10401} 10402 10403 10404/* bind hp and internal speaker mute (with plug check) */ 10405static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol, 10406 struct snd_ctl_elem_value *ucontrol) 10407{ 10408 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 10409 long *valp = ucontrol->value.integer.value; 10410 int change; 10411 10412 change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0, 10413 HDA_AMP_MUTE, 10414 valp[0] ? 0 : HDA_AMP_MUTE); 10415 change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0, 10416 HDA_AMP_MUTE, 10417 valp[1] ? 0 : HDA_AMP_MUTE); 10418 if (change) 10419 alc268_acer_automute(codec, 0); 10420 return change; 10421} 10422 10423static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = { 10424 /* output mixer control */ 10425 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol), 10426 { 10427 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 10428 .name = "Master Playback Switch", 10429 .info = snd_hda_mixer_amp_switch_info, 10430 .get = snd_hda_mixer_amp_switch_get, 10431 .put = alc268_acer_master_sw_put, 10432 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 10433 }, 10434 HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT), 10435 { } 10436}; 10437 10438static struct snd_kcontrol_new alc268_acer_mixer[] = { 10439 /* output mixer control */ 10440 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol), 10441 { 10442 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 10443 .name = "Master Playback Switch", 10444 .info = snd_hda_mixer_amp_switch_info, 10445 .get = snd_hda_mixer_amp_switch_get, 10446 .put = alc268_acer_master_sw_put, 10447 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 10448 }, 10449 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 10450 HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT), 10451 HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT), 10452 { } 10453}; 10454 10455static struct hda_verb alc268_acer_aspire_one_verbs[] = { 10456 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 10457 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 10458 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 10459 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 10460 {0x23, AC_VERB_SET_CONNECT_SEL, 0x06}, 10461 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017}, 10462 { } 10463}; 10464 10465static struct hda_verb alc268_acer_verbs[] = { 10466 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */ 10467 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 10468 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 10469 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 10470 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 10471 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 10472 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 10473 { } 10474}; 10475 10476/* unsolicited event for HP jack sensing */ 10477static void alc268_toshiba_unsol_event(struct hda_codec *codec, 10478 unsigned int res) 10479{ 10480 if ((res >> 26) != ALC880_HP_EVENT) 10481 return; 10482 alc268_toshiba_automute(codec); 10483} 10484 10485static void alc268_acer_unsol_event(struct hda_codec *codec, 10486 unsigned int res) 10487{ 10488 if ((res >> 26) != ALC880_HP_EVENT) 10489 return; 10490 alc268_acer_automute(codec, 1); 10491} 10492 10493static void alc268_acer_init_hook(struct hda_codec *codec) 10494{ 10495 alc268_acer_automute(codec, 1); 10496} 10497 10498/* toggle speaker-output according to the hp-jack state */ 10499static void alc268_aspire_one_speaker_automute(struct hda_codec *codec) 10500{ 10501 unsigned int present; 10502 unsigned char bits; 10503 10504 present = snd_hda_codec_read(codec, 0x15, 0, 10505 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 10506 bits = present ? AMP_IN_MUTE(0) : 0; 10507 snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0, 10508 AMP_IN_MUTE(0), bits); 10509 snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1, 10510 AMP_IN_MUTE(0), bits); 10511} 10512 10513 10514static void alc268_acer_mic_automute(struct hda_codec *codec) 10515{ 10516 unsigned int present; 10517 10518 present = snd_hda_codec_read(codec, 0x18, 0, 10519 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 10520 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL, 10521 present ? 0x0 : 0x6); 10522} 10523 10524static void alc268_acer_lc_unsol_event(struct hda_codec *codec, 10525 unsigned int res) 10526{ 10527 if ((res >> 26) == ALC880_HP_EVENT) 10528 alc268_aspire_one_speaker_automute(codec); 10529 if ((res >> 26) == ALC880_MIC_EVENT) 10530 alc268_acer_mic_automute(codec); 10531} 10532 10533static void alc268_acer_lc_init_hook(struct hda_codec *codec) 10534{ 10535 alc268_aspire_one_speaker_automute(codec); 10536 alc268_acer_mic_automute(codec); 10537} 10538 10539static struct snd_kcontrol_new alc268_dell_mixer[] = { 10540 /* output mixer control */ 10541 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 10542 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 10543 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 10544 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 10545 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 10546 HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT), 10547 { } 10548}; 10549 10550static struct hda_verb alc268_dell_verbs[] = { 10551 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 10552 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 10553 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 10554 { } 10555}; 10556 10557/* mute/unmute internal speaker according to the hp jack and mute state */ 10558static void alc268_dell_automute(struct hda_codec *codec) 10559{ 10560 unsigned int present; 10561 unsigned int mute; 10562 10563 present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0); 10564 if (present & 0x80000000) 10565 mute = HDA_AMP_MUTE; 10566 else 10567 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0); 10568 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 10569 HDA_AMP_MUTE, mute); 10570} 10571 10572static void alc268_dell_unsol_event(struct hda_codec *codec, 10573 unsigned int res) 10574{ 10575 if ((res >> 26) != ALC880_HP_EVENT) 10576 return; 10577 alc268_dell_automute(codec); 10578} 10579 10580#define alc268_dell_init_hook alc268_dell_automute 10581 10582static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = { 10583 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT), 10584 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 10585 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT), 10586 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 10587 HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT), 10588 HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT), 10589 HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT), 10590 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 10591 { } 10592}; 10593 10594static struct hda_verb alc267_quanta_il1_verbs[] = { 10595 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 10596 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, 10597 { } 10598}; 10599 10600static void alc267_quanta_il1_hp_automute(struct hda_codec *codec) 10601{ 10602 unsigned int present; 10603 10604 present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0) 10605 & AC_PINSENSE_PRESENCE; 10606 snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 10607 present ? 0 : PIN_OUT); 10608} 10609 10610static void alc267_quanta_il1_mic_automute(struct hda_codec *codec) 10611{ 10612 unsigned int present; 10613 10614 present = snd_hda_codec_read(codec, 0x18, 0, 10615 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 10616 snd_hda_codec_write(codec, 0x23, 0, 10617 AC_VERB_SET_CONNECT_SEL, 10618 present ? 0x00 : 0x01); 10619} 10620 10621static void alc267_quanta_il1_automute(struct hda_codec *codec) 10622{ 10623 alc267_quanta_il1_hp_automute(codec); 10624 alc267_quanta_il1_mic_automute(codec); 10625} 10626 10627static void alc267_quanta_il1_unsol_event(struct hda_codec *codec, 10628 unsigned int res) 10629{ 10630 switch (res >> 26) { 10631 case ALC880_HP_EVENT: 10632 alc267_quanta_il1_hp_automute(codec); 10633 break; 10634 case ALC880_MIC_EVENT: 10635 alc267_quanta_il1_mic_automute(codec); 10636 break; 10637 } 10638} 10639 10640/* 10641 * generic initialization of ADC, input mixers and output mixers 10642 */ 10643static struct hda_verb alc268_base_init_verbs[] = { 10644 /* Unmute DAC0-1 and set vol = 0 */ 10645 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10646 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10647 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10648 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10649 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10650 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10651 10652 /* 10653 * Set up output mixers (0x0c - 0x0e) 10654 */ 10655 /* set vol=0 to output mixers */ 10656 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10657 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10658 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10659 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00}, 10660 10661 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10662 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10663 10664 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 10665 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, 10666 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 10667 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 10668 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 10669 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 10670 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 10671 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 10672 10673 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10674 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10675 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10676 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10677 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10678 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10679 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10680 10681 /* set PCBEEP vol = 0, mute connections */ 10682 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10683 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 10684 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 10685 10686 /* Unmute Selector 23h,24h and set the default input to mic-in */ 10687 10688 {0x23, AC_VERB_SET_CONNECT_SEL, 0x00}, 10689 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 10690 {0x24, AC_VERB_SET_CONNECT_SEL, 0x00}, 10691 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 10692 10693 { } 10694}; 10695 10696/* 10697 * generic initialization of ADC, input mixers and output mixers 10698 */ 10699static struct hda_verb alc268_volume_init_verbs[] = { 10700 /* set output DAC */ 10701 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10702 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10703 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10704 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10705 10706 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 10707 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, 10708 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 10709 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 10710 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 10711 10712 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 10713 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10714 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 10715 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10716 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10717 10718 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10719 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10720 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10721 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 10722 10723 /* set PCBEEP vol = 0, mute connections */ 10724 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 10725 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 10726 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 10727 10728 { } 10729}; 10730 10731#define alc268_mux_enum_info alc_mux_enum_info 10732#define alc268_mux_enum_get alc_mux_enum_get 10733#define alc268_mux_enum_put alc_mux_enum_put 10734 10735static struct snd_kcontrol_new alc268_capture_alt_mixer[] = { 10736 HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT), 10737 HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT), 10738 { 10739 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 10740 /* The multiple "Capture Source" controls confuse alsamixer 10741 * So call somewhat different.. 10742 */ 10743 /* .name = "Capture Source", */ 10744 .name = "Input Source", 10745 .count = 1, 10746 .info = alc268_mux_enum_info, 10747 .get = alc268_mux_enum_get, 10748 .put = alc268_mux_enum_put, 10749 }, 10750 { } /* end */ 10751}; 10752 10753static struct snd_kcontrol_new alc268_capture_mixer[] = { 10754 HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT), 10755 HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT), 10756 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT), 10757 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT), 10758 { 10759 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 10760 /* The multiple "Capture Source" controls confuse alsamixer 10761 * So call somewhat different.. 10762 */ 10763 /* .name = "Capture Source", */ 10764 .name = "Input Source", 10765 .count = 2, 10766 .info = alc268_mux_enum_info, 10767 .get = alc268_mux_enum_get, 10768 .put = alc268_mux_enum_put, 10769 }, 10770 { } /* end */ 10771}; 10772 10773static struct hda_input_mux alc268_capture_source = { 10774 .num_items = 4, 10775 .items = { 10776 { "Mic", 0x0 }, 10777 { "Front Mic", 0x1 }, 10778 { "Line", 0x2 }, 10779 { "CD", 0x3 }, 10780 }, 10781}; 10782 10783static struct hda_input_mux alc268_acer_capture_source = { 10784 .num_items = 3, 10785 .items = { 10786 { "Mic", 0x0 }, 10787 { "Internal Mic", 0x6 }, 10788 { "Line", 0x2 }, 10789 }, 10790}; 10791 10792#ifdef CONFIG_SND_DEBUG 10793static struct snd_kcontrol_new alc268_test_mixer[] = { 10794 /* Volume widgets */ 10795 HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT), 10796 HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT), 10797 HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT), 10798 HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT), 10799 HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT), 10800 HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT), 10801 HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT), 10802 HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT), 10803 HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT), 10804 HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT), 10805 HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT), 10806 HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT), 10807 HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT), 10808 /* The below appears problematic on some hardwares */ 10809 /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/ 10810 HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT), 10811 HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT), 10812 HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT), 10813 HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT), 10814 10815 /* Modes for retasking pin widgets */ 10816 ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT), 10817 ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT), 10818 ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT), 10819 ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT), 10820 10821 /* Controls for GPIO pins, assuming they are configured as outputs */ 10822 ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01), 10823 ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02), 10824 ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04), 10825 ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08), 10826 10827 /* Switches to allow the digital SPDIF output pin to be enabled. 10828 * The ALC268 does not have an SPDIF input. 10829 */ 10830 ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01), 10831 10832 /* A switch allowing EAPD to be enabled. Some laptops seem to use 10833 * this output to turn on an external amplifier. 10834 */ 10835 ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02), 10836 ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02), 10837 10838 { } /* end */ 10839}; 10840#endif 10841 10842/* create input playback/capture controls for the given pin */ 10843static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid, 10844 const char *ctlname, int idx) 10845{ 10846 char name[32]; 10847 int err; 10848 10849 sprintf(name, "%s Playback Volume", ctlname); 10850 if (nid == 0x14) { 10851 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 10852 HDA_COMPOSE_AMP_VAL(0x02, 3, idx, 10853 HDA_OUTPUT)); 10854 if (err < 0) 10855 return err; 10856 } else if (nid == 0x15) { 10857 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 10858 HDA_COMPOSE_AMP_VAL(0x03, 3, idx, 10859 HDA_OUTPUT)); 10860 if (err < 0) 10861 return err; 10862 } else 10863 return -1; 10864 sprintf(name, "%s Playback Switch", ctlname); 10865 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 10866 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT)); 10867 if (err < 0) 10868 return err; 10869 return 0; 10870} 10871 10872/* add playback controls from the parsed DAC table */ 10873static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec, 10874 const struct auto_pin_cfg *cfg) 10875{ 10876 hda_nid_t nid; 10877 int err; 10878 10879 spec->multiout.num_dacs = 2; /* only use one dac */ 10880 spec->multiout.dac_nids = spec->private_dac_nids; 10881 spec->multiout.dac_nids[0] = 2; 10882 spec->multiout.dac_nids[1] = 3; 10883 10884 nid = cfg->line_out_pins[0]; 10885 if (nid) 10886 alc268_new_analog_output(spec, nid, "Front", 0); 10887 10888 nid = cfg->speaker_pins[0]; 10889 if (nid == 0x1d) { 10890 err = add_control(spec, ALC_CTL_WIDGET_VOL, 10891 "Speaker Playback Volume", 10892 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT)); 10893 if (err < 0) 10894 return err; 10895 } 10896 nid = cfg->hp_pins[0]; 10897 if (nid) 10898 alc268_new_analog_output(spec, nid, "Headphone", 0); 10899 10900 nid = cfg->line_out_pins[1] | cfg->line_out_pins[2]; 10901 if (nid == 0x16) { 10902 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 10903 "Mono Playback Switch", 10904 HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT)); 10905 if (err < 0) 10906 return err; 10907 } 10908 return 0; 10909} 10910 10911/* create playback/capture controls for input pins */ 10912static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec, 10913 const struct auto_pin_cfg *cfg) 10914{ 10915 struct hda_input_mux *imux = &spec->private_imux; 10916 int i, idx1; 10917 10918 for (i = 0; i < AUTO_PIN_LAST; i++) { 10919 switch(cfg->input_pins[i]) { 10920 case 0x18: 10921 idx1 = 0; /* Mic 1 */ 10922 break; 10923 case 0x19: 10924 idx1 = 1; /* Mic 2 */ 10925 break; 10926 case 0x1a: 10927 idx1 = 2; /* Line In */ 10928 break; 10929 case 0x1c: 10930 idx1 = 3; /* CD */ 10931 break; 10932 case 0x12: 10933 case 0x13: 10934 idx1 = 6; /* digital mics */ 10935 break; 10936 default: 10937 continue; 10938 } 10939 imux->items[imux->num_items].label = auto_pin_cfg_labels[i]; 10940 imux->items[imux->num_items].index = idx1; 10941 imux->num_items++; 10942 } 10943 return 0; 10944} 10945 10946static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec) 10947{ 10948 struct alc_spec *spec = codec->spec; 10949 hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0]; 10950 hda_nid_t hp_nid = spec->autocfg.hp_pins[0]; 10951 hda_nid_t line_nid = spec->autocfg.line_out_pins[0]; 10952 unsigned int dac_vol1, dac_vol2; 10953 10954 if (speaker_nid) { 10955 snd_hda_codec_write(codec, speaker_nid, 0, 10956 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 10957 snd_hda_codec_write(codec, 0x0f, 0, 10958 AC_VERB_SET_AMP_GAIN_MUTE, 10959 AMP_IN_UNMUTE(1)); 10960 snd_hda_codec_write(codec, 0x10, 0, 10961 AC_VERB_SET_AMP_GAIN_MUTE, 10962 AMP_IN_UNMUTE(1)); 10963 } else { 10964 snd_hda_codec_write(codec, 0x0f, 0, 10965 AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)); 10966 snd_hda_codec_write(codec, 0x10, 0, 10967 AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)); 10968 } 10969 10970 dac_vol1 = dac_vol2 = 0xb000 | 0x40; /* set max volume */ 10971 if (line_nid == 0x14) 10972 dac_vol2 = AMP_OUT_ZERO; 10973 else if (line_nid == 0x15) 10974 dac_vol1 = AMP_OUT_ZERO; 10975 if (hp_nid == 0x14) 10976 dac_vol2 = AMP_OUT_ZERO; 10977 else if (hp_nid == 0x15) 10978 dac_vol1 = AMP_OUT_ZERO; 10979 if (line_nid != 0x16 || hp_nid != 0x16 || 10980 spec->autocfg.line_out_pins[1] != 0x16 || 10981 spec->autocfg.line_out_pins[2] != 0x16) 10982 dac_vol1 = dac_vol2 = AMP_OUT_ZERO; 10983 10984 snd_hda_codec_write(codec, 0x02, 0, 10985 AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1); 10986 snd_hda_codec_write(codec, 0x03, 0, 10987 AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2); 10988} 10989 10990/* pcm configuration: identiacal with ALC880 */ 10991#define alc268_pcm_analog_playback alc880_pcm_analog_playback 10992#define alc268_pcm_analog_capture alc880_pcm_analog_capture 10993#define alc268_pcm_analog_alt_capture alc880_pcm_analog_alt_capture 10994#define alc268_pcm_digital_playback alc880_pcm_digital_playback 10995 10996/* 10997 * BIOS auto configuration 10998 */ 10999static int alc268_parse_auto_config(struct hda_codec *codec) 11000{ 11001 struct alc_spec *spec = codec->spec; 11002 int err; 11003 static hda_nid_t alc268_ignore[] = { 0 }; 11004 11005 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 11006 alc268_ignore); 11007 if (err < 0) 11008 return err; 11009 if (!spec->autocfg.line_outs) 11010 return 0; /* can't find valid BIOS pin config */ 11011 11012 err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg); 11013 if (err < 0) 11014 return err; 11015 err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg); 11016 if (err < 0) 11017 return err; 11018 11019 spec->multiout.max_channels = 2; 11020 11021 /* digital only support output */ 11022 if (spec->autocfg.dig_out_pin) 11023 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID; 11024 11025 if (spec->kctl_alloc) 11026 spec->mixers[spec->num_mixers++] = spec->kctl_alloc; 11027 11028 if (spec->autocfg.speaker_pins[0] != 0x1d) 11029 spec->mixers[spec->num_mixers++] = alc268_beep_mixer; 11030 11031 spec->init_verbs[spec->num_init_verbs++] = alc268_volume_init_verbs; 11032 spec->num_mux_defs = 1; 11033 spec->input_mux = &spec->private_imux; 11034 11035 err = alc_auto_add_mic_boost(codec); 11036 if (err < 0) 11037 return err; 11038 11039 return 1; 11040} 11041 11042#define alc268_auto_init_multi_out alc882_auto_init_multi_out 11043#define alc268_auto_init_hp_out alc882_auto_init_hp_out 11044#define alc268_auto_init_analog_input alc882_auto_init_analog_input 11045 11046/* init callback for auto-configuration model -- overriding the default init */ 11047static void alc268_auto_init(struct hda_codec *codec) 11048{ 11049 struct alc_spec *spec = codec->spec; 11050 alc268_auto_init_multi_out(codec); 11051 alc268_auto_init_hp_out(codec); 11052 alc268_auto_init_mono_speaker_out(codec); 11053 alc268_auto_init_analog_input(codec); 11054 if (spec->unsol_event) 11055 alc_sku_automute(codec); 11056} 11057 11058/* 11059 * configuration and preset 11060 */ 11061static const char *alc268_models[ALC268_MODEL_LAST] = { 11062 [ALC267_QUANTA_IL1] = "quanta-il1", 11063 [ALC268_3ST] = "3stack", 11064 [ALC268_TOSHIBA] = "toshiba", 11065 [ALC268_ACER] = "acer", 11066 [ALC268_ACER_ASPIRE_ONE] = "acer-aspire", 11067 [ALC268_DELL] = "dell", 11068 [ALC268_ZEPTO] = "zepto", 11069#ifdef CONFIG_SND_DEBUG 11070 [ALC268_TEST] = "test", 11071#endif 11072 [ALC268_AUTO] = "auto", 11073}; 11074 11075static struct snd_pci_quirk alc268_cfg_tbl[] = { 11076 SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER), 11077 SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER), 11078 SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER), 11079 SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER), 11080 SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER), 11081 SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One", 11082 ALC268_ACER_ASPIRE_ONE), 11083 SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL), 11084 SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA), 11085 SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST), 11086 SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA), 11087 SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA), 11088 SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA), 11089 SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER), 11090 SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1), 11091 SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO), 11092 {} 11093}; 11094 11095static struct alc_config_preset alc268_presets[] = { 11096 [ALC267_QUANTA_IL1] = { 11097 .mixers = { alc267_quanta_il1_mixer }, 11098 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 11099 alc267_quanta_il1_verbs }, 11100 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 11101 .dac_nids = alc268_dac_nids, 11102 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 11103 .adc_nids = alc268_adc_nids_alt, 11104 .hp_nid = 0x03, 11105 .num_channel_mode = ARRAY_SIZE(alc268_modes), 11106 .channel_mode = alc268_modes, 11107 .input_mux = &alc268_capture_source, 11108 .unsol_event = alc267_quanta_il1_unsol_event, 11109 .init_hook = alc267_quanta_il1_automute, 11110 }, 11111 [ALC268_3ST] = { 11112 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer, 11113 alc268_beep_mixer }, 11114 .init_verbs = { alc268_base_init_verbs }, 11115 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 11116 .dac_nids = alc268_dac_nids, 11117 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 11118 .adc_nids = alc268_adc_nids_alt, 11119 .capsrc_nids = alc268_capsrc_nids, 11120 .hp_nid = 0x03, 11121 .dig_out_nid = ALC268_DIGOUT_NID, 11122 .num_channel_mode = ARRAY_SIZE(alc268_modes), 11123 .channel_mode = alc268_modes, 11124 .input_mux = &alc268_capture_source, 11125 }, 11126 [ALC268_TOSHIBA] = { 11127 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer, 11128 alc268_beep_mixer }, 11129 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 11130 alc268_toshiba_verbs }, 11131 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 11132 .dac_nids = alc268_dac_nids, 11133 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 11134 .adc_nids = alc268_adc_nids_alt, 11135 .capsrc_nids = alc268_capsrc_nids, 11136 .hp_nid = 0x03, 11137 .num_channel_mode = ARRAY_SIZE(alc268_modes), 11138 .channel_mode = alc268_modes, 11139 .input_mux = &alc268_capture_source, 11140 .unsol_event = alc268_toshiba_unsol_event, 11141 .init_hook = alc268_toshiba_automute, 11142 }, 11143 [ALC268_ACER] = { 11144 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer, 11145 alc268_beep_mixer }, 11146 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 11147 alc268_acer_verbs }, 11148 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 11149 .dac_nids = alc268_dac_nids, 11150 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 11151 .adc_nids = alc268_adc_nids_alt, 11152 .capsrc_nids = alc268_capsrc_nids, 11153 .hp_nid = 0x02, 11154 .num_channel_mode = ARRAY_SIZE(alc268_modes), 11155 .channel_mode = alc268_modes, 11156 .input_mux = &alc268_acer_capture_source, 11157 .unsol_event = alc268_acer_unsol_event, 11158 .init_hook = alc268_acer_init_hook, 11159 }, 11160 [ALC268_ACER_ASPIRE_ONE] = { 11161 .mixers = { alc268_acer_aspire_one_mixer, 11162 alc268_capture_alt_mixer }, 11163 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 11164 alc268_acer_aspire_one_verbs }, 11165 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 11166 .dac_nids = alc268_dac_nids, 11167 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 11168 .adc_nids = alc268_adc_nids_alt, 11169 .capsrc_nids = alc268_capsrc_nids, 11170 .hp_nid = 0x03, 11171 .num_channel_mode = ARRAY_SIZE(alc268_modes), 11172 .channel_mode = alc268_modes, 11173 .input_mux = &alc268_acer_lc_capture_source, 11174 .unsol_event = alc268_acer_lc_unsol_event, 11175 .init_hook = alc268_acer_lc_init_hook, 11176 }, 11177 [ALC268_DELL] = { 11178 .mixers = { alc268_dell_mixer, alc268_beep_mixer }, 11179 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 11180 alc268_dell_verbs }, 11181 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 11182 .dac_nids = alc268_dac_nids, 11183 .hp_nid = 0x02, 11184 .num_channel_mode = ARRAY_SIZE(alc268_modes), 11185 .channel_mode = alc268_modes, 11186 .unsol_event = alc268_dell_unsol_event, 11187 .init_hook = alc268_dell_init_hook, 11188 .input_mux = &alc268_capture_source, 11189 }, 11190 [ALC268_ZEPTO] = { 11191 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer, 11192 alc268_beep_mixer }, 11193 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 11194 alc268_toshiba_verbs }, 11195 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 11196 .dac_nids = alc268_dac_nids, 11197 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 11198 .adc_nids = alc268_adc_nids_alt, 11199 .capsrc_nids = alc268_capsrc_nids, 11200 .hp_nid = 0x03, 11201 .dig_out_nid = ALC268_DIGOUT_NID, 11202 .num_channel_mode = ARRAY_SIZE(alc268_modes), 11203 .channel_mode = alc268_modes, 11204 .input_mux = &alc268_capture_source, 11205 .unsol_event = alc268_toshiba_unsol_event, 11206 .init_hook = alc268_toshiba_automute 11207 }, 11208#ifdef CONFIG_SND_DEBUG 11209 [ALC268_TEST] = { 11210 .mixers = { alc268_test_mixer, alc268_capture_mixer }, 11211 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs, 11212 alc268_volume_init_verbs }, 11213 .num_dacs = ARRAY_SIZE(alc268_dac_nids), 11214 .dac_nids = alc268_dac_nids, 11215 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt), 11216 .adc_nids = alc268_adc_nids_alt, 11217 .capsrc_nids = alc268_capsrc_nids, 11218 .hp_nid = 0x03, 11219 .dig_out_nid = ALC268_DIGOUT_NID, 11220 .num_channel_mode = ARRAY_SIZE(alc268_modes), 11221 .channel_mode = alc268_modes, 11222 .input_mux = &alc268_capture_source, 11223 }, 11224#endif 11225}; 11226 11227static int patch_alc268(struct hda_codec *codec) 11228{ 11229 struct alc_spec *spec; 11230 int board_config; 11231 int err; 11232 11233 spec = kcalloc(1, sizeof(*spec), GFP_KERNEL); 11234 if (spec == NULL) 11235 return -ENOMEM; 11236 11237 codec->spec = spec; 11238 11239 board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST, 11240 alc268_models, 11241 alc268_cfg_tbl); 11242 11243 if (board_config < 0 || board_config >= ALC268_MODEL_LAST) { 11244 printk(KERN_INFO "hda_codec: Unknown model for ALC268, " 11245 "trying auto-probe from BIOS...\n"); 11246 board_config = ALC268_AUTO; 11247 } 11248 11249 if (board_config == ALC268_AUTO) { 11250 /* automatic parse from the BIOS config */ 11251 err = alc268_parse_auto_config(codec); 11252 if (err < 0) { 11253 alc_free(codec); 11254 return err; 11255 } else if (!err) { 11256 printk(KERN_INFO 11257 "hda_codec: Cannot set up configuration " 11258 "from BIOS. Using base mode...\n"); 11259 board_config = ALC268_3ST; 11260 } 11261 } 11262 11263 if (board_config != ALC268_AUTO) 11264 setup_preset(spec, &alc268_presets[board_config]); 11265 11266 if (codec->vendor_id == 0x10ec0267) { 11267 spec->stream_name_analog = "ALC267 Analog"; 11268 spec->stream_name_digital = "ALC267 Digital"; 11269 } else { 11270 spec->stream_name_analog = "ALC268 Analog"; 11271 spec->stream_name_digital = "ALC268 Digital"; 11272 } 11273 11274 spec->stream_analog_playback = &alc268_pcm_analog_playback; 11275 spec->stream_analog_capture = &alc268_pcm_analog_capture; 11276 spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture; 11277 11278 spec->stream_digital_playback = &alc268_pcm_digital_playback; 11279 11280 if (!query_amp_caps(codec, 0x1d, HDA_INPUT)) 11281 /* override the amp caps for beep generator */ 11282 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT, 11283 (0x0c << AC_AMPCAP_OFFSET_SHIFT) | 11284 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) | 11285 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) | 11286 (0 << AC_AMPCAP_MUTE_SHIFT)); 11287 11288 if (!spec->adc_nids && spec->input_mux) { 11289 /* check whether NID 0x07 is valid */ 11290 unsigned int wcap = get_wcaps(codec, 0x07); 11291 int i; 11292 11293 /* get type */ 11294 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 11295 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) { 11296 spec->adc_nids = alc268_adc_nids_alt; 11297 spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt); 11298 spec->mixers[spec->num_mixers] = 11299 alc268_capture_alt_mixer; 11300 spec->num_mixers++; 11301 } else { 11302 spec->adc_nids = alc268_adc_nids; 11303 spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids); 11304 spec->mixers[spec->num_mixers] = 11305 alc268_capture_mixer; 11306 spec->num_mixers++; 11307 } 11308 spec->capsrc_nids = alc268_capsrc_nids; 11309 /* set default input source */ 11310 for (i = 0; i < spec->num_adc_nids; i++) 11311 snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i], 11312 0, AC_VERB_SET_CONNECT_SEL, 11313 spec->input_mux->items[0].index); 11314 } 11315 11316 spec->vmaster_nid = 0x02; 11317 11318 codec->patch_ops = alc_patch_ops; 11319 if (board_config == ALC268_AUTO) 11320 spec->init_hook = alc268_auto_init; 11321 11322 return 0; 11323} 11324 11325/* 11326 * ALC269 channel source setting (2 channel) 11327 */ 11328#define ALC269_DIGOUT_NID ALC880_DIGOUT_NID 11329 11330#define alc269_dac_nids alc260_dac_nids 11331 11332static hda_nid_t alc269_adc_nids[1] = { 11333 /* ADC1 */ 11334 0x08, 11335}; 11336 11337static hda_nid_t alc269_capsrc_nids[1] = { 11338 0x23, 11339}; 11340 11341/* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24), 11342 * not a mux! 11343 */ 11344 11345static struct hda_input_mux alc269_eeepc_dmic_capture_source = { 11346 .num_items = 2, 11347 .items = { 11348 { "i-Mic", 0x5 }, 11349 { "e-Mic", 0x0 }, 11350 }, 11351}; 11352 11353static struct hda_input_mux alc269_eeepc_amic_capture_source = { 11354 .num_items = 2, 11355 .items = { 11356 { "i-Mic", 0x1 }, 11357 { "e-Mic", 0x0 }, 11358 }, 11359}; 11360 11361#define alc269_modes alc260_modes 11362#define alc269_capture_source alc880_lg_lw_capture_source 11363 11364static struct snd_kcontrol_new alc269_base_mixer[] = { 11365 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 11366 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 11367 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 11368 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 11369 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 11370 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 11371 HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x4, HDA_INPUT), 11372 HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x4, HDA_INPUT), 11373 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 11374 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 11375 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 11376 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 11377 HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), 11378 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT), 11379 { } /* end */ 11380}; 11381 11382static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = { 11383 /* output mixer control */ 11384 HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol), 11385 { 11386 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11387 .name = "Master Playback Switch", 11388 .info = snd_hda_mixer_amp_switch_info, 11389 .get = snd_hda_mixer_amp_switch_get, 11390 .put = alc268_acer_master_sw_put, 11391 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 11392 }, 11393 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 11394 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 11395 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 11396 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), 11397 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), 11398 HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT), 11399 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x04, HDA_INPUT), 11400 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x04, HDA_INPUT), 11401 { } 11402}; 11403 11404/* bind volumes of both NID 0x0c and 0x0d */ 11405static struct hda_bind_ctls alc269_epc_bind_vol = { 11406 .ops = &snd_hda_bind_vol, 11407 .values = { 11408 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT), 11409 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT), 11410 0 11411 }, 11412}; 11413 11414static struct snd_kcontrol_new alc269_eeepc_mixer[] = { 11415 HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 11416 HDA_BIND_VOL("LineOut Playback Volume", &alc269_epc_bind_vol), 11417 HDA_CODEC_MUTE("LineOut Playback Switch", 0x15, 0x0, HDA_OUTPUT), 11418 { } /* end */ 11419}; 11420 11421/* capture mixer elements */ 11422static struct snd_kcontrol_new alc269_capture_mixer[] = { 11423 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 11424 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 11425 { 11426 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 11427 /* The multiple "Capture Source" controls confuse alsamixer 11428 * So call somewhat different.. 11429 */ 11430 /* .name = "Capture Source", */ 11431 .name = "Input Source", 11432 .count = 1, 11433 .info = alc_mux_enum_info, 11434 .get = alc_mux_enum_get, 11435 .put = alc_mux_enum_put, 11436 }, 11437 { } /* end */ 11438}; 11439 11440/* capture mixer elements */ 11441static struct snd_kcontrol_new alc269_epc_capture_mixer[] = { 11442 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 11443 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 11444 { } /* end */ 11445}; 11446 11447/* beep control */ 11448static struct snd_kcontrol_new alc269_beep_mixer[] = { 11449 HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x4, HDA_INPUT), 11450 HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x4, HDA_INPUT), 11451 { } /* end */ 11452}; 11453 11454static struct hda_verb alc269_quanta_fl1_verbs[] = { 11455 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 11456 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 11457 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 11458 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, 11459 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 11460 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 11461 { } 11462}; 11463 11464/* toggle speaker-output according to the hp-jack state */ 11465static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec) 11466{ 11467 unsigned int present; 11468 unsigned char bits; 11469 11470 present = snd_hda_codec_read(codec, 0x15, 0, 11471 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 11472 bits = present ? AMP_IN_MUTE(0) : 0; 11473 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 11474 AMP_IN_MUTE(0), bits); 11475 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 11476 AMP_IN_MUTE(0), bits); 11477 11478 snd_hda_codec_write(codec, 0x20, 0, 11479 AC_VERB_SET_COEF_INDEX, 0x0c); 11480 snd_hda_codec_write(codec, 0x20, 0, 11481 AC_VERB_SET_PROC_COEF, 0x680); 11482 11483 snd_hda_codec_write(codec, 0x20, 0, 11484 AC_VERB_SET_COEF_INDEX, 0x0c); 11485 snd_hda_codec_write(codec, 0x20, 0, 11486 AC_VERB_SET_PROC_COEF, 0x480); 11487} 11488 11489static void alc269_quanta_fl1_mic_automute(struct hda_codec *codec) 11490{ 11491 unsigned int present; 11492 11493 present = snd_hda_codec_read(codec, 0x18, 0, 11494 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 11495 snd_hda_codec_write(codec, 0x23, 0, 11496 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x1); 11497} 11498 11499static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec, 11500 unsigned int res) 11501{ 11502 if ((res >> 26) == ALC880_HP_EVENT) 11503 alc269_quanta_fl1_speaker_automute(codec); 11504 if ((res >> 26) == ALC880_MIC_EVENT) 11505 alc269_quanta_fl1_mic_automute(codec); 11506} 11507 11508static void alc269_quanta_fl1_init_hook(struct hda_codec *codec) 11509{ 11510 alc269_quanta_fl1_speaker_automute(codec); 11511 alc269_quanta_fl1_mic_automute(codec); 11512} 11513 11514static struct hda_verb alc269_eeepc_dmic_init_verbs[] = { 11515 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 11516 {0x23, AC_VERB_SET_CONNECT_SEL, 0x05}, 11517 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 }, 11518 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))}, 11519 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 11520 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 11521 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 11522 {} 11523}; 11524 11525static struct hda_verb alc269_eeepc_amic_init_verbs[] = { 11526 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 11527 {0x23, AC_VERB_SET_CONNECT_SEL, 0x01}, 11528 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 }, 11529 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))}, 11530 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 11531 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 11532 {} 11533}; 11534 11535/* toggle speaker-output according to the hp-jack state */ 11536static void alc269_speaker_automute(struct hda_codec *codec) 11537{ 11538 unsigned int present; 11539 unsigned char bits; 11540 11541 present = snd_hda_codec_read(codec, 0x15, 0, 11542 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 11543 bits = present ? AMP_IN_MUTE(0) : 0; 11544 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0, 11545 AMP_IN_MUTE(0), bits); 11546 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, 11547 AMP_IN_MUTE(0), bits); 11548} 11549 11550static void alc269_eeepc_dmic_automute(struct hda_codec *codec) 11551{ 11552 unsigned int present; 11553 11554 present = snd_hda_codec_read(codec, 0x18, 0, 11555 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 11556 snd_hda_codec_write(codec, 0x23, 0, 11557 AC_VERB_SET_CONNECT_SEL, (present ? 0 : 5)); 11558} 11559 11560static void alc269_eeepc_amic_automute(struct hda_codec *codec) 11561{ 11562 unsigned int present; 11563 11564 present = snd_hda_codec_read(codec, 0x18, 0, 11565 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 11566 snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE, 11567 0x7000 | (0x00 << 8) | (present ? 0 : 0x80)); 11568 snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE, 11569 0x7000 | (0x01 << 8) | (present ? 0x80 : 0)); 11570} 11571 11572/* unsolicited event for HP jack sensing */ 11573static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec, 11574 unsigned int res) 11575{ 11576 if ((res >> 26) == ALC880_HP_EVENT) 11577 alc269_speaker_automute(codec); 11578 11579 if ((res >> 26) == ALC880_MIC_EVENT) 11580 alc269_eeepc_dmic_automute(codec); 11581} 11582 11583static void alc269_eeepc_dmic_inithook(struct hda_codec *codec) 11584{ 11585 alc269_speaker_automute(codec); 11586 alc269_eeepc_dmic_automute(codec); 11587} 11588 11589/* unsolicited event for HP jack sensing */ 11590static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec, 11591 unsigned int res) 11592{ 11593 if ((res >> 26) == ALC880_HP_EVENT) 11594 alc269_speaker_automute(codec); 11595 11596 if ((res >> 26) == ALC880_MIC_EVENT) 11597 alc269_eeepc_amic_automute(codec); 11598} 11599 11600static void alc269_eeepc_amic_inithook(struct hda_codec *codec) 11601{ 11602 alc269_speaker_automute(codec); 11603 alc269_eeepc_amic_automute(codec); 11604} 11605 11606/* 11607 * generic initialization of ADC, input mixers and output mixers 11608 */ 11609static struct hda_verb alc269_init_verbs[] = { 11610 /* 11611 * Unmute ADC0 and set the default input to mic-in 11612 */ 11613 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11614 11615 /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the 11616 * analog-loopback mixer widget 11617 * Note: PASD motherboards uses the Line In 2 as the input for 11618 * front panel mic (mic 2) 11619 */ 11620 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 11621 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 11622 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 11623 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 11624 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 11625 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 11626 11627 /* 11628 * Set up output mixers (0x0c - 0x0e) 11629 */ 11630 /* set vol=0 to output mixers */ 11631 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 11632 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 11633 11634 /* set up input amps for analog loopback */ 11635 /* Amp Indices: DAC = 0, mixer = 1 */ 11636 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11637 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11638 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11639 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11640 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 11641 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11642 11643 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 11644 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 11645 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 11646 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 11647 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 11648 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 11649 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 11650 11651 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11652 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 11653 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11654 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11655 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11656 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11657 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 11658 11659 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 11660 {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, 11661 11662 /* FIXME: use matrix-type input source selection */ 11663 /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */ 11664 /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ 11665 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 11666 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 11667 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 11668 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 11669 11670 /* set EAPD */ 11671 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 11672 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 11673 { } 11674}; 11675 11676/* add playback controls from the parsed DAC table */ 11677static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec, 11678 const struct auto_pin_cfg *cfg) 11679{ 11680 hda_nid_t nid; 11681 int err; 11682 11683 spec->multiout.num_dacs = 1; /* only use one dac */ 11684 spec->multiout.dac_nids = spec->private_dac_nids; 11685 spec->multiout.dac_nids[0] = 2; 11686 11687 nid = cfg->line_out_pins[0]; 11688 if (nid) { 11689 err = add_control(spec, ALC_CTL_WIDGET_VOL, 11690 "Front Playback Volume", 11691 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT)); 11692 if (err < 0) 11693 return err; 11694 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 11695 "Front Playback Switch", 11696 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 11697 if (err < 0) 11698 return err; 11699 } 11700 11701 nid = cfg->speaker_pins[0]; 11702 if (nid) { 11703 if (!cfg->line_out_pins[0]) { 11704 err = add_control(spec, ALC_CTL_WIDGET_VOL, 11705 "Speaker Playback Volume", 11706 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, 11707 HDA_OUTPUT)); 11708 if (err < 0) 11709 return err; 11710 } 11711 if (nid == 0x16) { 11712 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 11713 "Speaker Playback Switch", 11714 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 11715 HDA_OUTPUT)); 11716 if (err < 0) 11717 return err; 11718 } else { 11719 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 11720 "Speaker Playback Switch", 11721 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 11722 HDA_OUTPUT)); 11723 if (err < 0) 11724 return err; 11725 } 11726 } 11727 nid = cfg->hp_pins[0]; 11728 if (nid) { 11729 /* spec->multiout.hp_nid = 2; */ 11730 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) { 11731 err = add_control(spec, ALC_CTL_WIDGET_VOL, 11732 "Headphone Playback Volume", 11733 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, 11734 HDA_OUTPUT)); 11735 if (err < 0) 11736 return err; 11737 } 11738 if (nid == 0x16) { 11739 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 11740 "Headphone Playback Switch", 11741 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 11742 HDA_OUTPUT)); 11743 if (err < 0) 11744 return err; 11745 } else { 11746 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 11747 "Headphone Playback Switch", 11748 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 11749 HDA_OUTPUT)); 11750 if (err < 0) 11751 return err; 11752 } 11753 } 11754 return 0; 11755} 11756 11757#define alc269_auto_create_analog_input_ctls \ 11758 alc880_auto_create_analog_input_ctls 11759 11760#ifdef CONFIG_SND_HDA_POWER_SAVE 11761#define alc269_loopbacks alc880_loopbacks 11762#endif 11763 11764/* pcm configuration: identiacal with ALC880 */ 11765#define alc269_pcm_analog_playback alc880_pcm_analog_playback 11766#define alc269_pcm_analog_capture alc880_pcm_analog_capture 11767#define alc269_pcm_digital_playback alc880_pcm_digital_playback 11768#define alc269_pcm_digital_capture alc880_pcm_digital_capture 11769 11770/* 11771 * BIOS auto configuration 11772 */ 11773static int alc269_parse_auto_config(struct hda_codec *codec) 11774{ 11775 struct alc_spec *spec = codec->spec; 11776 int i, err; 11777 static hda_nid_t alc269_ignore[] = { 0x1d, 0 }; 11778 11779 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 11780 alc269_ignore); 11781 if (err < 0) 11782 return err; 11783 11784 err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg); 11785 if (err < 0) 11786 return err; 11787 err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg); 11788 if (err < 0) 11789 return err; 11790 11791 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 11792 11793 if (spec->autocfg.dig_out_pin) 11794 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID; 11795 11796 if (spec->kctl_alloc) 11797 spec->mixers[spec->num_mixers++] = spec->kctl_alloc; 11798 11799 /* create a beep mixer control if the pin 0x1d isn't assigned */ 11800 for (i = 0; i < ARRAY_SIZE(spec->autocfg.input_pins); i++) 11801 if (spec->autocfg.input_pins[i] == 0x1d) 11802 break; 11803 if (i >= ARRAY_SIZE(spec->autocfg.input_pins)) 11804 spec->mixers[spec->num_mixers++] = alc269_beep_mixer; 11805 11806 spec->init_verbs[spec->num_init_verbs++] = alc269_init_verbs; 11807 spec->num_mux_defs = 1; 11808 spec->input_mux = &spec->private_imux; 11809 /* set default input source */ 11810 snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0], 11811 0, AC_VERB_SET_CONNECT_SEL, 11812 spec->input_mux->items[0].index); 11813 11814 err = alc_auto_add_mic_boost(codec); 11815 if (err < 0) 11816 return err; 11817 11818 spec->mixers[spec->num_mixers] = alc269_capture_mixer; 11819 spec->num_mixers++; 11820 11821 return 1; 11822} 11823 11824#define alc269_auto_init_multi_out alc882_auto_init_multi_out 11825#define alc269_auto_init_hp_out alc882_auto_init_hp_out 11826#define alc269_auto_init_analog_input alc882_auto_init_analog_input 11827 11828 11829/* init callback for auto-configuration model -- overriding the default init */ 11830static void alc269_auto_init(struct hda_codec *codec) 11831{ 11832 struct alc_spec *spec = codec->spec; 11833 alc269_auto_init_multi_out(codec); 11834 alc269_auto_init_hp_out(codec); 11835 alc269_auto_init_analog_input(codec); 11836 if (spec->unsol_event) 11837 alc_sku_automute(codec); 11838} 11839 11840/* 11841 * configuration and preset 11842 */ 11843static const char *alc269_models[ALC269_MODEL_LAST] = { 11844 [ALC269_BASIC] = "basic", 11845 [ALC269_QUANTA_FL1] = "Quanta", 11846 [ALC269_ASUS_EEEPC_P901] = "Asus_Epc_Dmic" 11847}; 11848 11849static struct snd_pci_quirk alc269_cfg_tbl[] = { 11850 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1), 11851 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A", 11852 ALC269_ASUS_EEEPC_P703), 11853 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901", 11854 ALC269_ASUS_EEEPC_P901), 11855 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101", 11856 ALC269_ASUS_EEEPC_P901), 11857 {} 11858}; 11859 11860static struct alc_config_preset alc269_presets[] = { 11861 [ALC269_BASIC] = { 11862 .mixers = { alc269_base_mixer, alc269_capture_mixer }, 11863 .init_verbs = { alc269_init_verbs }, 11864 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 11865 .dac_nids = alc269_dac_nids, 11866 .hp_nid = 0x03, 11867 .num_channel_mode = ARRAY_SIZE(alc269_modes), 11868 .channel_mode = alc269_modes, 11869 .input_mux = &alc269_capture_source, 11870 }, 11871 [ALC269_QUANTA_FL1] = { 11872 .mixers = { alc269_quanta_fl1_mixer }, 11873 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs }, 11874 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 11875 .dac_nids = alc269_dac_nids, 11876 .hp_nid = 0x03, 11877 .num_channel_mode = ARRAY_SIZE(alc269_modes), 11878 .channel_mode = alc269_modes, 11879 .input_mux = &alc269_capture_source, 11880 .unsol_event = alc269_quanta_fl1_unsol_event, 11881 .init_hook = alc269_quanta_fl1_init_hook, 11882 }, 11883 [ALC269_ASUS_EEEPC_P703] = { 11884 .mixers = { alc269_eeepc_mixer, alc269_epc_capture_mixer }, 11885 .init_verbs = { alc269_init_verbs, 11886 alc269_eeepc_amic_init_verbs }, 11887 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 11888 .dac_nids = alc269_dac_nids, 11889 .hp_nid = 0x03, 11890 .num_channel_mode = ARRAY_SIZE(alc269_modes), 11891 .channel_mode = alc269_modes, 11892 .input_mux = &alc269_eeepc_amic_capture_source, 11893 .unsol_event = alc269_eeepc_amic_unsol_event, 11894 .init_hook = alc269_eeepc_amic_inithook, 11895 }, 11896 [ALC269_ASUS_EEEPC_P901] = { 11897 .mixers = { alc269_eeepc_mixer, alc269_epc_capture_mixer}, 11898 .init_verbs = { alc269_init_verbs, 11899 alc269_eeepc_dmic_init_verbs }, 11900 .num_dacs = ARRAY_SIZE(alc269_dac_nids), 11901 .dac_nids = alc269_dac_nids, 11902 .hp_nid = 0x03, 11903 .num_channel_mode = ARRAY_SIZE(alc269_modes), 11904 .channel_mode = alc269_modes, 11905 .input_mux = &alc269_eeepc_dmic_capture_source, 11906 .unsol_event = alc269_eeepc_dmic_unsol_event, 11907 .init_hook = alc269_eeepc_dmic_inithook, 11908 }, 11909}; 11910 11911static int patch_alc269(struct hda_codec *codec) 11912{ 11913 struct alc_spec *spec; 11914 int board_config; 11915 int err; 11916 11917 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 11918 if (spec == NULL) 11919 return -ENOMEM; 11920 11921 codec->spec = spec; 11922 11923 alc_fix_pll_init(codec, 0x20, 0x04, 15); 11924 11925 board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST, 11926 alc269_models, 11927 alc269_cfg_tbl); 11928 11929 if (board_config < 0) { 11930 printk(KERN_INFO "hda_codec: Unknown model for ALC269, " 11931 "trying auto-probe from BIOS...\n"); 11932 board_config = ALC269_AUTO; 11933 } 11934 11935 if (board_config == ALC269_AUTO) { 11936 /* automatic parse from the BIOS config */ 11937 err = alc269_parse_auto_config(codec); 11938 if (err < 0) { 11939 alc_free(codec); 11940 return err; 11941 } else if (!err) { 11942 printk(KERN_INFO 11943 "hda_codec: Cannot set up configuration " 11944 "from BIOS. Using base mode...\n"); 11945 board_config = ALC269_BASIC; 11946 } 11947 } 11948 11949 if (board_config != ALC269_AUTO) 11950 setup_preset(spec, &alc269_presets[board_config]); 11951 11952 spec->stream_name_analog = "ALC269 Analog"; 11953 spec->stream_analog_playback = &alc269_pcm_analog_playback; 11954 spec->stream_analog_capture = &alc269_pcm_analog_capture; 11955 11956 spec->stream_name_digital = "ALC269 Digital"; 11957 spec->stream_digital_playback = &alc269_pcm_digital_playback; 11958 spec->stream_digital_capture = &alc269_pcm_digital_capture; 11959 11960 spec->adc_nids = alc269_adc_nids; 11961 spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids); 11962 spec->capsrc_nids = alc269_capsrc_nids; 11963 11964 codec->patch_ops = alc_patch_ops; 11965 if (board_config == ALC269_AUTO) 11966 spec->init_hook = alc269_auto_init; 11967#ifdef CONFIG_SND_HDA_POWER_SAVE 11968 if (!spec->loopback.amplist) 11969 spec->loopback.amplist = alc269_loopbacks; 11970#endif 11971 11972 return 0; 11973} 11974 11975/* 11976 * ALC861 channel source setting (2/6 channel selection for 3-stack) 11977 */ 11978 11979/* 11980 * set the path ways for 2 channel output 11981 * need to set the codec line out and mic 1 pin widgets to inputs 11982 */ 11983static struct hda_verb alc861_threestack_ch2_init[] = { 11984 /* set pin widget 1Ah (line in) for input */ 11985 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 11986 /* set pin widget 18h (mic1/2) for input, for mic also enable 11987 * the vref 11988 */ 11989 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 11990 11991 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c }, 11992#if 0 11993 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/ 11994 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/ 11995#endif 11996 { } /* end */ 11997}; 11998/* 11999 * 6ch mode 12000 * need to set the codec line out and mic 1 pin widgets to outputs 12001 */ 12002static struct hda_verb alc861_threestack_ch6_init[] = { 12003 /* set pin widget 1Ah (line in) for output (Back Surround)*/ 12004 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 12005 /* set pin widget 18h (mic1) for output (CLFE)*/ 12006 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 12007 12008 { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 }, 12009 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 }, 12010 12011 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 }, 12012#if 0 12013 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/ 12014 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/ 12015#endif 12016 { } /* end */ 12017}; 12018 12019static struct hda_channel_mode alc861_threestack_modes[2] = { 12020 { 2, alc861_threestack_ch2_init }, 12021 { 6, alc861_threestack_ch6_init }, 12022}; 12023/* Set mic1 as input and unmute the mixer */ 12024static struct hda_verb alc861_uniwill_m31_ch2_init[] = { 12025 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 12026 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/ 12027 { } /* end */ 12028}; 12029/* Set mic1 as output and mute mixer */ 12030static struct hda_verb alc861_uniwill_m31_ch4_init[] = { 12031 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 12032 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/ 12033 { } /* end */ 12034}; 12035 12036static struct hda_channel_mode alc861_uniwill_m31_modes[2] = { 12037 { 2, alc861_uniwill_m31_ch2_init }, 12038 { 4, alc861_uniwill_m31_ch4_init }, 12039}; 12040 12041/* Set mic1 and line-in as input and unmute the mixer */ 12042static struct hda_verb alc861_asus_ch2_init[] = { 12043 /* set pin widget 1Ah (line in) for input */ 12044 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 12045 /* set pin widget 18h (mic1/2) for input, for mic also enable 12046 * the vref 12047 */ 12048 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 12049 12050 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c }, 12051#if 0 12052 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/ 12053 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/ 12054#endif 12055 { } /* end */ 12056}; 12057/* Set mic1 nad line-in as output and mute mixer */ 12058static struct hda_verb alc861_asus_ch6_init[] = { 12059 /* set pin widget 1Ah (line in) for output (Back Surround)*/ 12060 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 12061 /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */ 12062 /* set pin widget 18h (mic1) for output (CLFE)*/ 12063 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 12064 /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */ 12065 { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 }, 12066 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 }, 12067 12068 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 }, 12069#if 0 12070 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/ 12071 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/ 12072#endif 12073 { } /* end */ 12074}; 12075 12076static struct hda_channel_mode alc861_asus_modes[2] = { 12077 { 2, alc861_asus_ch2_init }, 12078 { 6, alc861_asus_ch6_init }, 12079}; 12080 12081/* patch-ALC861 */ 12082 12083static struct snd_kcontrol_new alc861_base_mixer[] = { 12084 /* output mixer control */ 12085 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT), 12086 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT), 12087 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT), 12088 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT), 12089 HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), 12090 12091 /*Input mixer control */ 12092 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT), 12093 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */ 12094 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 12095 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 12096 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT), 12097 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT), 12098 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 12099 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 12100 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT), 12101 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT), 12102 12103 /* Capture mixer control */ 12104 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 12105 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 12106 { 12107 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 12108 .name = "Capture Source", 12109 .count = 1, 12110 .info = alc_mux_enum_info, 12111 .get = alc_mux_enum_get, 12112 .put = alc_mux_enum_put, 12113 }, 12114 { } /* end */ 12115}; 12116 12117static struct snd_kcontrol_new alc861_3ST_mixer[] = { 12118 /* output mixer control */ 12119 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT), 12120 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT), 12121 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT), 12122 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT), 12123 /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */ 12124 12125 /* Input mixer control */ 12126 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT), 12127 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */ 12128 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 12129 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 12130 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT), 12131 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT), 12132 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 12133 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 12134 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT), 12135 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT), 12136 12137 /* Capture mixer control */ 12138 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 12139 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 12140 { 12141 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 12142 .name = "Capture Source", 12143 .count = 1, 12144 .info = alc_mux_enum_info, 12145 .get = alc_mux_enum_get, 12146 .put = alc_mux_enum_put, 12147 }, 12148 { 12149 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 12150 .name = "Channel Mode", 12151 .info = alc_ch_mode_info, 12152 .get = alc_ch_mode_get, 12153 .put = alc_ch_mode_put, 12154 .private_value = ARRAY_SIZE(alc861_threestack_modes), 12155 }, 12156 { } /* end */ 12157}; 12158 12159static struct snd_kcontrol_new alc861_toshiba_mixer[] = { 12160 /* output mixer control */ 12161 HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT), 12162 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 12163 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 12164 12165 /*Capture mixer control */ 12166 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 12167 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 12168 { 12169 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 12170 .name = "Capture Source", 12171 .count = 1, 12172 .info = alc_mux_enum_info, 12173 .get = alc_mux_enum_get, 12174 .put = alc_mux_enum_put, 12175 }, 12176 12177 { } /* end */ 12178}; 12179 12180static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = { 12181 /* output mixer control */ 12182 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT), 12183 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT), 12184 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT), 12185 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT), 12186 /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */ 12187 12188 /* Input mixer control */ 12189 /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT), 12190 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */ 12191 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 12192 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 12193 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT), 12194 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT), 12195 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 12196 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 12197 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT), 12198 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT), 12199 12200 /* Capture mixer control */ 12201 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 12202 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 12203 { 12204 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 12205 .name = "Capture Source", 12206 .count = 1, 12207 .info = alc_mux_enum_info, 12208 .get = alc_mux_enum_get, 12209 .put = alc_mux_enum_put, 12210 }, 12211 { 12212 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 12213 .name = "Channel Mode", 12214 .info = alc_ch_mode_info, 12215 .get = alc_ch_mode_get, 12216 .put = alc_ch_mode_put, 12217 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes), 12218 }, 12219 { } /* end */ 12220}; 12221 12222static struct snd_kcontrol_new alc861_asus_mixer[] = { 12223 /* output mixer control */ 12224 HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT), 12225 HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT), 12226 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT), 12227 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT), 12228 HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), 12229 12230 /* Input mixer control */ 12231 HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT), 12232 HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), 12233 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 12234 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 12235 HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT), 12236 HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT), 12237 HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), 12238 HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), 12239 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT), 12240 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT), 12241 12242 /* Capture mixer control */ 12243 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 12244 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 12245 { 12246 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 12247 .name = "Capture Source", 12248 .count = 1, 12249 .info = alc_mux_enum_info, 12250 .get = alc_mux_enum_get, 12251 .put = alc_mux_enum_put, 12252 }, 12253 { 12254 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 12255 .name = "Channel Mode", 12256 .info = alc_ch_mode_info, 12257 .get = alc_ch_mode_get, 12258 .put = alc_ch_mode_put, 12259 .private_value = ARRAY_SIZE(alc861_asus_modes), 12260 }, 12261 { } 12262}; 12263 12264/* additional mixer */ 12265static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = { 12266 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), 12267 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), 12268 HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x23, 0x0, HDA_OUTPUT), 12269 HDA_CODEC_MUTE("PC Beep Playback Switch", 0x23, 0x0, HDA_OUTPUT), 12270 { } 12271}; 12272 12273/* 12274 * generic initialization of ADC, input mixers and output mixers 12275 */ 12276static struct hda_verb alc861_base_init_verbs[] = { 12277 /* 12278 * Unmute ADC0 and set the default input to mic-in 12279 */ 12280 /* port-A for surround (rear panel) */ 12281 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 12282 { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 }, 12283 /* port-B for mic-in (rear panel) with vref */ 12284 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 12285 /* port-C for line-in (rear panel) */ 12286 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 12287 /* port-D for Front */ 12288 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 12289 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 }, 12290 /* port-E for HP out (front panel) */ 12291 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 12292 /* route front PCM to HP */ 12293 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 12294 /* port-F for mic-in (front panel) with vref */ 12295 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 12296 /* port-G for CLFE (rear panel) */ 12297 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 12298 { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 12299 /* port-H for side (rear panel) */ 12300 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 12301 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 }, 12302 /* CD-in */ 12303 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 12304 /* route front mic to ADC1*/ 12305 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 12306 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12307 12308 /* Unmute DAC0~3 & spdif out*/ 12309 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12310 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12311 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12312 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12313 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12314 12315 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 12316 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12317 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12318 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12319 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12320 12321 /* Unmute Stereo Mixer 15 */ 12322 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12323 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12324 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 12325 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */ 12326 12327 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12328 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12329 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12330 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12331 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12332 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12333 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12334 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12335 /* hp used DAC 3 (Front) */ 12336 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 12337 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 12338 12339 { } 12340}; 12341 12342static struct hda_verb alc861_threestack_init_verbs[] = { 12343 /* 12344 * Unmute ADC0 and set the default input to mic-in 12345 */ 12346 /* port-A for surround (rear panel) */ 12347 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 12348 /* port-B for mic-in (rear panel) with vref */ 12349 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 12350 /* port-C for line-in (rear panel) */ 12351 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 12352 /* port-D for Front */ 12353 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 12354 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 }, 12355 /* port-E for HP out (front panel) */ 12356 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 12357 /* route front PCM to HP */ 12358 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 12359 /* port-F for mic-in (front panel) with vref */ 12360 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 12361 /* port-G for CLFE (rear panel) */ 12362 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 12363 /* port-H for side (rear panel) */ 12364 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 12365 /* CD-in */ 12366 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 12367 /* route front mic to ADC1*/ 12368 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 12369 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12370 /* Unmute DAC0~3 & spdif out*/ 12371 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12372 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12373 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12374 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12375 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12376 12377 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 12378 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12379 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12380 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12381 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12382 12383 /* Unmute Stereo Mixer 15 */ 12384 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12385 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12386 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 12387 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */ 12388 12389 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12390 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12391 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12392 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12393 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12394 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12395 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12396 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12397 /* hp used DAC 3 (Front) */ 12398 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 12399 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 12400 { } 12401}; 12402 12403static struct hda_verb alc861_uniwill_m31_init_verbs[] = { 12404 /* 12405 * Unmute ADC0 and set the default input to mic-in 12406 */ 12407 /* port-A for surround (rear panel) */ 12408 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 12409 /* port-B for mic-in (rear panel) with vref */ 12410 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 12411 /* port-C for line-in (rear panel) */ 12412 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 12413 /* port-D for Front */ 12414 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 12415 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 }, 12416 /* port-E for HP out (front panel) */ 12417 /* this has to be set to VREF80 */ 12418 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 12419 /* route front PCM to HP */ 12420 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 12421 /* port-F for mic-in (front panel) with vref */ 12422 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 12423 /* port-G for CLFE (rear panel) */ 12424 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 12425 /* port-H for side (rear panel) */ 12426 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 12427 /* CD-in */ 12428 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 12429 /* route front mic to ADC1*/ 12430 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 12431 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12432 /* Unmute DAC0~3 & spdif out*/ 12433 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12434 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12435 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12436 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12437 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12438 12439 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 12440 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12441 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12442 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12443 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12444 12445 /* Unmute Stereo Mixer 15 */ 12446 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12447 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12448 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 12449 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */ 12450 12451 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12452 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12453 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12454 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12455 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12456 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12457 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12458 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12459 /* hp used DAC 3 (Front) */ 12460 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 12461 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 12462 { } 12463}; 12464 12465static struct hda_verb alc861_asus_init_verbs[] = { 12466 /* 12467 * Unmute ADC0 and set the default input to mic-in 12468 */ 12469 /* port-A for surround (rear panel) 12470 * according to codec#0 this is the HP jack 12471 */ 12472 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */ 12473 /* route front PCM to HP */ 12474 { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 }, 12475 /* port-B for mic-in (rear panel) with vref */ 12476 { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 12477 /* port-C for line-in (rear panel) */ 12478 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 12479 /* port-D for Front */ 12480 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 12481 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 }, 12482 /* port-E for HP out (front panel) */ 12483 /* this has to be set to VREF80 */ 12484 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 12485 /* route front PCM to HP */ 12486 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 12487 /* port-F for mic-in (front panel) with vref */ 12488 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 12489 /* port-G for CLFE (rear panel) */ 12490 { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 12491 /* port-H for side (rear panel) */ 12492 { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 12493 /* CD-in */ 12494 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 12495 /* route front mic to ADC1*/ 12496 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, 12497 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12498 /* Unmute DAC0~3 & spdif out*/ 12499 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12500 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12501 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12502 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12503 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12504 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 12505 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12506 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12507 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12508 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12509 12510 /* Unmute Stereo Mixer 15 */ 12511 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12512 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12513 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 12514 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */ 12515 12516 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12517 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12518 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12519 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12520 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12521 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12522 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12523 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12524 /* hp used DAC 3 (Front) */ 12525 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 12526 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 12527 { } 12528}; 12529 12530/* additional init verbs for ASUS laptops */ 12531static struct hda_verb alc861_asus_laptop_init_verbs[] = { 12532 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */ 12533 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */ 12534 { } 12535}; 12536 12537/* 12538 * generic initialization of ADC, input mixers and output mixers 12539 */ 12540static struct hda_verb alc861_auto_init_verbs[] = { 12541 /* 12542 * Unmute ADC0 and set the default input to mic-in 12543 */ 12544 /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */ 12545 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12546 12547 /* Unmute DAC0~3 & spdif out*/ 12548 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12549 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12550 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12551 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 12552 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 12553 12554 /* Unmute Mixer 14 (mic) 1c (Line in)*/ 12555 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12556 {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12557 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12558 {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12559 12560 /* Unmute Stereo Mixer 15 */ 12561 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12562 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12563 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 12564 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, 12565 12566 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12567 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12568 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12569 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12570 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12571 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12572 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 12573 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 12574 12575 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 12576 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 12577 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 12578 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 12579 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 12580 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 12581 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 12582 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 12583 12584 {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, /* set Mic 1 */ 12585 12586 { } 12587}; 12588 12589static struct hda_verb alc861_toshiba_init_verbs[] = { 12590 {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 12591 12592 { } 12593}; 12594 12595/* toggle speaker-output according to the hp-jack state */ 12596static void alc861_toshiba_automute(struct hda_codec *codec) 12597{ 12598 unsigned int present; 12599 12600 present = snd_hda_codec_read(codec, 0x0f, 0, 12601 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 12602 snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0, 12603 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 12604 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3, 12605 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE); 12606} 12607 12608static void alc861_toshiba_unsol_event(struct hda_codec *codec, 12609 unsigned int res) 12610{ 12611 if ((res >> 26) == ALC880_HP_EVENT) 12612 alc861_toshiba_automute(codec); 12613} 12614 12615/* pcm configuration: identiacal with ALC880 */ 12616#define alc861_pcm_analog_playback alc880_pcm_analog_playback 12617#define alc861_pcm_analog_capture alc880_pcm_analog_capture 12618#define alc861_pcm_digital_playback alc880_pcm_digital_playback 12619#define alc861_pcm_digital_capture alc880_pcm_digital_capture 12620 12621 12622#define ALC861_DIGOUT_NID 0x07 12623 12624static struct hda_channel_mode alc861_8ch_modes[1] = { 12625 { 8, NULL } 12626}; 12627 12628static hda_nid_t alc861_dac_nids[4] = { 12629 /* front, surround, clfe, side */ 12630 0x03, 0x06, 0x05, 0x04 12631}; 12632 12633static hda_nid_t alc660_dac_nids[3] = { 12634 /* front, clfe, surround */ 12635 0x03, 0x05, 0x06 12636}; 12637 12638static hda_nid_t alc861_adc_nids[1] = { 12639 /* ADC0-2 */ 12640 0x08, 12641}; 12642 12643static struct hda_input_mux alc861_capture_source = { 12644 .num_items = 5, 12645 .items = { 12646 { "Mic", 0x0 }, 12647 { "Front Mic", 0x3 }, 12648 { "Line", 0x1 }, 12649 { "CD", 0x4 }, 12650 { "Mixer", 0x5 }, 12651 }, 12652}; 12653 12654/* fill in the dac_nids table from the parsed pin configuration */ 12655static int alc861_auto_fill_dac_nids(struct alc_spec *spec, 12656 const struct auto_pin_cfg *cfg) 12657{ 12658 int i; 12659 hda_nid_t nid; 12660 12661 spec->multiout.dac_nids = spec->private_dac_nids; 12662 for (i = 0; i < cfg->line_outs; i++) { 12663 nid = cfg->line_out_pins[i]; 12664 if (nid) { 12665 if (i >= ARRAY_SIZE(alc861_dac_nids)) 12666 continue; 12667 spec->multiout.dac_nids[i] = alc861_dac_nids[i]; 12668 } 12669 } 12670 spec->multiout.num_dacs = cfg->line_outs; 12671 return 0; 12672} 12673 12674/* add playback controls from the parsed DAC table */ 12675static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec, 12676 const struct auto_pin_cfg *cfg) 12677{ 12678 char name[32]; 12679 static const char *chname[4] = { 12680 "Front", "Surround", NULL /*CLFE*/, "Side" 12681 }; 12682 hda_nid_t nid; 12683 int i, idx, err; 12684 12685 for (i = 0; i < cfg->line_outs; i++) { 12686 nid = spec->multiout.dac_nids[i]; 12687 if (!nid) 12688 continue; 12689 if (nid == 0x05) { 12690 /* Center/LFE */ 12691 err = add_control(spec, ALC_CTL_BIND_MUTE, 12692 "Center Playback Switch", 12693 HDA_COMPOSE_AMP_VAL(nid, 1, 0, 12694 HDA_OUTPUT)); 12695 if (err < 0) 12696 return err; 12697 err = add_control(spec, ALC_CTL_BIND_MUTE, 12698 "LFE Playback Switch", 12699 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 12700 HDA_OUTPUT)); 12701 if (err < 0) 12702 return err; 12703 } else { 12704 for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1; 12705 idx++) 12706 if (nid == alc861_dac_nids[idx]) 12707 break; 12708 sprintf(name, "%s Playback Switch", chname[idx]); 12709 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 12710 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 12711 HDA_OUTPUT)); 12712 if (err < 0) 12713 return err; 12714 } 12715 } 12716 return 0; 12717} 12718 12719static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin) 12720{ 12721 int err; 12722 hda_nid_t nid; 12723 12724 if (!pin) 12725 return 0; 12726 12727 if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) { 12728 nid = 0x03; 12729 err = add_control(spec, ALC_CTL_WIDGET_MUTE, 12730 "Headphone Playback Switch", 12731 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 12732 if (err < 0) 12733 return err; 12734 spec->multiout.hp_nid = nid; 12735 } 12736 return 0; 12737} 12738 12739/* create playback/capture controls for input pins */ 12740static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec, 12741 const struct auto_pin_cfg *cfg) 12742{ 12743 struct hda_input_mux *imux = &spec->private_imux; 12744 int i, err, idx, idx1; 12745 12746 for (i = 0; i < AUTO_PIN_LAST; i++) { 12747 switch (cfg->input_pins[i]) { 12748 case 0x0c: 12749 idx1 = 1; 12750 idx = 2; /* Line In */ 12751 break; 12752 case 0x0f: 12753 idx1 = 2; 12754 idx = 2; /* Line In */ 12755 break; 12756 case 0x0d: 12757 idx1 = 0; 12758 idx = 1; /* Mic In */ 12759 break; 12760 case 0x10: 12761 idx1 = 3; 12762 idx = 1; /* Mic In */ 12763 break; 12764 case 0x11: 12765 idx1 = 4; 12766 idx = 0; /* CD */ 12767 break; 12768 default: 12769 continue; 12770 } 12771 12772 err = new_analog_input(spec, cfg->input_pins[i], 12773 auto_pin_cfg_labels[i], idx, 0x15); 12774 if (err < 0) 12775 return err; 12776 12777 imux->items[imux->num_items].label = auto_pin_cfg_labels[i]; 12778 imux->items[imux->num_items].index = idx1; 12779 imux->num_items++; 12780 } 12781 return 0; 12782} 12783 12784static struct snd_kcontrol_new alc861_capture_mixer[] = { 12785 HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), 12786 HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), 12787 12788 { 12789 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 12790 /* The multiple "Capture Source" controls confuse alsamixer 12791 * So call somewhat different.. 12792 */ 12793 /* .name = "Capture Source", */ 12794 .name = "Input Source", 12795 .count = 1, 12796 .info = alc_mux_enum_info, 12797 .get = alc_mux_enum_get, 12798 .put = alc_mux_enum_put, 12799 }, 12800 { } /* end */ 12801}; 12802 12803static void alc861_auto_set_output_and_unmute(struct hda_codec *codec, 12804 hda_nid_t nid, 12805 int pin_type, int dac_idx) 12806{ 12807 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 12808 pin_type); 12809 snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE, 12810 AMP_OUT_UNMUTE); 12811} 12812 12813static void alc861_auto_init_multi_out(struct hda_codec *codec) 12814{ 12815 struct alc_spec *spec = codec->spec; 12816 int i; 12817 12818 alc_subsystem_id(codec, 0x0e, 0x0f, 0x0b); 12819 for (i = 0; i < spec->autocfg.line_outs; i++) { 12820 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 12821 int pin_type = get_pin_type(spec->autocfg.line_out_type); 12822 if (nid) 12823 alc861_auto_set_output_and_unmute(codec, nid, pin_type, 12824 spec->multiout.dac_nids[i]); 12825 } 12826} 12827 12828static void alc861_auto_init_hp_out(struct hda_codec *codec) 12829{ 12830 struct alc_spec *spec = codec->spec; 12831 hda_nid_t pin; 12832 12833 pin = spec->autocfg.hp_pins[0]; 12834 if (pin) /* connect to front */ 12835 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP, 12836 spec->multiout.dac_nids[0]); 12837 pin = spec->autocfg.speaker_pins[0]; 12838 if (pin) 12839 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 12840} 12841 12842static void alc861_auto_init_analog_input(struct hda_codec *codec) 12843{ 12844 struct alc_spec *spec = codec->spec; 12845 int i; 12846 12847 for (i = 0; i < AUTO_PIN_LAST; i++) { 12848 hda_nid_t nid = spec->autocfg.input_pins[i]; 12849 if (nid >= 0x0c && nid <= 0x11) { 12850 snd_hda_codec_write(codec, nid, 0, 12851 AC_VERB_SET_PIN_WIDGET_CONTROL, 12852 i <= AUTO_PIN_FRONT_MIC ? 12853 PIN_VREF80 : PIN_IN); 12854 } 12855 } 12856} 12857 12858/* parse the BIOS configuration and set up the alc_spec */ 12859/* return 1 if successful, 0 if the proper config is not found, 12860 * or a negative error code 12861 */ 12862static int alc861_parse_auto_config(struct hda_codec *codec) 12863{ 12864 struct alc_spec *spec = codec->spec; 12865 int err; 12866 static hda_nid_t alc861_ignore[] = { 0x1d, 0 }; 12867 12868 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 12869 alc861_ignore); 12870 if (err < 0) 12871 return err; 12872 if (!spec->autocfg.line_outs) 12873 return 0; /* can't find valid BIOS pin config */ 12874 12875 err = alc861_auto_fill_dac_nids(spec, &spec->autocfg); 12876 if (err < 0) 12877 return err; 12878 err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg); 12879 if (err < 0) 12880 return err; 12881 err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); 12882 if (err < 0) 12883 return err; 12884 err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg); 12885 if (err < 0) 12886 return err; 12887 12888 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 12889 12890 if (spec->autocfg.dig_out_pin) 12891 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID; 12892 12893 if (spec->kctl_alloc) 12894 spec->mixers[spec->num_mixers++] = spec->kctl_alloc; 12895 12896 spec->init_verbs[spec->num_init_verbs++] = alc861_auto_init_verbs; 12897 12898 spec->num_mux_defs = 1; 12899 spec->input_mux = &spec->private_imux; 12900 12901 spec->adc_nids = alc861_adc_nids; 12902 spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids); 12903 spec->mixers[spec->num_mixers] = alc861_capture_mixer; 12904 spec->num_mixers++; 12905 12906 return 1; 12907} 12908 12909/* additional initialization for auto-configuration model */ 12910static void alc861_auto_init(struct hda_codec *codec) 12911{ 12912 struct alc_spec *spec = codec->spec; 12913 alc861_auto_init_multi_out(codec); 12914 alc861_auto_init_hp_out(codec); 12915 alc861_auto_init_analog_input(codec); 12916 if (spec->unsol_event) 12917 alc_sku_automute(codec); 12918} 12919 12920#ifdef CONFIG_SND_HDA_POWER_SAVE 12921static struct hda_amp_list alc861_loopbacks[] = { 12922 { 0x15, HDA_INPUT, 0 }, 12923 { 0x15, HDA_INPUT, 1 }, 12924 { 0x15, HDA_INPUT, 2 }, 12925 { 0x15, HDA_INPUT, 3 }, 12926 { } /* end */ 12927}; 12928#endif 12929 12930 12931/* 12932 * configuration and preset 12933 */ 12934static const char *alc861_models[ALC861_MODEL_LAST] = { 12935 [ALC861_3ST] = "3stack", 12936 [ALC660_3ST] = "3stack-660", 12937 [ALC861_3ST_DIG] = "3stack-dig", 12938 [ALC861_6ST_DIG] = "6stack-dig", 12939 [ALC861_UNIWILL_M31] = "uniwill-m31", 12940 [ALC861_TOSHIBA] = "toshiba", 12941 [ALC861_ASUS] = "asus", 12942 [ALC861_ASUS_LAPTOP] = "asus-laptop", 12943 [ALC861_AUTO] = "auto", 12944}; 12945 12946static struct snd_pci_quirk alc861_cfg_tbl[] = { 12947 SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST), 12948 SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP), 12949 SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP), 12950 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS), 12951 SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP), 12952 SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG), 12953 SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA), 12954 /* FIXME: the entry below breaks Toshiba A100 (model=auto works!) 12955 * Any other models that need this preset? 12956 */ 12957 /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */ 12958 SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST), 12959 SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST), 12960 SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31), 12961 SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31), 12962 SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP), 12963 /* FIXME: the below seems conflict */ 12964 /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */ 12965 SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST), 12966 SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST), 12967 {} 12968}; 12969 12970static struct alc_config_preset alc861_presets[] = { 12971 [ALC861_3ST] = { 12972 .mixers = { alc861_3ST_mixer }, 12973 .init_verbs = { alc861_threestack_init_verbs }, 12974 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 12975 .dac_nids = alc861_dac_nids, 12976 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes), 12977 .channel_mode = alc861_threestack_modes, 12978 .need_dac_fix = 1, 12979 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 12980 .adc_nids = alc861_adc_nids, 12981 .input_mux = &alc861_capture_source, 12982 }, 12983 [ALC861_3ST_DIG] = { 12984 .mixers = { alc861_base_mixer }, 12985 .init_verbs = { alc861_threestack_init_verbs }, 12986 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 12987 .dac_nids = alc861_dac_nids, 12988 .dig_out_nid = ALC861_DIGOUT_NID, 12989 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes), 12990 .channel_mode = alc861_threestack_modes, 12991 .need_dac_fix = 1, 12992 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 12993 .adc_nids = alc861_adc_nids, 12994 .input_mux = &alc861_capture_source, 12995 }, 12996 [ALC861_6ST_DIG] = { 12997 .mixers = { alc861_base_mixer }, 12998 .init_verbs = { alc861_base_init_verbs }, 12999 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 13000 .dac_nids = alc861_dac_nids, 13001 .dig_out_nid = ALC861_DIGOUT_NID, 13002 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes), 13003 .channel_mode = alc861_8ch_modes, 13004 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 13005 .adc_nids = alc861_adc_nids, 13006 .input_mux = &alc861_capture_source, 13007 }, 13008 [ALC660_3ST] = { 13009 .mixers = { alc861_3ST_mixer }, 13010 .init_verbs = { alc861_threestack_init_verbs }, 13011 .num_dacs = ARRAY_SIZE(alc660_dac_nids), 13012 .dac_nids = alc660_dac_nids, 13013 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes), 13014 .channel_mode = alc861_threestack_modes, 13015 .need_dac_fix = 1, 13016 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 13017 .adc_nids = alc861_adc_nids, 13018 .input_mux = &alc861_capture_source, 13019 }, 13020 [ALC861_UNIWILL_M31] = { 13021 .mixers = { alc861_uniwill_m31_mixer }, 13022 .init_verbs = { alc861_uniwill_m31_init_verbs }, 13023 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 13024 .dac_nids = alc861_dac_nids, 13025 .dig_out_nid = ALC861_DIGOUT_NID, 13026 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes), 13027 .channel_mode = alc861_uniwill_m31_modes, 13028 .need_dac_fix = 1, 13029 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 13030 .adc_nids = alc861_adc_nids, 13031 .input_mux = &alc861_capture_source, 13032 }, 13033 [ALC861_TOSHIBA] = { 13034 .mixers = { alc861_toshiba_mixer }, 13035 .init_verbs = { alc861_base_init_verbs, 13036 alc861_toshiba_init_verbs }, 13037 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 13038 .dac_nids = alc861_dac_nids, 13039 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 13040 .channel_mode = alc883_3ST_2ch_modes, 13041 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 13042 .adc_nids = alc861_adc_nids, 13043 .input_mux = &alc861_capture_source, 13044 .unsol_event = alc861_toshiba_unsol_event, 13045 .init_hook = alc861_toshiba_automute, 13046 }, 13047 [ALC861_ASUS] = { 13048 .mixers = { alc861_asus_mixer }, 13049 .init_verbs = { alc861_asus_init_verbs }, 13050 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 13051 .dac_nids = alc861_dac_nids, 13052 .dig_out_nid = ALC861_DIGOUT_NID, 13053 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes), 13054 .channel_mode = alc861_asus_modes, 13055 .need_dac_fix = 1, 13056 .hp_nid = 0x06, 13057 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 13058 .adc_nids = alc861_adc_nids, 13059 .input_mux = &alc861_capture_source, 13060 }, 13061 [ALC861_ASUS_LAPTOP] = { 13062 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer }, 13063 .init_verbs = { alc861_asus_init_verbs, 13064 alc861_asus_laptop_init_verbs }, 13065 .num_dacs = ARRAY_SIZE(alc861_dac_nids), 13066 .dac_nids = alc861_dac_nids, 13067 .dig_out_nid = ALC861_DIGOUT_NID, 13068 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes), 13069 .channel_mode = alc883_3ST_2ch_modes, 13070 .need_dac_fix = 1, 13071 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), 13072 .adc_nids = alc861_adc_nids, 13073 .input_mux = &alc861_capture_source, 13074 }, 13075}; 13076 13077 13078static int patch_alc861(struct hda_codec *codec) 13079{ 13080 struct alc_spec *spec; 13081 int board_config; 13082 int err; 13083 13084 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 13085 if (spec == NULL) 13086 return -ENOMEM; 13087 13088 codec->spec = spec; 13089 13090 board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST, 13091 alc861_models, 13092 alc861_cfg_tbl); 13093 13094 if (board_config < 0) { 13095 printk(KERN_INFO "hda_codec: Unknown model for ALC861, " 13096 "trying auto-probe from BIOS...\n"); 13097 board_config = ALC861_AUTO; 13098 } 13099 13100 if (board_config == ALC861_AUTO) { 13101 /* automatic parse from the BIOS config */ 13102 err = alc861_parse_auto_config(codec); 13103 if (err < 0) { 13104 alc_free(codec); 13105 return err; 13106 } else if (!err) { 13107 printk(KERN_INFO 13108 "hda_codec: Cannot set up configuration " 13109 "from BIOS. Using base mode...\n"); 13110 board_config = ALC861_3ST_DIG; 13111 } 13112 } 13113 13114 if (board_config != ALC861_AUTO) 13115 setup_preset(spec, &alc861_presets[board_config]); 13116 13117 spec->stream_name_analog = "ALC861 Analog"; 13118 spec->stream_analog_playback = &alc861_pcm_analog_playback; 13119 spec->stream_analog_capture = &alc861_pcm_analog_capture; 13120 13121 spec->stream_name_digital = "ALC861 Digital"; 13122 spec->stream_digital_playback = &alc861_pcm_digital_playback; 13123 spec->stream_digital_capture = &alc861_pcm_digital_capture; 13124 13125 spec->vmaster_nid = 0x03; 13126 13127 codec->patch_ops = alc_patch_ops; 13128 if (board_config == ALC861_AUTO) 13129 spec->init_hook = alc861_auto_init; 13130#ifdef CONFIG_SND_HDA_POWER_SAVE 13131 if (!spec->loopback.amplist) 13132 spec->loopback.amplist = alc861_loopbacks; 13133#endif 13134 13135 return 0; 13136} 13137 13138/* 13139 * ALC861-VD support 13140 * 13141 * Based on ALC882 13142 * 13143 * In addition, an independent DAC 13144 */ 13145#define ALC861VD_DIGOUT_NID 0x06 13146 13147static hda_nid_t alc861vd_dac_nids[4] = { 13148 /* front, surr, clfe, side surr */ 13149 0x02, 0x03, 0x04, 0x05 13150}; 13151 13152/* dac_nids for ALC660vd are in a different order - according to 13153 * Realtek's driver. 13154 * This should probably tesult in a different mixer for 6stack models 13155 * of ALC660vd codecs, but for now there is only 3stack mixer 13156 * - and it is the same as in 861vd. 13157 * adc_nids in ALC660vd are (is) the same as in 861vd 13158 */ 13159static hda_nid_t alc660vd_dac_nids[3] = { 13160 /* front, rear, clfe, rear_surr */ 13161 0x02, 0x04, 0x03 13162}; 13163 13164static hda_nid_t alc861vd_adc_nids[1] = { 13165 /* ADC0 */ 13166 0x09, 13167}; 13168 13169static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 }; 13170 13171/* input MUX */ 13172/* FIXME: should be a matrix-type input source selection */ 13173static struct hda_input_mux alc861vd_capture_source = { 13174 .num_items = 4, 13175 .items = { 13176 { "Mic", 0x0 }, 13177 { "Front Mic", 0x1 }, 13178 { "Line", 0x2 }, 13179 { "CD", 0x4 }, 13180 }, 13181}; 13182 13183static struct hda_input_mux alc861vd_dallas_capture_source = { 13184 .num_items = 2, 13185 .items = { 13186 { "Ext Mic", 0x0 }, 13187 { "Int Mic", 0x1 }, 13188 }, 13189}; 13190 13191static struct hda_input_mux alc861vd_hp_capture_source = { 13192 .num_items = 2, 13193 .items = { 13194 { "Front Mic", 0x0 }, 13195 { "ATAPI Mic", 0x1 }, 13196 }, 13197}; 13198 13199#define alc861vd_mux_enum_info alc_mux_enum_info 13200#define alc861vd_mux_enum_get alc_mux_enum_get 13201/* ALC861VD has the ALC882-type input selection (but has only one ADC) */ 13202#define alc861vd_mux_enum_put alc882_mux_enum_put 13203 13204/* 13205 * 2ch mode 13206 */ 13207static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = { 13208 { 2, NULL } 13209}; 13210 13211/* 13212 * 6ch mode 13213 */ 13214static struct hda_verb alc861vd_6stack_ch6_init[] = { 13215 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 13216 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 13217 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 13218 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 13219 { } /* end */ 13220}; 13221 13222/* 13223 * 8ch mode 13224 */ 13225static struct hda_verb alc861vd_6stack_ch8_init[] = { 13226 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 13227 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 13228 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 13229 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 13230 { } /* end */ 13231}; 13232 13233static struct hda_channel_mode alc861vd_6stack_modes[2] = { 13234 { 6, alc861vd_6stack_ch6_init }, 13235 { 8, alc861vd_6stack_ch8_init }, 13236}; 13237 13238static struct snd_kcontrol_new alc861vd_chmode_mixer[] = { 13239 { 13240 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 13241 .name = "Channel Mode", 13242 .info = alc_ch_mode_info, 13243 .get = alc_ch_mode_get, 13244 .put = alc_ch_mode_put, 13245 }, 13246 { } /* end */ 13247}; 13248 13249static struct snd_kcontrol_new alc861vd_capture_mixer[] = { 13250 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT), 13251 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT), 13252 13253 { 13254 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 13255 /* The multiple "Capture Source" controls confuse alsamixer 13256 * So call somewhat different.. 13257 */ 13258 /* .name = "Capture Source", */ 13259 .name = "Input Source", 13260 .count = 1, 13261 .info = alc861vd_mux_enum_info, 13262 .get = alc861vd_mux_enum_get, 13263 .put = alc861vd_mux_enum_put, 13264 }, 13265 { } /* end */ 13266}; 13267 13268/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17 13269 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b 13270 */ 13271static struct snd_kcontrol_new alc861vd_6st_mixer[] = { 13272 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 13273 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 13274 13275 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT), 13276 HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT), 13277 13278 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, 13279 HDA_OUTPUT), 13280 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, 13281 HDA_OUTPUT), 13282 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT), 13283 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT), 13284 13285 HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT), 13286 HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT), 13287 13288 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 13289 13290 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 13291 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 13292 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 13293 13294 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 13295 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 13296 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 13297 13298 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 13299 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 13300 13301 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 13302 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 13303 13304 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 13305 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 13306 13307 { } /* end */ 13308}; 13309 13310static struct snd_kcontrol_new alc861vd_3st_mixer[] = { 13311 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 13312 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 13313 13314 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 13315 13316 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 13317 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 13318 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 13319 13320 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 13321 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 13322 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 13323 13324 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 13325 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 13326 13327 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 13328 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 13329 13330 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 13331 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 13332 13333 { } /* end */ 13334}; 13335 13336static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = { 13337 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 13338 /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/ 13339 HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), 13340 13341 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 13342 13343 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), 13344 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 13345 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 13346 13347 HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT), 13348 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 13349 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 13350 13351 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 13352 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 13353 13354 { } /* end */ 13355}; 13356 13357/* Pin assignment: Speaker=0x14, HP = 0x15, 13358 * Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d 13359 */ 13360static struct snd_kcontrol_new alc861vd_dallas_mixer[] = { 13361 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 13362 HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT), 13363 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 13364 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT), 13365 HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT), 13366 HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 13367 HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 13368 HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT), 13369 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 13370 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 13371 HDA_CODEC_VOLUME("PC Beep Volume", 0x0b, 0x05, HDA_INPUT), 13372 HDA_CODEC_MUTE("PC Beep Switch", 0x0b, 0x05, HDA_INPUT), 13373 { } /* end */ 13374}; 13375 13376/* Pin assignment: Speaker=0x14, Line-out = 0x15, 13377 * Front Mic=0x18, ATAPI Mic = 0x19, 13378 */ 13379static struct snd_kcontrol_new alc861vd_hp_mixer[] = { 13380 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 13381 HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), 13382 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT), 13383 HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT), 13384 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 13385 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 13386 HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 13387 HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 13388 13389 { } /* end */ 13390}; 13391 13392/* 13393 * generic initialization of ADC, input mixers and output mixers 13394 */ 13395static struct hda_verb alc861vd_volume_init_verbs[] = { 13396 /* 13397 * Unmute ADC0 and set the default input to mic-in 13398 */ 13399 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 13400 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13401 13402 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of 13403 * the analog-loopback mixer widget 13404 */ 13405 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 13406 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 13407 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 13408 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 13409 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 13410 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 13411 13412 /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */ 13413 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13414 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13415 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 13416 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 13417 13418 /* 13419 * Set up output mixers (0x02 - 0x05) 13420 */ 13421 /* set vol=0 to output mixers */ 13422 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 13423 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 13424 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 13425 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 13426 13427 /* set up input amps for analog loopback */ 13428 /* Amp Indices: DAC = 0, mixer = 1 */ 13429 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 13430 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 13431 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 13432 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 13433 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 13434 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 13435 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 13436 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 13437 13438 { } 13439}; 13440 13441/* 13442 * 3-stack pin configuration: 13443 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b 13444 */ 13445static struct hda_verb alc861vd_3stack_init_verbs[] = { 13446 /* 13447 * Set pin mode and muting 13448 */ 13449 /* set front pin widgets 0x14 for output */ 13450 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 13451 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13452 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 13453 13454 /* Mic (rear) pin: input vref at 80% */ 13455 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 13456 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13457 /* Front Mic pin: input vref at 80% */ 13458 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 13459 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13460 /* Line In pin: input */ 13461 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 13462 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13463 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 13464 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 13465 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13466 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 13467 /* CD pin widget for input */ 13468 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 13469 13470 { } 13471}; 13472 13473/* 13474 * 6-stack pin configuration: 13475 */ 13476static struct hda_verb alc861vd_6stack_init_verbs[] = { 13477 /* 13478 * Set pin mode and muting 13479 */ 13480 /* set front pin widgets 0x14 for output */ 13481 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 13482 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13483 {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, 13484 13485 /* Rear Pin: output 1 (0x0d) */ 13486 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 13487 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13488 {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, 13489 /* CLFE Pin: output 2 (0x0e) */ 13490 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 13491 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13492 {0x16, AC_VERB_SET_CONNECT_SEL, 0x02}, 13493 /* Side Pin: output 3 (0x0f) */ 13494 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 13495 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13496 {0x17, AC_VERB_SET_CONNECT_SEL, 0x03}, 13497 13498 /* Mic (rear) pin: input vref at 80% */ 13499 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 13500 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13501 /* Front Mic pin: input vref at 80% */ 13502 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 13503 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13504 /* Line In pin: input */ 13505 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 13506 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13507 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 13508 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 13509 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13510 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 13511 /* CD pin widget for input */ 13512 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 13513 13514 { } 13515}; 13516 13517static struct hda_verb alc861vd_eapd_verbs[] = { 13518 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 13519 { } 13520}; 13521 13522static struct hda_verb alc660vd_eapd_verbs[] = { 13523 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 13524 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 13525 { } 13526}; 13527 13528static struct hda_verb alc861vd_lenovo_unsol_verbs[] = { 13529 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13530 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13531 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 13532 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 13533 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 13534 {} 13535}; 13536 13537/* toggle speaker-output according to the hp-jack state */ 13538static void alc861vd_lenovo_hp_automute(struct hda_codec *codec) 13539{ 13540 unsigned int present; 13541 unsigned char bits; 13542 13543 present = snd_hda_codec_read(codec, 0x1b, 0, 13544 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 13545 bits = present ? HDA_AMP_MUTE : 0; 13546 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 13547 HDA_AMP_MUTE, bits); 13548} 13549 13550static void alc861vd_lenovo_mic_automute(struct hda_codec *codec) 13551{ 13552 unsigned int present; 13553 unsigned char bits; 13554 13555 present = snd_hda_codec_read(codec, 0x18, 0, 13556 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 13557 bits = present ? HDA_AMP_MUTE : 0; 13558 snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, 13559 HDA_AMP_MUTE, bits); 13560} 13561 13562static void alc861vd_lenovo_automute(struct hda_codec *codec) 13563{ 13564 alc861vd_lenovo_hp_automute(codec); 13565 alc861vd_lenovo_mic_automute(codec); 13566} 13567 13568static void alc861vd_lenovo_unsol_event(struct hda_codec *codec, 13569 unsigned int res) 13570{ 13571 switch (res >> 26) { 13572 case ALC880_HP_EVENT: 13573 alc861vd_lenovo_hp_automute(codec); 13574 break; 13575 case ALC880_MIC_EVENT: 13576 alc861vd_lenovo_mic_automute(codec); 13577 break; 13578 } 13579} 13580 13581static struct hda_verb alc861vd_dallas_verbs[] = { 13582 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 13583 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 13584 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 13585 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 13586 13587 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13588 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 13589 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 13590 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 13591 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 13592 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 13593 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 13594 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 13595 13596 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 13597 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13598 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 13599 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13600 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 13601 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13602 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 13603 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 13604 13605 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50}, 13606 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13607 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50}, 13608 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 13609 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 13610 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 13611 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 13612 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 13613 13614 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 13615 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 13616 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 13617 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 13618 13619 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 13620 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 13621 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 13622 13623 { } /* end */ 13624}; 13625 13626/* toggle speaker-output according to the hp-jack state */ 13627static void alc861vd_dallas_automute(struct hda_codec *codec) 13628{ 13629 unsigned int present; 13630 13631 present = snd_hda_codec_read(codec, 0x15, 0, 13632 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 13633 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 13634 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 13635} 13636 13637static void alc861vd_dallas_unsol_event(struct hda_codec *codec, unsigned int res) 13638{ 13639 if ((res >> 26) == ALC880_HP_EVENT) 13640 alc861vd_dallas_automute(codec); 13641} 13642 13643#ifdef CONFIG_SND_HDA_POWER_SAVE 13644#define alc861vd_loopbacks alc880_loopbacks 13645#endif 13646 13647/* pcm configuration: identiacal with ALC880 */ 13648#define alc861vd_pcm_analog_playback alc880_pcm_analog_playback 13649#define alc861vd_pcm_analog_capture alc880_pcm_analog_capture 13650#define alc861vd_pcm_digital_playback alc880_pcm_digital_playback 13651#define alc861vd_pcm_digital_capture alc880_pcm_digital_capture 13652 13653/* 13654 * configuration and preset 13655 */ 13656static const char *alc861vd_models[ALC861VD_MODEL_LAST] = { 13657 [ALC660VD_3ST] = "3stack-660", 13658 [ALC660VD_3ST_DIG] = "3stack-660-digout", 13659 [ALC861VD_3ST] = "3stack", 13660 [ALC861VD_3ST_DIG] = "3stack-digout", 13661 [ALC861VD_6ST_DIG] = "6stack-digout", 13662 [ALC861VD_LENOVO] = "lenovo", 13663 [ALC861VD_DALLAS] = "dallas", 13664 [ALC861VD_HP] = "hp", 13665 [ALC861VD_AUTO] = "auto", 13666}; 13667 13668static struct snd_pci_quirk alc861vd_cfg_tbl[] = { 13669 SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST), 13670 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP), 13671 SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST), 13672 SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST), 13673 SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC861VD_LENOVO), 13674 SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG), 13675 SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST), 13676 SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO), 13677 /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/ 13678 SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS), 13679 SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO), 13680 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS), 13681 SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG), 13682 SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo", ALC861VD_LENOVO), 13683 SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo 3000 C200", ALC861VD_LENOVO), 13684 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 N200", ALC861VD_LENOVO), 13685 SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG), 13686 {} 13687}; 13688 13689static struct alc_config_preset alc861vd_presets[] = { 13690 [ALC660VD_3ST] = { 13691 .mixers = { alc861vd_3st_mixer }, 13692 .init_verbs = { alc861vd_volume_init_verbs, 13693 alc861vd_3stack_init_verbs }, 13694 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids), 13695 .dac_nids = alc660vd_dac_nids, 13696 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 13697 .channel_mode = alc861vd_3stack_2ch_modes, 13698 .input_mux = &alc861vd_capture_source, 13699 }, 13700 [ALC660VD_3ST_DIG] = { 13701 .mixers = { alc861vd_3st_mixer }, 13702 .init_verbs = { alc861vd_volume_init_verbs, 13703 alc861vd_3stack_init_verbs }, 13704 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids), 13705 .dac_nids = alc660vd_dac_nids, 13706 .dig_out_nid = ALC861VD_DIGOUT_NID, 13707 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 13708 .channel_mode = alc861vd_3stack_2ch_modes, 13709 .input_mux = &alc861vd_capture_source, 13710 }, 13711 [ALC861VD_3ST] = { 13712 .mixers = { alc861vd_3st_mixer }, 13713 .init_verbs = { alc861vd_volume_init_verbs, 13714 alc861vd_3stack_init_verbs }, 13715 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 13716 .dac_nids = alc861vd_dac_nids, 13717 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 13718 .channel_mode = alc861vd_3stack_2ch_modes, 13719 .input_mux = &alc861vd_capture_source, 13720 }, 13721 [ALC861VD_3ST_DIG] = { 13722 .mixers = { alc861vd_3st_mixer }, 13723 .init_verbs = { alc861vd_volume_init_verbs, 13724 alc861vd_3stack_init_verbs }, 13725 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 13726 .dac_nids = alc861vd_dac_nids, 13727 .dig_out_nid = ALC861VD_DIGOUT_NID, 13728 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 13729 .channel_mode = alc861vd_3stack_2ch_modes, 13730 .input_mux = &alc861vd_capture_source, 13731 }, 13732 [ALC861VD_6ST_DIG] = { 13733 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer }, 13734 .init_verbs = { alc861vd_volume_init_verbs, 13735 alc861vd_6stack_init_verbs }, 13736 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 13737 .dac_nids = alc861vd_dac_nids, 13738 .dig_out_nid = ALC861VD_DIGOUT_NID, 13739 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes), 13740 .channel_mode = alc861vd_6stack_modes, 13741 .input_mux = &alc861vd_capture_source, 13742 }, 13743 [ALC861VD_LENOVO] = { 13744 .mixers = { alc861vd_lenovo_mixer }, 13745 .init_verbs = { alc861vd_volume_init_verbs, 13746 alc861vd_3stack_init_verbs, 13747 alc861vd_eapd_verbs, 13748 alc861vd_lenovo_unsol_verbs }, 13749 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids), 13750 .dac_nids = alc660vd_dac_nids, 13751 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 13752 .channel_mode = alc861vd_3stack_2ch_modes, 13753 .input_mux = &alc861vd_capture_source, 13754 .unsol_event = alc861vd_lenovo_unsol_event, 13755 .init_hook = alc861vd_lenovo_automute, 13756 }, 13757 [ALC861VD_DALLAS] = { 13758 .mixers = { alc861vd_dallas_mixer }, 13759 .init_verbs = { alc861vd_dallas_verbs }, 13760 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 13761 .dac_nids = alc861vd_dac_nids, 13762 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 13763 .channel_mode = alc861vd_3stack_2ch_modes, 13764 .input_mux = &alc861vd_dallas_capture_source, 13765 .unsol_event = alc861vd_dallas_unsol_event, 13766 .init_hook = alc861vd_dallas_automute, 13767 }, 13768 [ALC861VD_HP] = { 13769 .mixers = { alc861vd_hp_mixer }, 13770 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs }, 13771 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids), 13772 .dac_nids = alc861vd_dac_nids, 13773 .dig_out_nid = ALC861VD_DIGOUT_NID, 13774 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes), 13775 .channel_mode = alc861vd_3stack_2ch_modes, 13776 .input_mux = &alc861vd_hp_capture_source, 13777 .unsol_event = alc861vd_dallas_unsol_event, 13778 .init_hook = alc861vd_dallas_automute, 13779 }, 13780}; 13781 13782/* 13783 * BIOS auto configuration 13784 */ 13785static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec, 13786 hda_nid_t nid, int pin_type, int dac_idx) 13787{ 13788 alc_set_pin_output(codec, nid, pin_type); 13789} 13790 13791static void alc861vd_auto_init_multi_out(struct hda_codec *codec) 13792{ 13793 struct alc_spec *spec = codec->spec; 13794 int i; 13795 13796 alc_subsystem_id(codec, 0x15, 0x1b, 0x14); 13797 for (i = 0; i <= HDA_SIDE; i++) { 13798 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 13799 int pin_type = get_pin_type(spec->autocfg.line_out_type); 13800 if (nid) 13801 alc861vd_auto_set_output_and_unmute(codec, nid, 13802 pin_type, i); 13803 } 13804} 13805 13806 13807static void alc861vd_auto_init_hp_out(struct hda_codec *codec) 13808{ 13809 struct alc_spec *spec = codec->spec; 13810 hda_nid_t pin; 13811 13812 pin = spec->autocfg.hp_pins[0]; 13813 if (pin) /* connect to front and use dac 0 */ 13814 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 13815 pin = spec->autocfg.speaker_pins[0]; 13816 if (pin) 13817 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 13818} 13819 13820#define alc861vd_is_input_pin(nid) alc880_is_input_pin(nid) 13821#define ALC861VD_PIN_CD_NID ALC880_PIN_CD_NID 13822 13823static void alc861vd_auto_init_analog_input(struct hda_codec *codec) 13824{ 13825 struct alc_spec *spec = codec->spec; 13826 int i; 13827 13828 for (i = 0; i < AUTO_PIN_LAST; i++) { 13829 hda_nid_t nid = spec->autocfg.input_pins[i]; 13830 if (alc861vd_is_input_pin(nid)) { 13831 snd_hda_codec_write(codec, nid, 0, 13832 AC_VERB_SET_PIN_WIDGET_CONTROL, 13833 i <= AUTO_PIN_FRONT_MIC ? 13834 PIN_VREF80 : PIN_IN); 13835 if (nid != ALC861VD_PIN_CD_NID) 13836 snd_hda_codec_write(codec, nid, 0, 13837 AC_VERB_SET_AMP_GAIN_MUTE, 13838 AMP_OUT_MUTE); 13839 } 13840 } 13841} 13842 13843#define alc861vd_auto_init_input_src alc882_auto_init_input_src 13844 13845#define alc861vd_idx_to_mixer_vol(nid) ((nid) + 0x02) 13846#define alc861vd_idx_to_mixer_switch(nid) ((nid) + 0x0c) 13847 13848/* add playback controls from the parsed DAC table */ 13849/* Based on ALC880 version. But ALC861VD has separate, 13850 * different NIDs for mute/unmute switch and volume control */ 13851static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec, 13852 const struct auto_pin_cfg *cfg) 13853{ 13854 char name[32]; 13855 static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"}; 13856 hda_nid_t nid_v, nid_s; 13857 int i, err; 13858 13859 for (i = 0; i < cfg->line_outs; i++) { 13860 if (!spec->multiout.dac_nids[i]) 13861 continue; 13862 nid_v = alc861vd_idx_to_mixer_vol( 13863 alc880_dac_to_idx( 13864 spec->multiout.dac_nids[i])); 13865 nid_s = alc861vd_idx_to_mixer_switch( 13866 alc880_dac_to_idx( 13867 spec->multiout.dac_nids[i])); 13868 13869 if (i == 2) { 13870 /* Center/LFE */ 13871 err = add_control(spec, ALC_CTL_WIDGET_VOL, 13872 "Center Playback Volume", 13873 HDA_COMPOSE_AMP_VAL(nid_v, 1, 0, 13874 HDA_OUTPUT)); 13875 if (err < 0) 13876 return err; 13877 err = add_control(spec, ALC_CTL_WIDGET_VOL, 13878 "LFE Playback Volume", 13879 HDA_COMPOSE_AMP_VAL(nid_v, 2, 0, 13880 HDA_OUTPUT)); 13881 if (err < 0) 13882 return err; 13883 err = add_control(spec, ALC_CTL_BIND_MUTE, 13884 "Center Playback Switch", 13885 HDA_COMPOSE_AMP_VAL(nid_s, 1, 2, 13886 HDA_INPUT)); 13887 if (err < 0) 13888 return err; 13889 err = add_control(spec, ALC_CTL_BIND_MUTE, 13890 "LFE Playback Switch", 13891 HDA_COMPOSE_AMP_VAL(nid_s, 2, 2, 13892 HDA_INPUT)); 13893 if (err < 0) 13894 return err; 13895 } else { 13896 sprintf(name, "%s Playback Volume", chname[i]); 13897 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 13898 HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, 13899 HDA_OUTPUT)); 13900 if (err < 0) 13901 return err; 13902 sprintf(name, "%s Playback Switch", chname[i]); 13903 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 13904 HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, 13905 HDA_INPUT)); 13906 if (err < 0) 13907 return err; 13908 } 13909 } 13910 return 0; 13911} 13912 13913/* add playback controls for speaker and HP outputs */ 13914/* Based on ALC880 version. But ALC861VD has separate, 13915 * different NIDs for mute/unmute switch and volume control */ 13916static int alc861vd_auto_create_extra_out(struct alc_spec *spec, 13917 hda_nid_t pin, const char *pfx) 13918{ 13919 hda_nid_t nid_v, nid_s; 13920 int err; 13921 char name[32]; 13922 13923 if (!pin) 13924 return 0; 13925 13926 if (alc880_is_fixed_pin(pin)) { 13927 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin)); 13928 /* specify the DAC as the extra output */ 13929 if (!spec->multiout.hp_nid) 13930 spec->multiout.hp_nid = nid_v; 13931 else 13932 spec->multiout.extra_out_nid[0] = nid_v; 13933 /* control HP volume/switch on the output mixer amp */ 13934 nid_v = alc861vd_idx_to_mixer_vol( 13935 alc880_fixed_pin_idx(pin)); 13936 nid_s = alc861vd_idx_to_mixer_switch( 13937 alc880_fixed_pin_idx(pin)); 13938 13939 sprintf(name, "%s Playback Volume", pfx); 13940 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 13941 HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT)); 13942 if (err < 0) 13943 return err; 13944 sprintf(name, "%s Playback Switch", pfx); 13945 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 13946 HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT)); 13947 if (err < 0) 13948 return err; 13949 } else if (alc880_is_multi_pin(pin)) { 13950 /* set manual connection */ 13951 /* we have only a switch on HP-out PIN */ 13952 sprintf(name, "%s Playback Switch", pfx); 13953 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 13954 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 13955 if (err < 0) 13956 return err; 13957 } 13958 return 0; 13959} 13960 13961/* parse the BIOS configuration and set up the alc_spec 13962 * return 1 if successful, 0 if the proper config is not found, 13963 * or a negative error code 13964 * Based on ALC880 version - had to change it to override 13965 * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */ 13966static int alc861vd_parse_auto_config(struct hda_codec *codec) 13967{ 13968 struct alc_spec *spec = codec->spec; 13969 int err; 13970 static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 }; 13971 13972 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 13973 alc861vd_ignore); 13974 if (err < 0) 13975 return err; 13976 if (!spec->autocfg.line_outs) 13977 return 0; /* can't find valid BIOS pin config */ 13978 13979 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg); 13980 if (err < 0) 13981 return err; 13982 err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg); 13983 if (err < 0) 13984 return err; 13985 err = alc861vd_auto_create_extra_out(spec, 13986 spec->autocfg.speaker_pins[0], 13987 "Speaker"); 13988 if (err < 0) 13989 return err; 13990 err = alc861vd_auto_create_extra_out(spec, 13991 spec->autocfg.hp_pins[0], 13992 "Headphone"); 13993 if (err < 0) 13994 return err; 13995 err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg); 13996 if (err < 0) 13997 return err; 13998 13999 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 14000 14001 if (spec->autocfg.dig_out_pin) 14002 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID; 14003 14004 if (spec->kctl_alloc) 14005 spec->mixers[spec->num_mixers++] = spec->kctl_alloc; 14006 14007 spec->init_verbs[spec->num_init_verbs++] 14008 = alc861vd_volume_init_verbs; 14009 14010 spec->num_mux_defs = 1; 14011 spec->input_mux = &spec->private_imux; 14012 14013 err = alc_auto_add_mic_boost(codec); 14014 if (err < 0) 14015 return err; 14016 14017 return 1; 14018} 14019 14020/* additional initialization for auto-configuration model */ 14021static void alc861vd_auto_init(struct hda_codec *codec) 14022{ 14023 struct alc_spec *spec = codec->spec; 14024 alc861vd_auto_init_multi_out(codec); 14025 alc861vd_auto_init_hp_out(codec); 14026 alc861vd_auto_init_analog_input(codec); 14027 alc861vd_auto_init_input_src(codec); 14028 if (spec->unsol_event) 14029 alc_sku_automute(codec); 14030} 14031 14032static int patch_alc861vd(struct hda_codec *codec) 14033{ 14034 struct alc_spec *spec; 14035 int err, board_config; 14036 14037 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 14038 if (spec == NULL) 14039 return -ENOMEM; 14040 14041 codec->spec = spec; 14042 14043 board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST, 14044 alc861vd_models, 14045 alc861vd_cfg_tbl); 14046 14047 if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) { 14048 printk(KERN_INFO "hda_codec: Unknown model for ALC660VD/" 14049 "ALC861VD, trying auto-probe from BIOS...\n"); 14050 board_config = ALC861VD_AUTO; 14051 } 14052 14053 if (board_config == ALC861VD_AUTO) { 14054 /* automatic parse from the BIOS config */ 14055 err = alc861vd_parse_auto_config(codec); 14056 if (err < 0) { 14057 alc_free(codec); 14058 return err; 14059 } else if (!err) { 14060 printk(KERN_INFO 14061 "hda_codec: Cannot set up configuration " 14062 "from BIOS. Using base mode...\n"); 14063 board_config = ALC861VD_3ST; 14064 } 14065 } 14066 14067 if (board_config != ALC861VD_AUTO) 14068 setup_preset(spec, &alc861vd_presets[board_config]); 14069 14070 if (codec->vendor_id == 0x10ec0660) { 14071 spec->stream_name_analog = "ALC660-VD Analog"; 14072 spec->stream_name_digital = "ALC660-VD Digital"; 14073 /* always turn on EAPD */ 14074 spec->init_verbs[spec->num_init_verbs++] = alc660vd_eapd_verbs; 14075 } else { 14076 spec->stream_name_analog = "ALC861VD Analog"; 14077 spec->stream_name_digital = "ALC861VD Digital"; 14078 } 14079 14080 spec->stream_analog_playback = &alc861vd_pcm_analog_playback; 14081 spec->stream_analog_capture = &alc861vd_pcm_analog_capture; 14082 14083 spec->stream_digital_playback = &alc861vd_pcm_digital_playback; 14084 spec->stream_digital_capture = &alc861vd_pcm_digital_capture; 14085 14086 spec->adc_nids = alc861vd_adc_nids; 14087 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids); 14088 spec->capsrc_nids = alc861vd_capsrc_nids; 14089 14090 spec->mixers[spec->num_mixers] = alc861vd_capture_mixer; 14091 spec->num_mixers++; 14092 14093 spec->vmaster_nid = 0x02; 14094 14095 codec->patch_ops = alc_patch_ops; 14096 14097 if (board_config == ALC861VD_AUTO) 14098 spec->init_hook = alc861vd_auto_init; 14099#ifdef CONFIG_SND_HDA_POWER_SAVE 14100 if (!spec->loopback.amplist) 14101 spec->loopback.amplist = alc861vd_loopbacks; 14102#endif 14103 14104 return 0; 14105} 14106 14107/* 14108 * ALC662 support 14109 * 14110 * ALC662 is almost identical with ALC880 but has cleaner and more flexible 14111 * configuration. Each pin widget can choose any input DACs and a mixer. 14112 * Each ADC is connected from a mixer of all inputs. This makes possible 14113 * 6-channel independent captures. 14114 * 14115 * In addition, an independent DAC for the multi-playback (not used in this 14116 * driver yet). 14117 */ 14118#define ALC662_DIGOUT_NID 0x06 14119#define ALC662_DIGIN_NID 0x0a 14120 14121static hda_nid_t alc662_dac_nids[4] = { 14122 /* front, rear, clfe, rear_surr */ 14123 0x02, 0x03, 0x04 14124}; 14125 14126static hda_nid_t alc662_adc_nids[1] = { 14127 /* ADC1-2 */ 14128 0x09, 14129}; 14130 14131static hda_nid_t alc662_capsrc_nids[1] = { 0x22 }; 14132 14133/* input MUX */ 14134/* FIXME: should be a matrix-type input source selection */ 14135static struct hda_input_mux alc662_capture_source = { 14136 .num_items = 4, 14137 .items = { 14138 { "Mic", 0x0 }, 14139 { "Front Mic", 0x1 }, 14140 { "Line", 0x2 }, 14141 { "CD", 0x4 }, 14142 }, 14143}; 14144 14145static struct hda_input_mux alc662_lenovo_101e_capture_source = { 14146 .num_items = 2, 14147 .items = { 14148 { "Mic", 0x1 }, 14149 { "Line", 0x2 }, 14150 }, 14151}; 14152 14153static struct hda_input_mux alc662_eeepc_capture_source = { 14154 .num_items = 2, 14155 .items = { 14156 { "i-Mic", 0x1 }, 14157 { "e-Mic", 0x0 }, 14158 }, 14159}; 14160 14161static struct hda_input_mux alc663_capture_source = { 14162 .num_items = 3, 14163 .items = { 14164 { "Mic", 0x0 }, 14165 { "Front Mic", 0x1 }, 14166 { "Line", 0x2 }, 14167 }, 14168}; 14169 14170static struct hda_input_mux alc663_m51va_capture_source = { 14171 .num_items = 2, 14172 .items = { 14173 { "Ext-Mic", 0x0 }, 14174 { "D-Mic", 0x9 }, 14175 }, 14176}; 14177 14178#define alc662_mux_enum_info alc_mux_enum_info 14179#define alc662_mux_enum_get alc_mux_enum_get 14180#define alc662_mux_enum_put alc882_mux_enum_put 14181 14182/* 14183 * 2ch mode 14184 */ 14185static struct hda_channel_mode alc662_3ST_2ch_modes[1] = { 14186 { 2, NULL } 14187}; 14188 14189/* 14190 * 2ch mode 14191 */ 14192static struct hda_verb alc662_3ST_ch2_init[] = { 14193 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 14194 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 14195 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 14196 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 14197 { } /* end */ 14198}; 14199 14200/* 14201 * 6ch mode 14202 */ 14203static struct hda_verb alc662_3ST_ch6_init[] = { 14204 { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 14205 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 14206 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 }, 14207 { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 14208 { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 14209 { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 }, 14210 { } /* end */ 14211}; 14212 14213static struct hda_channel_mode alc662_3ST_6ch_modes[2] = { 14214 { 2, alc662_3ST_ch2_init }, 14215 { 6, alc662_3ST_ch6_init }, 14216}; 14217 14218/* 14219 * 2ch mode 14220 */ 14221static struct hda_verb alc662_sixstack_ch6_init[] = { 14222 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 14223 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, 14224 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 14225 { } /* end */ 14226}; 14227 14228/* 14229 * 6ch mode 14230 */ 14231static struct hda_verb alc662_sixstack_ch8_init[] = { 14232 { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 14233 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 14234 { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 14235 { } /* end */ 14236}; 14237 14238static struct hda_channel_mode alc662_5stack_modes[2] = { 14239 { 2, alc662_sixstack_ch6_init }, 14240 { 6, alc662_sixstack_ch8_init }, 14241}; 14242 14243/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17 14244 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b 14245 */ 14246 14247static struct snd_kcontrol_new alc662_base_mixer[] = { 14248 /* output mixer control */ 14249 HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT), 14250 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT), 14251 HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT), 14252 HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT), 14253 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT), 14254 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT), 14255 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT), 14256 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT), 14257 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 14258 14259 /*Input mixer control */ 14260 HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT), 14261 HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT), 14262 HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT), 14263 HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT), 14264 HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT), 14265 HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT), 14266 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT), 14267 HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT), 14268 { } /* end */ 14269}; 14270 14271static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = { 14272 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 14273 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT), 14274 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 14275 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 14276 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 14277 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 14278 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 14279 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 14280 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 14281 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 14282 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 14283 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 14284 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 14285 { } /* end */ 14286}; 14287 14288static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = { 14289 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 14290 HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT), 14291 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT), 14292 HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT), 14293 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT), 14294 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT), 14295 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT), 14296 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT), 14297 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 14298 HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), 14299 HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), 14300 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 14301 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 14302 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 14303 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 14304 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 14305 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 14306 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), 14307 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), 14308 { } /* end */ 14309}; 14310 14311static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = { 14312 HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT), 14313 HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT), 14314 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT), 14315 HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT), 14316 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 14317 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 14318 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 14319 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 14320 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 14321 { } /* end */ 14322}; 14323 14324static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = { 14325 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 14326 14327 HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT), 14328 HDA_CODEC_MUTE("Line-Out Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 14329 14330 HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT), 14331 HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 14332 HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 14333 14334 HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT), 14335 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 14336 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 14337 { } /* end */ 14338}; 14339 14340static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = { 14341 HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT), 14342 HDA_CODEC_MUTE("Line-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT), 14343 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT), 14344 HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT), 14345 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT), 14346 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT), 14347 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT), 14348 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT), 14349 HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 14350 HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT), 14351 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 14352 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 14353 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 14354 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 14355 { } /* end */ 14356}; 14357 14358static struct snd_kcontrol_new alc663_m51va_mixer[] = { 14359 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 14360 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 14361 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT), 14362 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 14363 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 14364 HDA_CODEC_MUTE("DMic Playback Switch", 0x23, 0x9, HDA_INPUT), 14365 { } /* end */ 14366}; 14367 14368static struct snd_kcontrol_new alc663_g71v_mixer[] = { 14369 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 14370 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 14371 HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT), 14372 HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT), 14373 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT), 14374 14375 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 14376 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 14377 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 14378 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 14379 { } /* end */ 14380}; 14381 14382static struct snd_kcontrol_new alc663_g50v_mixer[] = { 14383 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT), 14384 HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT), 14385 HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT), 14386 14387 HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), 14388 HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), 14389 HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT), 14390 HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT), 14391 HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), 14392 HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), 14393 { } /* end */ 14394}; 14395 14396static struct snd_kcontrol_new alc662_chmode_mixer[] = { 14397 { 14398 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 14399 .name = "Channel Mode", 14400 .info = alc_ch_mode_info, 14401 .get = alc_ch_mode_get, 14402 .put = alc_ch_mode_put, 14403 }, 14404 { } /* end */ 14405}; 14406 14407static struct hda_verb alc662_init_verbs[] = { 14408 /* ADC: mute amp left and right */ 14409 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 14410 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 14411 /* Front mixer: unmute input/output amp left and right (volume = 0) */ 14412 14413 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 14414 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 14415 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 14416 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 14417 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 14418 14419 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14420 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14421 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14422 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14423 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14424 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14425 14426 /* Front Pin: output 0 (0x0c) */ 14427 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14428 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14429 14430 /* Rear Pin: output 1 (0x0d) */ 14431 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14432 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14433 14434 /* CLFE Pin: output 2 (0x0e) */ 14435 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14436 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14437 14438 /* Mic (rear) pin: input vref at 80% */ 14439 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 14440 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 14441 /* Front Mic pin: input vref at 80% */ 14442 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 14443 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 14444 /* Line In pin: input */ 14445 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14446 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 14447 /* Line-2 In: Headphone output (output 0 - 0x0c) */ 14448 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 14449 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14450 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 14451 /* CD pin widget for input */ 14452 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 14453 14454 /* FIXME: use matrix-type input source selection */ 14455 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 14456 /* Input mixer */ 14457 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14458 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14459 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 14460 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 14461 14462 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14463 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14464 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 14465 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 14466 14467 /* always trun on EAPD */ 14468 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2}, 14469 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2}, 14470 14471 { } 14472}; 14473 14474static struct hda_verb alc662_sue_init_verbs[] = { 14475 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT}, 14476 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT}, 14477 {} 14478}; 14479 14480static struct hda_verb alc662_eeepc_sue_init_verbs[] = { 14481 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 14482 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 14483 {} 14484}; 14485 14486/* Set Unsolicited Event*/ 14487static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = { 14488 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 14489 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 14490 {} 14491}; 14492 14493/* 14494 * generic initialization of ADC, input mixers and output mixers 14495 */ 14496static struct hda_verb alc662_auto_init_verbs[] = { 14497 /* 14498 * Unmute ADC and set the default input to mic-in 14499 */ 14500 {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, 14501 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14502 14503 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 14504 * mixer widget 14505 * Note: PASD motherboards uses the Line In 2 as the input for front 14506 * panel mic (mic 2) 14507 */ 14508 /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ 14509 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 14510 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 14511 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 14512 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 14513 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 14514 14515 /* 14516 * Set up output mixers (0x0c - 0x0f) 14517 */ 14518 /* set vol=0 to output mixers */ 14519 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14520 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14521 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 14522 14523 /* set up input amps for analog loopback */ 14524 /* Amp Indices: DAC = 0, mixer = 1 */ 14525 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14526 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14527 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14528 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14529 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14530 {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14531 14532 14533 /* FIXME: use matrix-type input source selection */ 14534 /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ 14535 /* Input mixer */ 14536 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14537 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14538 { } 14539}; 14540 14541/* additional verbs for ALC663 */ 14542static struct hda_verb alc663_auto_init_verbs[] = { 14543 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 14544 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 14545 { } 14546}; 14547 14548static struct hda_verb alc663_m51va_init_verbs[] = { 14549 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 14550 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14551 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */ 14552 14553 {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)}, 14554 14555 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 14556 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 14557 {} 14558}; 14559 14560static struct hda_verb alc663_g71v_init_verbs[] = { 14561 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 14562 /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */ 14563 /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */ 14564 14565 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 14566 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14567 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */ 14568 14569 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT}, 14570 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT}, 14571 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT}, 14572 {} 14573}; 14574 14575static struct hda_verb alc663_g50v_init_verbs[] = { 14576 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 14577 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 14578 {0x21, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Headphone */ 14579 14580 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT}, 14581 {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT}, 14582 {} 14583}; 14584 14585/* capture mixer elements */ 14586static struct snd_kcontrol_new alc662_capture_mixer[] = { 14587 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT), 14588 HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT), 14589 { 14590 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 14591 /* The multiple "Capture Source" controls confuse alsamixer 14592 * So call somewhat different.. 14593 */ 14594 /* .name = "Capture Source", */ 14595 .name = "Input Source", 14596 .count = 1, 14597 .info = alc662_mux_enum_info, 14598 .get = alc662_mux_enum_get, 14599 .put = alc662_mux_enum_put, 14600 }, 14601 { } /* end */ 14602}; 14603 14604static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec) 14605{ 14606 unsigned int present; 14607 unsigned char bits; 14608 14609 present = snd_hda_codec_read(codec, 0x14, 0, 14610 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 14611 bits = present ? HDA_AMP_MUTE : 0; 14612 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 14613 HDA_AMP_MUTE, bits); 14614} 14615 14616static void alc662_lenovo_101e_all_automute(struct hda_codec *codec) 14617{ 14618 unsigned int present; 14619 unsigned char bits; 14620 14621 present = snd_hda_codec_read(codec, 0x1b, 0, 14622 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 14623 bits = present ? HDA_AMP_MUTE : 0; 14624 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 14625 HDA_AMP_MUTE, bits); 14626 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 14627 HDA_AMP_MUTE, bits); 14628} 14629 14630static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec, 14631 unsigned int res) 14632{ 14633 if ((res >> 26) == ALC880_HP_EVENT) 14634 alc662_lenovo_101e_all_automute(codec); 14635 if ((res >> 26) == ALC880_FRONT_EVENT) 14636 alc662_lenovo_101e_ispeaker_automute(codec); 14637} 14638 14639static void alc662_eeepc_mic_automute(struct hda_codec *codec) 14640{ 14641 unsigned int present; 14642 14643 present = snd_hda_codec_read(codec, 0x18, 0, 14644 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 14645 snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE, 14646 0x7000 | (0x00 << 8) | (present ? 0 : 0x80)); 14647 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE, 14648 0x7000 | (0x00 << 8) | (present ? 0 : 0x80)); 14649 snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE, 14650 0x7000 | (0x01 << 8) | (present ? 0x80 : 0)); 14651 snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE, 14652 0x7000 | (0x01 << 8) | (present ? 0x80 : 0)); 14653} 14654 14655/* unsolicited event for HP jack sensing */ 14656static void alc662_eeepc_unsol_event(struct hda_codec *codec, 14657 unsigned int res) 14658{ 14659 if ((res >> 26) == ALC880_HP_EVENT) 14660 alc262_hippo1_automute( codec ); 14661 14662 if ((res >> 26) == ALC880_MIC_EVENT) 14663 alc662_eeepc_mic_automute(codec); 14664} 14665 14666static void alc662_eeepc_inithook(struct hda_codec *codec) 14667{ 14668 alc262_hippo1_automute( codec ); 14669 alc662_eeepc_mic_automute(codec); 14670} 14671 14672static void alc662_eeepc_ep20_automute(struct hda_codec *codec) 14673{ 14674 unsigned int mute; 14675 unsigned int present; 14676 14677 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0); 14678 present = snd_hda_codec_read(codec, 0x14, 0, 14679 AC_VERB_GET_PIN_SENSE, 0); 14680 present = (present & 0x80000000) != 0; 14681 if (present) { 14682 /* mute internal speaker */ 14683 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 14684 HDA_AMP_MUTE, HDA_AMP_MUTE); 14685 } else { 14686 /* unmute internal speaker if necessary */ 14687 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0); 14688 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 14689 HDA_AMP_MUTE, mute); 14690 } 14691} 14692 14693/* unsolicited event for HP jack sensing */ 14694static void alc662_eeepc_ep20_unsol_event(struct hda_codec *codec, 14695 unsigned int res) 14696{ 14697 if ((res >> 26) == ALC880_HP_EVENT) 14698 alc662_eeepc_ep20_automute(codec); 14699} 14700 14701static void alc662_eeepc_ep20_inithook(struct hda_codec *codec) 14702{ 14703 alc662_eeepc_ep20_automute(codec); 14704} 14705 14706static void alc663_m51va_speaker_automute(struct hda_codec *codec) 14707{ 14708 unsigned int present; 14709 unsigned char bits; 14710 14711 present = snd_hda_codec_read(codec, 0x21, 0, 14712 AC_VERB_GET_PIN_SENSE, 0) 14713 & AC_PINSENSE_PRESENCE; 14714 bits = present ? HDA_AMP_MUTE : 0; 14715 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 14716 HDA_AMP_MUTE, bits); 14717} 14718 14719static void alc663_m51va_mic_automute(struct hda_codec *codec) 14720{ 14721 unsigned int present; 14722 14723 present = snd_hda_codec_read(codec, 0x18, 0, 14724 AC_VERB_GET_PIN_SENSE, 0) 14725 & AC_PINSENSE_PRESENCE; 14726 snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE, 14727 0x7000 | (0x00 << 8) | (present ? 0 : 0x80)); 14728 snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE, 14729 0x7000 | (0x00 << 8) | (present ? 0 : 0x80)); 14730 snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE, 14731 0x7000 | (0x09 << 8) | (present ? 0x80 : 0)); 14732 snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE, 14733 0x7000 | (0x09 << 8) | (present ? 0x80 : 0)); 14734} 14735 14736static void alc663_m51va_unsol_event(struct hda_codec *codec, 14737 unsigned int res) 14738{ 14739 switch (res >> 26) { 14740 case ALC880_HP_EVENT: 14741 alc663_m51va_speaker_automute(codec); 14742 break; 14743 case ALC880_MIC_EVENT: 14744 alc663_m51va_mic_automute(codec); 14745 break; 14746 } 14747} 14748 14749static void alc663_m51va_inithook(struct hda_codec *codec) 14750{ 14751 alc663_m51va_speaker_automute(codec); 14752 alc663_m51va_mic_automute(codec); 14753} 14754 14755static void alc663_g71v_hp_automute(struct hda_codec *codec) 14756{ 14757 unsigned int present; 14758 unsigned char bits; 14759 14760 present = snd_hda_codec_read(codec, 0x21, 0, 14761 AC_VERB_GET_PIN_SENSE, 0) 14762 & AC_PINSENSE_PRESENCE; 14763 bits = present ? HDA_AMP_MUTE : 0; 14764 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, 14765 HDA_AMP_MUTE, bits); 14766 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 14767 HDA_AMP_MUTE, bits); 14768} 14769 14770static void alc663_g71v_front_automute(struct hda_codec *codec) 14771{ 14772 unsigned int present; 14773 unsigned char bits; 14774 14775 present = snd_hda_codec_read(codec, 0x15, 0, 14776 AC_VERB_GET_PIN_SENSE, 0) 14777 & AC_PINSENSE_PRESENCE; 14778 bits = present ? HDA_AMP_MUTE : 0; 14779 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0, 14780 HDA_AMP_MUTE, bits); 14781} 14782 14783static void alc663_g71v_unsol_event(struct hda_codec *codec, 14784 unsigned int res) 14785{ 14786 switch (res >> 26) { 14787 case ALC880_HP_EVENT: 14788 alc663_g71v_hp_automute(codec); 14789 break; 14790 case ALC880_FRONT_EVENT: 14791 alc663_g71v_front_automute(codec); 14792 break; 14793 case ALC880_MIC_EVENT: 14794 alc662_eeepc_mic_automute(codec); 14795 break; 14796 } 14797} 14798 14799static void alc663_g71v_inithook(struct hda_codec *codec) 14800{ 14801 alc663_g71v_front_automute(codec); 14802 alc663_g71v_hp_automute(codec); 14803 alc662_eeepc_mic_automute(codec); 14804} 14805 14806static void alc663_g50v_unsol_event(struct hda_codec *codec, 14807 unsigned int res) 14808{ 14809 switch (res >> 26) { 14810 case ALC880_HP_EVENT: 14811 alc663_m51va_speaker_automute(codec); 14812 break; 14813 case ALC880_MIC_EVENT: 14814 alc662_eeepc_mic_automute(codec); 14815 break; 14816 } 14817} 14818 14819static void alc663_g50v_inithook(struct hda_codec *codec) 14820{ 14821 alc663_m51va_speaker_automute(codec); 14822 alc662_eeepc_mic_automute(codec); 14823} 14824 14825#ifdef CONFIG_SND_HDA_POWER_SAVE 14826#define alc662_loopbacks alc880_loopbacks 14827#endif 14828 14829 14830/* pcm configuration: identiacal with ALC880 */ 14831#define alc662_pcm_analog_playback alc880_pcm_analog_playback 14832#define alc662_pcm_analog_capture alc880_pcm_analog_capture 14833#define alc662_pcm_digital_playback alc880_pcm_digital_playback 14834#define alc662_pcm_digital_capture alc880_pcm_digital_capture 14835 14836/* 14837 * configuration and preset 14838 */ 14839static const char *alc662_models[ALC662_MODEL_LAST] = { 14840 [ALC662_3ST_2ch_DIG] = "3stack-dig", 14841 [ALC662_3ST_6ch_DIG] = "3stack-6ch-dig", 14842 [ALC662_3ST_6ch] = "3stack-6ch", 14843 [ALC662_5ST_DIG] = "6stack-dig", 14844 [ALC662_LENOVO_101E] = "lenovo-101e", 14845 [ALC662_ASUS_EEEPC_P701] = "eeepc-p701", 14846 [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20", 14847 [ALC663_ASUS_M51VA] = "m51va", 14848 [ALC663_ASUS_G71V] = "g71v", 14849 [ALC663_ASUS_H13] = "h13", 14850 [ALC663_ASUS_G50V] = "g50v", 14851 [ALC662_AUTO] = "auto", 14852}; 14853 14854static struct snd_pci_quirk alc662_cfg_tbl[] = { 14855 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS G71V", ALC663_ASUS_G71V), 14856 SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA), 14857 SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS M51VA", ALC663_ASUS_G50V), 14858 SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG), 14859 SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701), 14860 SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20), 14861 SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E), 14862 SND_PCI_QUIRK(0x1854, 0x2000, "ASUS H13-2000", ALC663_ASUS_H13), 14863 SND_PCI_QUIRK(0x1854, 0x2001, "ASUS H13-2001", ALC663_ASUS_H13), 14864 SND_PCI_QUIRK(0x1854, 0x2002, "ASUS H13-2002", ALC663_ASUS_H13), 14865 {} 14866}; 14867 14868static struct alc_config_preset alc662_presets[] = { 14869 [ALC662_3ST_2ch_DIG] = { 14870 .mixers = { alc662_3ST_2ch_mixer, alc662_capture_mixer }, 14871 .init_verbs = { alc662_init_verbs }, 14872 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 14873 .dac_nids = alc662_dac_nids, 14874 .dig_out_nid = ALC662_DIGOUT_NID, 14875 .dig_in_nid = ALC662_DIGIN_NID, 14876 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 14877 .channel_mode = alc662_3ST_2ch_modes, 14878 .input_mux = &alc662_capture_source, 14879 }, 14880 [ALC662_3ST_6ch_DIG] = { 14881 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer, 14882 alc662_capture_mixer }, 14883 .init_verbs = { alc662_init_verbs }, 14884 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 14885 .dac_nids = alc662_dac_nids, 14886 .dig_out_nid = ALC662_DIGOUT_NID, 14887 .dig_in_nid = ALC662_DIGIN_NID, 14888 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes), 14889 .channel_mode = alc662_3ST_6ch_modes, 14890 .need_dac_fix = 1, 14891 .input_mux = &alc662_capture_source, 14892 }, 14893 [ALC662_3ST_6ch] = { 14894 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer, 14895 alc662_capture_mixer }, 14896 .init_verbs = { alc662_init_verbs }, 14897 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 14898 .dac_nids = alc662_dac_nids, 14899 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes), 14900 .channel_mode = alc662_3ST_6ch_modes, 14901 .need_dac_fix = 1, 14902 .input_mux = &alc662_capture_source, 14903 }, 14904 [ALC662_5ST_DIG] = { 14905 .mixers = { alc662_base_mixer, alc662_chmode_mixer, 14906 alc662_capture_mixer }, 14907 .init_verbs = { alc662_init_verbs }, 14908 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 14909 .dac_nids = alc662_dac_nids, 14910 .dig_out_nid = ALC662_DIGOUT_NID, 14911 .dig_in_nid = ALC662_DIGIN_NID, 14912 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes), 14913 .channel_mode = alc662_5stack_modes, 14914 .input_mux = &alc662_capture_source, 14915 }, 14916 [ALC662_LENOVO_101E] = { 14917 .mixers = { alc662_lenovo_101e_mixer, alc662_capture_mixer }, 14918 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs }, 14919 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 14920 .dac_nids = alc662_dac_nids, 14921 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 14922 .channel_mode = alc662_3ST_2ch_modes, 14923 .input_mux = &alc662_lenovo_101e_capture_source, 14924 .unsol_event = alc662_lenovo_101e_unsol_event, 14925 .init_hook = alc662_lenovo_101e_all_automute, 14926 }, 14927 [ALC662_ASUS_EEEPC_P701] = { 14928 .mixers = { alc662_eeepc_p701_mixer, alc662_capture_mixer }, 14929 .init_verbs = { alc662_init_verbs, 14930 alc662_eeepc_sue_init_verbs }, 14931 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 14932 .dac_nids = alc662_dac_nids, 14933 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 14934 .channel_mode = alc662_3ST_2ch_modes, 14935 .input_mux = &alc662_eeepc_capture_source, 14936 .unsol_event = alc662_eeepc_unsol_event, 14937 .init_hook = alc662_eeepc_inithook, 14938 }, 14939 [ALC662_ASUS_EEEPC_EP20] = { 14940 .mixers = { alc662_eeepc_ep20_mixer, alc662_capture_mixer, 14941 alc662_chmode_mixer }, 14942 .init_verbs = { alc662_init_verbs, 14943 alc662_eeepc_ep20_sue_init_verbs }, 14944 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 14945 .dac_nids = alc662_dac_nids, 14946 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes), 14947 .channel_mode = alc662_3ST_6ch_modes, 14948 .input_mux = &alc662_lenovo_101e_capture_source, 14949 .unsol_event = alc662_eeepc_ep20_unsol_event, 14950 .init_hook = alc662_eeepc_ep20_inithook, 14951 }, 14952 [ALC663_ASUS_M51VA] = { 14953 .mixers = { alc663_m51va_mixer, alc662_capture_mixer}, 14954 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs }, 14955 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 14956 .dac_nids = alc662_dac_nids, 14957 .dig_out_nid = ALC662_DIGOUT_NID, 14958 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 14959 .channel_mode = alc662_3ST_2ch_modes, 14960 .input_mux = &alc663_m51va_capture_source, 14961 .unsol_event = alc663_m51va_unsol_event, 14962 .init_hook = alc663_m51va_inithook, 14963 }, 14964 [ALC663_ASUS_G71V] = { 14965 .mixers = { alc663_g71v_mixer, alc662_capture_mixer}, 14966 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs }, 14967 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 14968 .dac_nids = alc662_dac_nids, 14969 .dig_out_nid = ALC662_DIGOUT_NID, 14970 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 14971 .channel_mode = alc662_3ST_2ch_modes, 14972 .input_mux = &alc662_eeepc_capture_source, 14973 .unsol_event = alc663_g71v_unsol_event, 14974 .init_hook = alc663_g71v_inithook, 14975 }, 14976 [ALC663_ASUS_H13] = { 14977 .mixers = { alc663_m51va_mixer, alc662_capture_mixer}, 14978 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs }, 14979 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 14980 .dac_nids = alc662_dac_nids, 14981 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes), 14982 .channel_mode = alc662_3ST_2ch_modes, 14983 .input_mux = &alc663_m51va_capture_source, 14984 .unsol_event = alc663_m51va_unsol_event, 14985 .init_hook = alc663_m51va_inithook, 14986 }, 14987 [ALC663_ASUS_G50V] = { 14988 .mixers = { alc663_g50v_mixer, alc662_capture_mixer}, 14989 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs }, 14990 .num_dacs = ARRAY_SIZE(alc662_dac_nids), 14991 .dac_nids = alc662_dac_nids, 14992 .dig_out_nid = ALC662_DIGOUT_NID, 14993 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes), 14994 .channel_mode = alc662_3ST_6ch_modes, 14995 .input_mux = &alc663_capture_source, 14996 .unsol_event = alc663_g50v_unsol_event, 14997 .init_hook = alc663_g50v_inithook, 14998 }, 14999}; 15000 15001 15002/* 15003 * BIOS auto configuration 15004 */ 15005 15006/* add playback controls from the parsed DAC table */ 15007static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec, 15008 const struct auto_pin_cfg *cfg) 15009{ 15010 char name[32]; 15011 static const char *chname[4] = { 15012 "Front", "Surround", NULL /*CLFE*/, "Side" 15013 }; 15014 hda_nid_t nid; 15015 int i, err; 15016 15017 for (i = 0; i < cfg->line_outs; i++) { 15018 if (!spec->multiout.dac_nids[i]) 15019 continue; 15020 nid = alc880_idx_to_dac(i); 15021 if (i == 2) { 15022 /* Center/LFE */ 15023 err = add_control(spec, ALC_CTL_WIDGET_VOL, 15024 "Center Playback Volume", 15025 HDA_COMPOSE_AMP_VAL(nid, 1, 0, 15026 HDA_OUTPUT)); 15027 if (err < 0) 15028 return err; 15029 err = add_control(spec, ALC_CTL_WIDGET_VOL, 15030 "LFE Playback Volume", 15031 HDA_COMPOSE_AMP_VAL(nid, 2, 0, 15032 HDA_OUTPUT)); 15033 if (err < 0) 15034 return err; 15035 err = add_control(spec, ALC_CTL_BIND_MUTE, 15036 "Center Playback Switch", 15037 HDA_COMPOSE_AMP_VAL(nid, 1, 2, 15038 HDA_INPUT)); 15039 if (err < 0) 15040 return err; 15041 err = add_control(spec, ALC_CTL_BIND_MUTE, 15042 "LFE Playback Switch", 15043 HDA_COMPOSE_AMP_VAL(nid, 2, 2, 15044 HDA_INPUT)); 15045 if (err < 0) 15046 return err; 15047 } else { 15048 sprintf(name, "%s Playback Volume", chname[i]); 15049 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 15050 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 15051 HDA_OUTPUT)); 15052 if (err < 0) 15053 return err; 15054 sprintf(name, "%s Playback Switch", chname[i]); 15055 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 15056 HDA_COMPOSE_AMP_VAL(nid, 3, 2, 15057 HDA_INPUT)); 15058 if (err < 0) 15059 return err; 15060 } 15061 } 15062 return 0; 15063} 15064 15065/* add playback controls for speaker and HP outputs */ 15066static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin, 15067 const char *pfx) 15068{ 15069 hda_nid_t nid; 15070 int err; 15071 char name[32]; 15072 15073 if (!pin) 15074 return 0; 15075 15076 if (pin == 0x17) { 15077 /* ALC663 has a mono output pin on 0x17 */ 15078 sprintf(name, "%s Playback Switch", pfx); 15079 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 15080 HDA_COMPOSE_AMP_VAL(pin, 2, 0, HDA_OUTPUT)); 15081 return err; 15082 } 15083 15084 if (alc880_is_fixed_pin(pin)) { 15085 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin)); 15086 /* printk("DAC nid=%x\n",nid); */ 15087 /* specify the DAC as the extra output */ 15088 if (!spec->multiout.hp_nid) 15089 spec->multiout.hp_nid = nid; 15090 else 15091 spec->multiout.extra_out_nid[0] = nid; 15092 /* control HP volume/switch on the output mixer amp */ 15093 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin)); 15094 sprintf(name, "%s Playback Volume", pfx); 15095 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, 15096 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 15097 if (err < 0) 15098 return err; 15099 sprintf(name, "%s Playback Switch", pfx); 15100 err = add_control(spec, ALC_CTL_BIND_MUTE, name, 15101 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT)); 15102 if (err < 0) 15103 return err; 15104 } else if (alc880_is_multi_pin(pin)) { 15105 /* set manual connection */ 15106 /* we have only a switch on HP-out PIN */ 15107 sprintf(name, "%s Playback Switch", pfx); 15108 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, 15109 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 15110 if (err < 0) 15111 return err; 15112 } 15113 return 0; 15114} 15115 15116/* create playback/capture controls for input pins */ 15117static int alc662_auto_create_analog_input_ctls(struct alc_spec *spec, 15118 const struct auto_pin_cfg *cfg) 15119{ 15120 struct hda_input_mux *imux = &spec->private_imux; 15121 int i, err, idx; 15122 15123 for (i = 0; i < AUTO_PIN_LAST; i++) { 15124 if (alc880_is_input_pin(cfg->input_pins[i])) { 15125 idx = alc880_input_pin_idx(cfg->input_pins[i]); 15126 err = new_analog_input(spec, cfg->input_pins[i], 15127 auto_pin_cfg_labels[i], 15128 idx, 0x0b); 15129 if (err < 0) 15130 return err; 15131 imux->items[imux->num_items].label = 15132 auto_pin_cfg_labels[i]; 15133 imux->items[imux->num_items].index = 15134 alc880_input_pin_idx(cfg->input_pins[i]); 15135 imux->num_items++; 15136 } 15137 } 15138 return 0; 15139} 15140 15141static void alc662_auto_set_output_and_unmute(struct hda_codec *codec, 15142 hda_nid_t nid, int pin_type, 15143 int dac_idx) 15144{ 15145 alc_set_pin_output(codec, nid, pin_type); 15146 /* need the manual connection? */ 15147 if (alc880_is_multi_pin(nid)) { 15148 struct alc_spec *spec = codec->spec; 15149 int idx = alc880_multi_pin_idx(nid); 15150 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0, 15151 AC_VERB_SET_CONNECT_SEL, 15152 alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx])); 15153 } 15154} 15155 15156static void alc662_auto_init_multi_out(struct hda_codec *codec) 15157{ 15158 struct alc_spec *spec = codec->spec; 15159 int i; 15160 15161 alc_subsystem_id(codec, 0x15, 0x1b, 0x14); 15162 for (i = 0; i <= HDA_SIDE; i++) { 15163 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 15164 int pin_type = get_pin_type(spec->autocfg.line_out_type); 15165 if (nid) 15166 alc662_auto_set_output_and_unmute(codec, nid, pin_type, 15167 i); 15168 } 15169} 15170 15171static void alc662_auto_init_hp_out(struct hda_codec *codec) 15172{ 15173 struct alc_spec *spec = codec->spec; 15174 hda_nid_t pin; 15175 15176 pin = spec->autocfg.hp_pins[0]; 15177 if (pin) /* connect to front */ 15178 /* use dac 0 */ 15179 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 15180 pin = spec->autocfg.speaker_pins[0]; 15181 if (pin) 15182 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 15183} 15184 15185#define alc662_is_input_pin(nid) alc880_is_input_pin(nid) 15186#define ALC662_PIN_CD_NID ALC880_PIN_CD_NID 15187 15188static void alc662_auto_init_analog_input(struct hda_codec *codec) 15189{ 15190 struct alc_spec *spec = codec->spec; 15191 int i; 15192 15193 for (i = 0; i < AUTO_PIN_LAST; i++) { 15194 hda_nid_t nid = spec->autocfg.input_pins[i]; 15195 if (alc662_is_input_pin(nid)) { 15196 snd_hda_codec_write(codec, nid, 0, 15197 AC_VERB_SET_PIN_WIDGET_CONTROL, 15198 (i <= AUTO_PIN_FRONT_MIC ? 15199 PIN_VREF80 : PIN_IN)); 15200 if (nid != ALC662_PIN_CD_NID) 15201 snd_hda_codec_write(codec, nid, 0, 15202 AC_VERB_SET_AMP_GAIN_MUTE, 15203 AMP_OUT_MUTE); 15204 } 15205 } 15206} 15207 15208#define alc662_auto_init_input_src alc882_auto_init_input_src 15209 15210static int alc662_parse_auto_config(struct hda_codec *codec) 15211{ 15212 struct alc_spec *spec = codec->spec; 15213 int err; 15214 static hda_nid_t alc662_ignore[] = { 0x1d, 0 }; 15215 15216 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 15217 alc662_ignore); 15218 if (err < 0) 15219 return err; 15220 if (!spec->autocfg.line_outs) 15221 return 0; /* can't find valid BIOS pin config */ 15222 15223 err = alc880_auto_fill_dac_nids(spec, &spec->autocfg); 15224 if (err < 0) 15225 return err; 15226 err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg); 15227 if (err < 0) 15228 return err; 15229 err = alc662_auto_create_extra_out(spec, 15230 spec->autocfg.speaker_pins[0], 15231 "Speaker"); 15232 if (err < 0) 15233 return err; 15234 err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0], 15235 "Headphone"); 15236 if (err < 0) 15237 return err; 15238 err = alc662_auto_create_analog_input_ctls(spec, &spec->autocfg); 15239 if (err < 0) 15240 return err; 15241 15242 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 15243 15244 if (spec->autocfg.dig_out_pin) 15245 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID; 15246 15247 if (spec->kctl_alloc) 15248 spec->mixers[spec->num_mixers++] = spec->kctl_alloc; 15249 15250 spec->num_mux_defs = 1; 15251 spec->input_mux = &spec->private_imux; 15252 15253 spec->init_verbs[spec->num_init_verbs++] = alc662_auto_init_verbs; 15254 if (codec->vendor_id == 0x10ec0663) 15255 spec->init_verbs[spec->num_init_verbs++] = 15256 alc663_auto_init_verbs; 15257 15258 err = alc_auto_add_mic_boost(codec); 15259 if (err < 0) 15260 return err; 15261 15262 spec->mixers[spec->num_mixers] = alc662_capture_mixer; 15263 spec->num_mixers++; 15264 return 1; 15265} 15266 15267/* additional initialization for auto-configuration model */ 15268static void alc662_auto_init(struct hda_codec *codec) 15269{ 15270 struct alc_spec *spec = codec->spec; 15271 alc662_auto_init_multi_out(codec); 15272 alc662_auto_init_hp_out(codec); 15273 alc662_auto_init_analog_input(codec); 15274 alc662_auto_init_input_src(codec); 15275 if (spec->unsol_event) 15276 alc_sku_automute(codec); 15277} 15278 15279static int patch_alc662(struct hda_codec *codec) 15280{ 15281 struct alc_spec *spec; 15282 int err, board_config; 15283 15284 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 15285 if (!spec) 15286 return -ENOMEM; 15287 15288 codec->spec = spec; 15289 15290 alc_fix_pll_init(codec, 0x20, 0x04, 15); 15291 15292 board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST, 15293 alc662_models, 15294 alc662_cfg_tbl); 15295 if (board_config < 0) { 15296 printk(KERN_INFO "hda_codec: Unknown model for ALC662, " 15297 "trying auto-probe from BIOS...\n"); 15298 board_config = ALC662_AUTO; 15299 } 15300 15301 if (board_config == ALC662_AUTO) { 15302 /* automatic parse from the BIOS config */ 15303 err = alc662_parse_auto_config(codec); 15304 if (err < 0) { 15305 alc_free(codec); 15306 return err; 15307 } else if (!err) { 15308 printk(KERN_INFO 15309 "hda_codec: Cannot set up configuration " 15310 "from BIOS. Using base mode...\n"); 15311 board_config = ALC662_3ST_2ch_DIG; 15312 } 15313 } 15314 15315 if (board_config != ALC662_AUTO) 15316 setup_preset(spec, &alc662_presets[board_config]); 15317 15318 if (codec->vendor_id == 0x10ec0663) { 15319 spec->stream_name_analog = "ALC663 Analog"; 15320 spec->stream_name_digital = "ALC663 Digital"; 15321 } else { 15322 spec->stream_name_analog = "ALC662 Analog"; 15323 spec->stream_name_digital = "ALC662 Digital"; 15324 } 15325 15326 spec->stream_analog_playback = &alc662_pcm_analog_playback; 15327 spec->stream_analog_capture = &alc662_pcm_analog_capture; 15328 15329 spec->stream_digital_playback = &alc662_pcm_digital_playback; 15330 spec->stream_digital_capture = &alc662_pcm_digital_capture; 15331 15332 spec->adc_nids = alc662_adc_nids; 15333 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids); 15334 spec->capsrc_nids = alc662_capsrc_nids; 15335 15336 spec->vmaster_nid = 0x02; 15337 15338 codec->patch_ops = alc_patch_ops; 15339 if (board_config == ALC662_AUTO) 15340 spec->init_hook = alc662_auto_init; 15341#ifdef CONFIG_SND_HDA_POWER_SAVE 15342 if (!spec->loopback.amplist) 15343 spec->loopback.amplist = alc662_loopbacks; 15344#endif 15345 15346 return 0; 15347} 15348 15349/* 15350 * patch entries 15351 */ 15352struct hda_codec_preset snd_hda_preset_realtek[] = { 15353 { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 }, 15354 { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 }, 15355 { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 }, 15356 { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 }, 15357 { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 }, 15358 { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660", 15359 .patch = patch_alc861 }, 15360 { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd }, 15361 { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 }, 15362 { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd }, 15363 { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2", 15364 .patch = patch_alc883 }, 15365 { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1", 15366 .patch = patch_alc662 }, 15367 { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 }, 15368 { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 }, 15369 { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 }, 15370 { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 }, 15371 { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A", 15372 .patch = patch_alc882 }, /* should be patch_alc883() in future */ 15373 { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 }, 15374 { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 }, 15375 { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 }, 15376 {} /* terminator */ 15377}; 15378