1 /* 2 * HD audio interface patch for AD1882, AD1884, AD1981HD, AD1983, AD1984, 3 * AD1986A, AD1988 4 * 5 * Copyright (c) 2005-2007 Takashi Iwai <tiwai@suse.de> 6 * 7 * This driver is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This driver is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 */ 21 22 #include <linux/init.h> 23 #include <linux/delay.h> 24 #include <linux/slab.h> 25 #include <linux/pci.h> 26 #include <linux/mutex.h> 27 28 #include <sound/core.h> 29 #include "hda_codec.h" 30 #include "hda_local.h" 31 32 struct ad198x_spec { 33 struct snd_kcontrol_new *mixers[5]; 34 int num_mixers; 35 36 const struct hda_verb *init_verbs[5]; /* initialization verbs 37 * don't forget NULL termination! 38 */ 39 unsigned int num_init_verbs; 40 41 /* playback */ 42 struct hda_multi_out multiout; /* playback set-up 43 * max_channels, dacs must be set 44 * dig_out_nid and hp_nid are optional 45 */ 46 unsigned int cur_eapd; 47 unsigned int need_dac_fix; 48 49 /* capture */ 50 unsigned int num_adc_nids; 51 hda_nid_t *adc_nids; 52 hda_nid_t dig_in_nid; /* digital-in NID; optional */ 53 54 /* capture source */ 55 const struct hda_input_mux *input_mux; 56 hda_nid_t *capsrc_nids; 57 unsigned int cur_mux[3]; 58 59 /* channel model */ 60 const struct hda_channel_mode *channel_mode; 61 int num_channel_mode; 62 63 /* PCM information */ 64 struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */ 65 66 struct mutex amp_mutex; /* PCM volume/mute control mutex */ 67 unsigned int spdif_route; 68 69 /* dynamic controls, init_verbs and input_mux */ 70 struct auto_pin_cfg autocfg; 71 unsigned int num_kctl_alloc, num_kctl_used; 72 struct snd_kcontrol_new *kctl_alloc; 73 struct hda_input_mux private_imux; 74 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS]; 75 76 unsigned int jack_present :1; 77 78 #ifdef CONFIG_SND_HDA_POWER_SAVE 79 struct hda_loopback_check loopback; 80 #endif 81 /* for virtual master */ 82 hda_nid_t vmaster_nid; 83 u32 vmaster_tlv[4]; 84 const char **slave_vols; 85 const char **slave_sws; 86 }; 87 88 /* 89 * input MUX handling (common part) 90 */ 91 static int ad198x_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 92 { 93 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 94 struct ad198x_spec *spec = codec->spec; 95 96 return snd_hda_input_mux_info(spec->input_mux, uinfo); 97 } 98 99 static int ad198x_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 100 { 101 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 102 struct ad198x_spec *spec = codec->spec; 103 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 104 105 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx]; 106 return 0; 107 } 108 109 static int ad198x_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 110 { 111 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 112 struct ad198x_spec *spec = codec->spec; 113 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 114 115 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol, 116 spec->capsrc_nids[adc_idx], 117 &spec->cur_mux[adc_idx]); 118 } 119 120 /* 121 * initialization (common callbacks) 122 */ 123 static int ad198x_init(struct hda_codec *codec) 124 { 125 struct ad198x_spec *spec = codec->spec; 126 int i; 127 128 for (i = 0; i < spec->num_init_verbs; i++) 129 snd_hda_sequence_write(codec, spec->init_verbs[i]); 130 return 0; 131 } 132 133 static const char *ad_slave_vols[] = { 134 "Front Playback Volume", 135 "Surround Playback Volume", 136 "Center Playback Volume", 137 "LFE Playback Volume", 138 "Side Playback Volume", 139 "Headphone Playback Volume", 140 "Mono Playback Volume", 141 "Speaker Playback Volume", 142 "IEC958 Playback Volume", 143 NULL 144 }; 145 146 static const char *ad_slave_sws[] = { 147 "Front Playback Switch", 148 "Surround Playback Switch", 149 "Center Playback Switch", 150 "LFE Playback Switch", 151 "Side Playback Switch", 152 "Headphone Playback Switch", 153 "Mono Playback Switch", 154 "Speaker Playback Switch", 155 "IEC958 Playback Switch", 156 NULL 157 }; 158 159 static int ad198x_build_controls(struct hda_codec *codec) 160 { 161 struct ad198x_spec *spec = codec->spec; 162 unsigned int i; 163 int err; 164 165 for (i = 0; i < spec->num_mixers; i++) { 166 err = snd_hda_add_new_ctls(codec, spec->mixers[i]); 167 if (err < 0) 168 return err; 169 } 170 if (spec->multiout.dig_out_nid) { 171 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid); 172 if (err < 0) 173 return err; 174 } 175 if (spec->dig_in_nid) { 176 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid); 177 if (err < 0) 178 return err; 179 } 180 181 /* if we have no master control, let's create it */ 182 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) { 183 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid, 184 HDA_OUTPUT, spec->vmaster_tlv); 185 err = snd_hda_add_vmaster(codec, "Master Playback Volume", 186 spec->vmaster_tlv, 187 (spec->slave_vols ? 188 spec->slave_vols : ad_slave_vols)); 189 if (err < 0) 190 return err; 191 } 192 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) { 193 err = snd_hda_add_vmaster(codec, "Master Playback Switch", 194 NULL, 195 (spec->slave_sws ? 196 spec->slave_sws : ad_slave_sws)); 197 if (err < 0) 198 return err; 199 } 200 201 return 0; 202 } 203 204 #ifdef CONFIG_SND_HDA_POWER_SAVE 205 static int ad198x_check_power_status(struct hda_codec *codec, hda_nid_t nid) 206 { 207 struct ad198x_spec *spec = codec->spec; 208 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid); 209 } 210 #endif 211 212 /* 213 * Analog playback callbacks 214 */ 215 static int ad198x_playback_pcm_open(struct hda_pcm_stream *hinfo, 216 struct hda_codec *codec, 217 struct snd_pcm_substream *substream) 218 { 219 struct ad198x_spec *spec = codec->spec; 220 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream); 221 } 222 223 static int ad198x_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 224 struct hda_codec *codec, 225 unsigned int stream_tag, 226 unsigned int format, 227 struct snd_pcm_substream *substream) 228 { 229 struct ad198x_spec *spec = codec->spec; 230 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, 231 format, substream); 232 } 233 234 static int ad198x_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 235 struct hda_codec *codec, 236 struct snd_pcm_substream *substream) 237 { 238 struct ad198x_spec *spec = codec->spec; 239 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); 240 } 241 242 /* 243 * Digital out 244 */ 245 static int ad198x_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, 246 struct hda_codec *codec, 247 struct snd_pcm_substream *substream) 248 { 249 struct ad198x_spec *spec = codec->spec; 250 return snd_hda_multi_out_dig_open(codec, &spec->multiout); 251 } 252 253 static int ad198x_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, 254 struct hda_codec *codec, 255 struct snd_pcm_substream *substream) 256 { 257 struct ad198x_spec *spec = codec->spec; 258 return snd_hda_multi_out_dig_close(codec, &spec->multiout); 259 } 260 261 static int ad198x_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 262 struct hda_codec *codec, 263 unsigned int stream_tag, 264 unsigned int format, 265 struct snd_pcm_substream *substream) 266 { 267 struct ad198x_spec *spec = codec->spec; 268 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag, 269 format, substream); 270 } 271 272 /* 273 * Analog capture 274 */ 275 static int ad198x_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 276 struct hda_codec *codec, 277 unsigned int stream_tag, 278 unsigned int format, 279 struct snd_pcm_substream *substream) 280 { 281 struct ad198x_spec *spec = codec->spec; 282 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 283 stream_tag, 0, format); 284 return 0; 285 } 286 287 static int ad198x_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 288 struct hda_codec *codec, 289 struct snd_pcm_substream *substream) 290 { 291 struct ad198x_spec *spec = codec->spec; 292 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 293 0, 0, 0); 294 return 0; 295 } 296 297 298 /* 299 */ 300 static struct hda_pcm_stream ad198x_pcm_analog_playback = { 301 .substreams = 1, 302 .channels_min = 2, 303 .channels_max = 6, /* changed later */ 304 .nid = 0, /* fill later */ 305 .ops = { 306 .open = ad198x_playback_pcm_open, 307 .prepare = ad198x_playback_pcm_prepare, 308 .cleanup = ad198x_playback_pcm_cleanup 309 }, 310 }; 311 312 static struct hda_pcm_stream ad198x_pcm_analog_capture = { 313 .substreams = 1, 314 .channels_min = 2, 315 .channels_max = 2, 316 .nid = 0, /* fill later */ 317 .ops = { 318 .prepare = ad198x_capture_pcm_prepare, 319 .cleanup = ad198x_capture_pcm_cleanup 320 }, 321 }; 322 323 static struct hda_pcm_stream ad198x_pcm_digital_playback = { 324 .substreams = 1, 325 .channels_min = 2, 326 .channels_max = 2, 327 .nid = 0, /* fill later */ 328 .ops = { 329 .open = ad198x_dig_playback_pcm_open, 330 .close = ad198x_dig_playback_pcm_close, 331 .prepare = ad198x_dig_playback_pcm_prepare 332 }, 333 }; 334 335 static struct hda_pcm_stream ad198x_pcm_digital_capture = { 336 .substreams = 1, 337 .channels_min = 2, 338 .channels_max = 2, 339 /* NID is set in alc_build_pcms */ 340 }; 341 342 static int ad198x_build_pcms(struct hda_codec *codec) 343 { 344 struct ad198x_spec *spec = codec->spec; 345 struct hda_pcm *info = spec->pcm_rec; 346 347 codec->num_pcms = 1; 348 codec->pcm_info = info; 349 350 info->name = "AD198x Analog"; 351 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_analog_playback; 352 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->multiout.max_channels; 353 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0]; 354 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_analog_capture; 355 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adc_nids; 356 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; 357 358 if (spec->multiout.dig_out_nid) { 359 info++; 360 codec->num_pcms++; 361 info->name = "AD198x Digital"; 362 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_digital_playback; 363 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid; 364 if (spec->dig_in_nid) { 365 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_digital_capture; 366 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid; 367 } 368 } 369 370 return 0; 371 } 372 373 static void ad198x_free(struct hda_codec *codec) 374 { 375 struct ad198x_spec *spec = codec->spec; 376 unsigned int i; 377 378 if (spec->kctl_alloc) { 379 for (i = 0; i < spec->num_kctl_used; i++) 380 kfree(spec->kctl_alloc[i].name); 381 kfree(spec->kctl_alloc); 382 } 383 kfree(codec->spec); 384 } 385 386 static struct hda_codec_ops ad198x_patch_ops = { 387 .build_controls = ad198x_build_controls, 388 .build_pcms = ad198x_build_pcms, 389 .init = ad198x_init, 390 .free = ad198x_free, 391 #ifdef CONFIG_SND_HDA_POWER_SAVE 392 .check_power_status = ad198x_check_power_status, 393 #endif 394 }; 395 396 397 /* 398 * EAPD control 399 * the private value = nid | (invert << 8) 400 */ 401 #define ad198x_eapd_info snd_ctl_boolean_mono_info 402 403 static int ad198x_eapd_get(struct snd_kcontrol *kcontrol, 404 struct snd_ctl_elem_value *ucontrol) 405 { 406 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 407 struct ad198x_spec *spec = codec->spec; 408 int invert = (kcontrol->private_value >> 8) & 1; 409 if (invert) 410 ucontrol->value.integer.value[0] = ! spec->cur_eapd; 411 else 412 ucontrol->value.integer.value[0] = spec->cur_eapd; 413 return 0; 414 } 415 416 static int ad198x_eapd_put(struct snd_kcontrol *kcontrol, 417 struct snd_ctl_elem_value *ucontrol) 418 { 419 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 420 struct ad198x_spec *spec = codec->spec; 421 int invert = (kcontrol->private_value >> 8) & 1; 422 hda_nid_t nid = kcontrol->private_value & 0xff; 423 unsigned int eapd; 424 eapd = !!ucontrol->value.integer.value[0]; 425 if (invert) 426 eapd = !eapd; 427 if (eapd == spec->cur_eapd) 428 return 0; 429 spec->cur_eapd = eapd; 430 snd_hda_codec_write_cache(codec, nid, 431 0, AC_VERB_SET_EAPD_BTLENABLE, 432 eapd ? 0x02 : 0x00); 433 return 1; 434 } 435 436 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol, 437 struct snd_ctl_elem_info *uinfo); 438 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol, 439 struct snd_ctl_elem_value *ucontrol); 440 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol, 441 struct snd_ctl_elem_value *ucontrol); 442 443 444 /* 445 * AD1986A specific 446 */ 447 448 #define AD1986A_SPDIF_OUT 0x02 449 #define AD1986A_FRONT_DAC 0x03 450 #define AD1986A_SURR_DAC 0x04 451 #define AD1986A_CLFE_DAC 0x05 452 #define AD1986A_ADC 0x06 453 454 static hda_nid_t ad1986a_dac_nids[3] = { 455 AD1986A_FRONT_DAC, AD1986A_SURR_DAC, AD1986A_CLFE_DAC 456 }; 457 static hda_nid_t ad1986a_adc_nids[1] = { AD1986A_ADC }; 458 static hda_nid_t ad1986a_capsrc_nids[1] = { 0x12 }; 459 460 static struct hda_input_mux ad1986a_capture_source = { 461 .num_items = 7, 462 .items = { 463 { "Mic", 0x0 }, 464 { "CD", 0x1 }, 465 { "Aux", 0x3 }, 466 { "Line", 0x4 }, 467 { "Mix", 0x5 }, 468 { "Mono", 0x6 }, 469 { "Phone", 0x7 }, 470 }, 471 }; 472 473 474 static struct hda_bind_ctls ad1986a_bind_pcm_vol = { 475 .ops = &snd_hda_bind_vol, 476 .values = { 477 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT), 478 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT), 479 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT), 480 0 481 }, 482 }; 483 484 static struct hda_bind_ctls ad1986a_bind_pcm_sw = { 485 .ops = &snd_hda_bind_sw, 486 .values = { 487 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT), 488 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT), 489 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT), 490 0 491 }, 492 }; 493 494 /* 495 * mixers 496 */ 497 static struct snd_kcontrol_new ad1986a_mixers[] = { 498 /* 499 * bind volumes/mutes of 3 DACs as a single PCM control for simplicity 500 */ 501 HDA_BIND_VOL("PCM Playback Volume", &ad1986a_bind_pcm_vol), 502 HDA_BIND_SW("PCM Playback Switch", &ad1986a_bind_pcm_sw), 503 HDA_CODEC_VOLUME("Front Playback Volume", 0x1b, 0x0, HDA_OUTPUT), 504 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 505 HDA_CODEC_VOLUME("Surround Playback Volume", 0x1c, 0x0, HDA_OUTPUT), 506 HDA_CODEC_MUTE("Surround Playback Switch", 0x1c, 0x0, HDA_OUTPUT), 507 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x1d, 1, 0x0, HDA_OUTPUT), 508 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x1d, 2, 0x0, HDA_OUTPUT), 509 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x1d, 1, 0x0, HDA_OUTPUT), 510 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x1d, 2, 0x0, HDA_OUTPUT), 511 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x1a, 0x0, HDA_OUTPUT), 512 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT), 513 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT), 514 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT), 515 HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT), 516 HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT), 517 HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT), 518 HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT), 519 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT), 520 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT), 521 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT), 522 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x18, 0x0, HDA_OUTPUT), 523 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x18, 0x0, HDA_OUTPUT), 524 HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT), 525 HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT), 526 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT), 527 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT), 528 { 529 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 530 .name = "Capture Source", 531 .info = ad198x_mux_enum_info, 532 .get = ad198x_mux_enum_get, 533 .put = ad198x_mux_enum_put, 534 }, 535 HDA_CODEC_MUTE("Stereo Downmix Switch", 0x09, 0x0, HDA_OUTPUT), 536 { } /* end */ 537 }; 538 539 /* additional mixers for 3stack mode */ 540 static struct snd_kcontrol_new ad1986a_3st_mixers[] = { 541 { 542 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 543 .name = "Channel Mode", 544 .info = ad198x_ch_mode_info, 545 .get = ad198x_ch_mode_get, 546 .put = ad198x_ch_mode_put, 547 }, 548 { } /* end */ 549 }; 550 551 /* laptop model - 2ch only */ 552 static hda_nid_t ad1986a_laptop_dac_nids[1] = { AD1986A_FRONT_DAC }; 553 554 /* master controls both pins 0x1a and 0x1b */ 555 static struct hda_bind_ctls ad1986a_laptop_master_vol = { 556 .ops = &snd_hda_bind_vol, 557 .values = { 558 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT), 559 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT), 560 0, 561 }, 562 }; 563 564 static struct hda_bind_ctls ad1986a_laptop_master_sw = { 565 .ops = &snd_hda_bind_sw, 566 .values = { 567 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT), 568 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT), 569 0, 570 }, 571 }; 572 573 static struct snd_kcontrol_new ad1986a_laptop_mixers[] = { 574 HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT), 575 HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT), 576 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol), 577 HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw), 578 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT), 579 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT), 580 HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT), 581 HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT), 582 HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT), 583 HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT), 584 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT), 585 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT), 586 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT), 587 /* HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x18, 0x0, HDA_OUTPUT), 588 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x18, 0x0, HDA_OUTPUT), 589 HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT), 590 HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT), */ 591 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT), 592 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT), 593 { 594 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 595 .name = "Capture Source", 596 .info = ad198x_mux_enum_info, 597 .get = ad198x_mux_enum_get, 598 .put = ad198x_mux_enum_put, 599 }, 600 { } /* end */ 601 }; 602 603 /* laptop-eapd model - 2ch only */ 604 605 static struct hda_input_mux ad1986a_laptop_eapd_capture_source = { 606 .num_items = 3, 607 .items = { 608 { "Mic", 0x0 }, 609 { "Internal Mic", 0x4 }, 610 { "Mix", 0x5 }, 611 }, 612 }; 613 614 static struct snd_kcontrol_new ad1986a_laptop_eapd_mixers[] = { 615 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol), 616 HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw), 617 HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT), 618 HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT), 619 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0x0, HDA_OUTPUT), 620 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0x0, HDA_OUTPUT), 621 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT), 622 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT), 623 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT), 624 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT), 625 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT), 626 { 627 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 628 .name = "Capture Source", 629 .info = ad198x_mux_enum_info, 630 .get = ad198x_mux_enum_get, 631 .put = ad198x_mux_enum_put, 632 }, 633 { 634 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 635 .name = "External Amplifier", 636 .info = ad198x_eapd_info, 637 .get = ad198x_eapd_get, 638 .put = ad198x_eapd_put, 639 .private_value = 0x1b | (1 << 8), /* port-D, inversed */ 640 }, 641 { } /* end */ 642 }; 643 644 /* laptop-automute - 2ch only */ 645 646 static void ad1986a_update_hp(struct hda_codec *codec) 647 { 648 struct ad198x_spec *spec = codec->spec; 649 unsigned int mute; 650 651 if (spec->jack_present) 652 mute = HDA_AMP_MUTE; /* mute internal speaker */ 653 else 654 /* unmute internal speaker if necessary */ 655 mute = snd_hda_codec_amp_read(codec, 0x1a, 0, HDA_OUTPUT, 0); 656 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 657 HDA_AMP_MUTE, mute); 658 } 659 660 static void ad1986a_hp_automute(struct hda_codec *codec) 661 { 662 struct ad198x_spec *spec = codec->spec; 663 unsigned int present; 664 665 present = snd_hda_codec_read(codec, 0x1a, 0, AC_VERB_GET_PIN_SENSE, 0); 666 /* Lenovo N100 seems to report the reversed bit for HP jack-sensing */ 667 spec->jack_present = !(present & 0x80000000); 668 ad1986a_update_hp(codec); 669 } 670 671 #define AD1986A_HP_EVENT 0x37 672 673 static void ad1986a_hp_unsol_event(struct hda_codec *codec, unsigned int res) 674 { 675 if ((res >> 26) != AD1986A_HP_EVENT) 676 return; 677 ad1986a_hp_automute(codec); 678 } 679 680 static int ad1986a_hp_init(struct hda_codec *codec) 681 { 682 ad198x_init(codec); 683 ad1986a_hp_automute(codec); 684 return 0; 685 } 686 687 /* bind hp and internal speaker mute (with plug check) */ 688 static int ad1986a_hp_master_sw_put(struct snd_kcontrol *kcontrol, 689 struct snd_ctl_elem_value *ucontrol) 690 { 691 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 692 long *valp = ucontrol->value.integer.value; 693 int change; 694 695 change = snd_hda_codec_amp_update(codec, 0x1a, 0, HDA_OUTPUT, 0, 696 HDA_AMP_MUTE, 697 valp[0] ? 0 : HDA_AMP_MUTE); 698 change |= snd_hda_codec_amp_update(codec, 0x1a, 1, HDA_OUTPUT, 0, 699 HDA_AMP_MUTE, 700 valp[1] ? 0 : HDA_AMP_MUTE); 701 if (change) 702 ad1986a_update_hp(codec); 703 return change; 704 } 705 706 static struct snd_kcontrol_new ad1986a_laptop_automute_mixers[] = { 707 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol), 708 { 709 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 710 .name = "Master Playback Switch", 711 .info = snd_hda_mixer_amp_switch_info, 712 .get = snd_hda_mixer_amp_switch_get, 713 .put = ad1986a_hp_master_sw_put, 714 .private_value = HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT), 715 }, 716 HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT), 717 HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT), 718 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0x0, HDA_OUTPUT), 719 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0x0, HDA_OUTPUT), 720 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT), 721 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT), 722 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT), 723 HDA_CODEC_VOLUME("Beep Playback Volume", 0x18, 0x0, HDA_OUTPUT), 724 HDA_CODEC_MUTE("Beep Playback Switch", 0x18, 0x0, HDA_OUTPUT), 725 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT), 726 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT), 727 { 728 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 729 .name = "Capture Source", 730 .info = ad198x_mux_enum_info, 731 .get = ad198x_mux_enum_get, 732 .put = ad198x_mux_enum_put, 733 }, 734 { 735 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 736 .name = "External Amplifier", 737 .info = ad198x_eapd_info, 738 .get = ad198x_eapd_get, 739 .put = ad198x_eapd_put, 740 .private_value = 0x1b | (1 << 8), /* port-D, inversed */ 741 }, 742 { } /* end */ 743 }; 744 745 /* 746 * initialization verbs 747 */ 748 static struct hda_verb ad1986a_init_verbs[] = { 749 /* Front, Surround, CLFE DAC; mute as default */ 750 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 751 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 752 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 753 /* Downmix - off */ 754 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 755 /* HP, Line-Out, Surround, CLFE selectors */ 756 {0x0a, AC_VERB_SET_CONNECT_SEL, 0x0}, 757 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0}, 758 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0}, 759 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0}, 760 /* Mono selector */ 761 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x0}, 762 /* Mic selector: Mic 1/2 pin */ 763 {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0}, 764 /* Line-in selector: Line-in */ 765 {0x10, AC_VERB_SET_CONNECT_SEL, 0x0}, 766 /* Mic 1/2 swap */ 767 {0x11, AC_VERB_SET_CONNECT_SEL, 0x0}, 768 /* Record selector: mic */ 769 {0x12, AC_VERB_SET_CONNECT_SEL, 0x0}, 770 /* Mic, Phone, CD, Aux, Line-In amp; mute as default */ 771 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 772 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 773 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 774 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 775 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 776 /* PC beep */ 777 {0x18, AC_VERB_SET_CONNECT_SEL, 0x0}, 778 /* HP, Line-Out, Surround, CLFE, Mono pins; mute as default */ 779 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 780 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 781 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 782 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 783 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 784 /* HP Pin */ 785 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 786 /* Front, Surround, CLFE Pins */ 787 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 788 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 789 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 790 /* Mono Pin */ 791 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 792 /* Mic Pin */ 793 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 794 /* Line, Aux, CD, Beep-In Pin */ 795 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 796 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 797 {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 798 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 799 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 800 { } /* end */ 801 }; 802 803 static struct hda_verb ad1986a_ch2_init[] = { 804 /* Surround out -> Line In */ 805 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 806 /* Line-in selectors */ 807 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x1 }, 808 /* CLFE -> Mic in */ 809 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 810 /* Mic selector, mix C/LFE (backmic) and Mic (frontmic) */ 811 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 }, 812 { } /* end */ 813 }; 814 815 static struct hda_verb ad1986a_ch4_init[] = { 816 /* Surround out -> Surround */ 817 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 818 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 }, 819 /* CLFE -> Mic in */ 820 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 821 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 }, 822 { } /* end */ 823 }; 824 825 static struct hda_verb ad1986a_ch6_init[] = { 826 /* Surround out -> Surround out */ 827 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 828 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 }, 829 /* CLFE -> CLFE */ 830 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 831 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x0 }, 832 { } /* end */ 833 }; 834 835 static struct hda_channel_mode ad1986a_modes[3] = { 836 { 2, ad1986a_ch2_init }, 837 { 4, ad1986a_ch4_init }, 838 { 6, ad1986a_ch6_init }, 839 }; 840 841 /* eapd initialization */ 842 static struct hda_verb ad1986a_eapd_init_verbs[] = { 843 {0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 }, 844 {} 845 }; 846 847 /* Ultra initialization */ 848 static struct hda_verb ad1986a_ultra_init[] = { 849 /* eapd initialization */ 850 { 0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 }, 851 /* CLFE -> Mic in */ 852 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2 }, 853 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 854 { 0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 }, 855 { } /* end */ 856 }; 857 858 /* pin sensing on HP jack */ 859 static struct hda_verb ad1986a_hp_init_verbs[] = { 860 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_HP_EVENT}, 861 {} 862 }; 863 864 865 /* models */ 866 enum { 867 AD1986A_6STACK, 868 AD1986A_3STACK, 869 AD1986A_LAPTOP, 870 AD1986A_LAPTOP_EAPD, 871 AD1986A_LAPTOP_AUTOMUTE, 872 AD1986A_ULTRA, 873 AD1986A_MODELS 874 }; 875 876 static const char *ad1986a_models[AD1986A_MODELS] = { 877 [AD1986A_6STACK] = "6stack", 878 [AD1986A_3STACK] = "3stack", 879 [AD1986A_LAPTOP] = "laptop", 880 [AD1986A_LAPTOP_EAPD] = "laptop-eapd", 881 [AD1986A_LAPTOP_AUTOMUTE] = "laptop-automute", 882 [AD1986A_ULTRA] = "ultra", 883 }; 884 885 static struct snd_pci_quirk ad1986a_cfg_tbl[] = { 886 SND_PCI_QUIRK(0x103c, 0x30af, "HP B2800", AD1986A_LAPTOP_EAPD), 887 SND_PCI_QUIRK(0x1043, 0x1153, "ASUS M9", AD1986A_LAPTOP_EAPD), 888 SND_PCI_QUIRK(0x1043, 0x11f7, "ASUS U5A", AD1986A_LAPTOP_EAPD), 889 SND_PCI_QUIRK(0x1043, 0x1213, "ASUS A6J", AD1986A_LAPTOP_EAPD), 890 SND_PCI_QUIRK(0x1043, 0x1263, "ASUS U5F", AD1986A_LAPTOP_EAPD), 891 SND_PCI_QUIRK(0x1043, 0x1297, "ASUS Z62F", AD1986A_LAPTOP_EAPD), 892 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS V1j", AD1986A_LAPTOP_EAPD), 893 SND_PCI_QUIRK(0x1043, 0x1302, "ASUS W3j", AD1986A_LAPTOP_EAPD), 894 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS VX1", AD1986A_LAPTOP), 895 SND_PCI_QUIRK(0x1043, 0x1447, "ASUS A8J", AD1986A_3STACK), 896 SND_PCI_QUIRK(0x1043, 0x817f, "ASUS P5", AD1986A_3STACK), 897 SND_PCI_QUIRK(0x1043, 0x818f, "ASUS P5", AD1986A_LAPTOP), 898 SND_PCI_QUIRK(0x1043, 0x81b3, "ASUS P5", AD1986A_3STACK), 899 SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS M2N", AD1986A_3STACK), 900 SND_PCI_QUIRK(0x1043, 0x8234, "ASUS M2N", AD1986A_3STACK), 901 SND_PCI_QUIRK(0x10de, 0xcb84, "ASUS A8N-VM", AD1986A_3STACK), 902 SND_PCI_QUIRK(0x1179, 0xff40, "Toshiba", AD1986A_LAPTOP_EAPD), 903 SND_PCI_QUIRK(0x144d, 0xb03c, "Samsung R55", AD1986A_3STACK), 904 SND_PCI_QUIRK(0x144d, 0xc01e, "FSC V2060", AD1986A_LAPTOP), 905 SND_PCI_QUIRK(0x144d, 0xc023, "Samsung X60", AD1986A_LAPTOP_EAPD), 906 SND_PCI_QUIRK(0x144d, 0xc024, "Samsung R65", AD1986A_LAPTOP_EAPD), 907 SND_PCI_QUIRK(0x144d, 0xc026, "Samsung X11", AD1986A_LAPTOP_EAPD), 908 SND_PCI_QUIRK(0x144d, 0xc027, "Samsung Q1", AD1986A_ULTRA), 909 SND_PCI_QUIRK(0x144d, 0xc504, "Samsung Q35", AD1986A_3STACK), 910 SND_PCI_QUIRK(0x17aa, 0x1011, "Lenovo M55", AD1986A_LAPTOP), 911 SND_PCI_QUIRK(0x17aa, 0x1017, "Lenovo A60", AD1986A_3STACK), 912 SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo N100", AD1986A_LAPTOP_AUTOMUTE), 913 SND_PCI_QUIRK(0x17c0, 0x2017, "Samsung M50", AD1986A_LAPTOP), 914 {} 915 }; 916 917 #ifdef CONFIG_SND_HDA_POWER_SAVE 918 static struct hda_amp_list ad1986a_loopbacks[] = { 919 { 0x13, HDA_OUTPUT, 0 }, /* Mic */ 920 { 0x14, HDA_OUTPUT, 0 }, /* Phone */ 921 { 0x15, HDA_OUTPUT, 0 }, /* CD */ 922 { 0x16, HDA_OUTPUT, 0 }, /* Aux */ 923 { 0x17, HDA_OUTPUT, 0 }, /* Line */ 924 { } /* end */ 925 }; 926 #endif 927 928 static int is_jack_available(struct hda_codec *codec, hda_nid_t nid) 929 { 930 unsigned int conf = snd_hda_codec_read(codec, nid, 0, 931 AC_VERB_GET_CONFIG_DEFAULT, 0); 932 return get_defcfg_connect(conf) != AC_JACK_PORT_NONE; 933 } 934 935 static int patch_ad1986a(struct hda_codec *codec) 936 { 937 struct ad198x_spec *spec; 938 int board_config; 939 940 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 941 if (spec == NULL) 942 return -ENOMEM; 943 944 codec->spec = spec; 945 946 spec->multiout.max_channels = 6; 947 spec->multiout.num_dacs = ARRAY_SIZE(ad1986a_dac_nids); 948 spec->multiout.dac_nids = ad1986a_dac_nids; 949 spec->multiout.dig_out_nid = AD1986A_SPDIF_OUT; 950 spec->num_adc_nids = 1; 951 spec->adc_nids = ad1986a_adc_nids; 952 spec->capsrc_nids = ad1986a_capsrc_nids; 953 spec->input_mux = &ad1986a_capture_source; 954 spec->num_mixers = 1; 955 spec->mixers[0] = ad1986a_mixers; 956 spec->num_init_verbs = 1; 957 spec->init_verbs[0] = ad1986a_init_verbs; 958 #ifdef CONFIG_SND_HDA_POWER_SAVE 959 spec->loopback.amplist = ad1986a_loopbacks; 960 #endif 961 spec->vmaster_nid = 0x1b; 962 963 codec->patch_ops = ad198x_patch_ops; 964 965 /* override some parameters */ 966 board_config = snd_hda_check_board_config(codec, AD1986A_MODELS, 967 ad1986a_models, 968 ad1986a_cfg_tbl); 969 switch (board_config) { 970 case AD1986A_3STACK: 971 spec->num_mixers = 2; 972 spec->mixers[1] = ad1986a_3st_mixers; 973 spec->num_init_verbs = 2; 974 spec->init_verbs[1] = ad1986a_ch2_init; 975 spec->channel_mode = ad1986a_modes; 976 spec->num_channel_mode = ARRAY_SIZE(ad1986a_modes); 977 spec->need_dac_fix = 1; 978 spec->multiout.max_channels = 2; 979 spec->multiout.num_dacs = 1; 980 break; 981 case AD1986A_LAPTOP: 982 spec->mixers[0] = ad1986a_laptop_mixers; 983 spec->multiout.max_channels = 2; 984 spec->multiout.num_dacs = 1; 985 spec->multiout.dac_nids = ad1986a_laptop_dac_nids; 986 break; 987 case AD1986A_LAPTOP_EAPD: 988 spec->mixers[0] = ad1986a_laptop_eapd_mixers; 989 spec->num_init_verbs = 2; 990 spec->init_verbs[1] = ad1986a_eapd_init_verbs; 991 spec->multiout.max_channels = 2; 992 spec->multiout.num_dacs = 1; 993 spec->multiout.dac_nids = ad1986a_laptop_dac_nids; 994 if (!is_jack_available(codec, 0x25)) 995 spec->multiout.dig_out_nid = 0; 996 spec->input_mux = &ad1986a_laptop_eapd_capture_source; 997 break; 998 case AD1986A_LAPTOP_AUTOMUTE: 999 spec->mixers[0] = ad1986a_laptop_automute_mixers; 1000 spec->num_init_verbs = 3; 1001 spec->init_verbs[1] = ad1986a_eapd_init_verbs; 1002 spec->init_verbs[2] = ad1986a_hp_init_verbs; 1003 spec->multiout.max_channels = 2; 1004 spec->multiout.num_dacs = 1; 1005 spec->multiout.dac_nids = ad1986a_laptop_dac_nids; 1006 if (!is_jack_available(codec, 0x25)) 1007 spec->multiout.dig_out_nid = 0; 1008 spec->input_mux = &ad1986a_laptop_eapd_capture_source; 1009 codec->patch_ops.unsol_event = ad1986a_hp_unsol_event; 1010 codec->patch_ops.init = ad1986a_hp_init; 1011 break; 1012 case AD1986A_ULTRA: 1013 spec->mixers[0] = ad1986a_laptop_eapd_mixers; 1014 spec->num_init_verbs = 2; 1015 spec->init_verbs[1] = ad1986a_ultra_init; 1016 spec->multiout.max_channels = 2; 1017 spec->multiout.num_dacs = 1; 1018 spec->multiout.dac_nids = ad1986a_laptop_dac_nids; 1019 spec->multiout.dig_out_nid = 0; 1020 break; 1021 } 1022 1023 /* AD1986A has a hardware problem that it can't share a stream 1024 * with multiple output pins. The copy of front to surrounds 1025 * causes noisy or silent outputs at a certain timing, e.g. 1026 * changing the volume. 1027 * So, let's disable the shared stream. 1028 */ 1029 spec->multiout.no_share_stream = 1; 1030 1031 return 0; 1032 } 1033 1034 /* 1035 * AD1983 specific 1036 */ 1037 1038 #define AD1983_SPDIF_OUT 0x02 1039 #define AD1983_DAC 0x03 1040 #define AD1983_ADC 0x04 1041 1042 static hda_nid_t ad1983_dac_nids[1] = { AD1983_DAC }; 1043 static hda_nid_t ad1983_adc_nids[1] = { AD1983_ADC }; 1044 static hda_nid_t ad1983_capsrc_nids[1] = { 0x15 }; 1045 1046 static struct hda_input_mux ad1983_capture_source = { 1047 .num_items = 4, 1048 .items = { 1049 { "Mic", 0x0 }, 1050 { "Line", 0x1 }, 1051 { "Mix", 0x2 }, 1052 { "Mix Mono", 0x3 }, 1053 }, 1054 }; 1055 1056 /* 1057 * SPDIF playback route 1058 */ 1059 static int ad1983_spdif_route_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 1060 { 1061 static char *texts[] = { "PCM", "ADC" }; 1062 1063 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 1064 uinfo->count = 1; 1065 uinfo->value.enumerated.items = 2; 1066 if (uinfo->value.enumerated.item > 1) 1067 uinfo->value.enumerated.item = 1; 1068 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 1069 return 0; 1070 } 1071 1072 static int ad1983_spdif_route_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1073 { 1074 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1075 struct ad198x_spec *spec = codec->spec; 1076 1077 ucontrol->value.enumerated.item[0] = spec->spdif_route; 1078 return 0; 1079 } 1080 1081 static int ad1983_spdif_route_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1082 { 1083 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1084 struct ad198x_spec *spec = codec->spec; 1085 1086 if (ucontrol->value.enumerated.item[0] > 1) 1087 return -EINVAL; 1088 if (spec->spdif_route != ucontrol->value.enumerated.item[0]) { 1089 spec->spdif_route = ucontrol->value.enumerated.item[0]; 1090 snd_hda_codec_write_cache(codec, spec->multiout.dig_out_nid, 0, 1091 AC_VERB_SET_CONNECT_SEL, 1092 spec->spdif_route); 1093 return 1; 1094 } 1095 return 0; 1096 } 1097 1098 static struct snd_kcontrol_new ad1983_mixers[] = { 1099 HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT), 1100 HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT), 1101 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT), 1102 HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT), 1103 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT), 1104 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT), 1105 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT), 1106 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT), 1107 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT), 1108 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT), 1109 HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT), 1110 HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT), 1111 HDA_CODEC_VOLUME_MONO("PC Speaker Playback Volume", 0x10, 1, 0x0, HDA_OUTPUT), 1112 HDA_CODEC_MUTE_MONO("PC Speaker Playback Switch", 0x10, 1, 0x0, HDA_OUTPUT), 1113 HDA_CODEC_VOLUME("Mic Boost", 0x0c, 0x0, HDA_OUTPUT), 1114 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT), 1115 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT), 1116 { 1117 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1118 .name = "Capture Source", 1119 .info = ad198x_mux_enum_info, 1120 .get = ad198x_mux_enum_get, 1121 .put = ad198x_mux_enum_put, 1122 }, 1123 { 1124 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1125 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source", 1126 .info = ad1983_spdif_route_info, 1127 .get = ad1983_spdif_route_get, 1128 .put = ad1983_spdif_route_put, 1129 }, 1130 { } /* end */ 1131 }; 1132 1133 static struct hda_verb ad1983_init_verbs[] = { 1134 /* Front, HP, Mono; mute as default */ 1135 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1136 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1137 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1138 /* Beep, PCM, Mic, Line-In: mute */ 1139 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1140 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1141 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1142 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1143 /* Front, HP selectors; from Mix */ 1144 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01}, 1145 {0x06, AC_VERB_SET_CONNECT_SEL, 0x01}, 1146 /* Mono selector; from Mix */ 1147 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03}, 1148 /* Mic selector; Mic */ 1149 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0}, 1150 /* Line-in selector: Line-in */ 1151 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0}, 1152 /* Mic boost: 0dB */ 1153 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 1154 /* Record selector: mic */ 1155 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0}, 1156 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1157 /* SPDIF route: PCM */ 1158 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, 1159 /* Front Pin */ 1160 {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 1161 /* HP Pin */ 1162 {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 1163 /* Mono Pin */ 1164 {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 1165 /* Mic Pin */ 1166 {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 1167 /* Line Pin */ 1168 {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 1169 { } /* end */ 1170 }; 1171 1172 #ifdef CONFIG_SND_HDA_POWER_SAVE 1173 static struct hda_amp_list ad1983_loopbacks[] = { 1174 { 0x12, HDA_OUTPUT, 0 }, /* Mic */ 1175 { 0x13, HDA_OUTPUT, 0 }, /* Line */ 1176 { } /* end */ 1177 }; 1178 #endif 1179 1180 static int patch_ad1983(struct hda_codec *codec) 1181 { 1182 struct ad198x_spec *spec; 1183 1184 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 1185 if (spec == NULL) 1186 return -ENOMEM; 1187 1188 codec->spec = spec; 1189 1190 spec->multiout.max_channels = 2; 1191 spec->multiout.num_dacs = ARRAY_SIZE(ad1983_dac_nids); 1192 spec->multiout.dac_nids = ad1983_dac_nids; 1193 spec->multiout.dig_out_nid = AD1983_SPDIF_OUT; 1194 spec->num_adc_nids = 1; 1195 spec->adc_nids = ad1983_adc_nids; 1196 spec->capsrc_nids = ad1983_capsrc_nids; 1197 spec->input_mux = &ad1983_capture_source; 1198 spec->num_mixers = 1; 1199 spec->mixers[0] = ad1983_mixers; 1200 spec->num_init_verbs = 1; 1201 spec->init_verbs[0] = ad1983_init_verbs; 1202 spec->spdif_route = 0; 1203 #ifdef CONFIG_SND_HDA_POWER_SAVE 1204 spec->loopback.amplist = ad1983_loopbacks; 1205 #endif 1206 spec->vmaster_nid = 0x05; 1207 1208 codec->patch_ops = ad198x_patch_ops; 1209 1210 return 0; 1211 } 1212 1213 1214 /* 1215 * AD1981 HD specific 1216 */ 1217 1218 #define AD1981_SPDIF_OUT 0x02 1219 #define AD1981_DAC 0x03 1220 #define AD1981_ADC 0x04 1221 1222 static hda_nid_t ad1981_dac_nids[1] = { AD1981_DAC }; 1223 static hda_nid_t ad1981_adc_nids[1] = { AD1981_ADC }; 1224 static hda_nid_t ad1981_capsrc_nids[1] = { 0x15 }; 1225 1226 /* 0x0c, 0x09, 0x0e, 0x0f, 0x19, 0x05, 0x18, 0x17 */ 1227 static struct hda_input_mux ad1981_capture_source = { 1228 .num_items = 7, 1229 .items = { 1230 { "Front Mic", 0x0 }, 1231 { "Line", 0x1 }, 1232 { "Mix", 0x2 }, 1233 { "Mix Mono", 0x3 }, 1234 { "CD", 0x4 }, 1235 { "Mic", 0x6 }, 1236 { "Aux", 0x7 }, 1237 }, 1238 }; 1239 1240 static struct snd_kcontrol_new ad1981_mixers[] = { 1241 HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT), 1242 HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT), 1243 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT), 1244 HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT), 1245 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT), 1246 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT), 1247 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT), 1248 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT), 1249 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT), 1250 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT), 1251 HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT), 1252 HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT), 1253 HDA_CODEC_VOLUME("Aux Playback Volume", 0x1b, 0x0, HDA_OUTPUT), 1254 HDA_CODEC_MUTE("Aux Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 1255 HDA_CODEC_VOLUME("Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT), 1256 HDA_CODEC_MUTE("Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT), 1257 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT), 1258 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT), 1259 HDA_CODEC_VOLUME_MONO("PC Speaker Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT), 1260 HDA_CODEC_MUTE_MONO("PC Speaker Playback Switch", 0x0d, 1, 0x0, HDA_OUTPUT), 1261 HDA_CODEC_VOLUME("Front Mic Boost", 0x08, 0x0, HDA_INPUT), 1262 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x0, HDA_INPUT), 1263 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT), 1264 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT), 1265 { 1266 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1267 .name = "Capture Source", 1268 .info = ad198x_mux_enum_info, 1269 .get = ad198x_mux_enum_get, 1270 .put = ad198x_mux_enum_put, 1271 }, 1272 /* identical with AD1983 */ 1273 { 1274 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1275 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source", 1276 .info = ad1983_spdif_route_info, 1277 .get = ad1983_spdif_route_get, 1278 .put = ad1983_spdif_route_put, 1279 }, 1280 { } /* end */ 1281 }; 1282 1283 static struct hda_verb ad1981_init_verbs[] = { 1284 /* Front, HP, Mono; mute as default */ 1285 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1286 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1287 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1288 /* Beep, PCM, Front Mic, Line, Rear Mic, Aux, CD-In: mute */ 1289 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1290 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1291 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1292 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1293 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1294 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1295 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1296 /* Front, HP selectors; from Mix */ 1297 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01}, 1298 {0x06, AC_VERB_SET_CONNECT_SEL, 0x01}, 1299 /* Mono selector; from Mix */ 1300 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03}, 1301 /* Mic Mixer; select Front Mic */ 1302 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 1303 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1304 /* Mic boost: 0dB */ 1305 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 1306 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 1307 /* Record selector: Front mic */ 1308 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0}, 1309 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1310 /* SPDIF route: PCM */ 1311 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, 1312 /* Front Pin */ 1313 {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 1314 /* HP Pin */ 1315 {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 1316 /* Mono Pin */ 1317 {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 1318 /* Front & Rear Mic Pins */ 1319 {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 1320 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 1321 /* Line Pin */ 1322 {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 1323 /* Digital Beep */ 1324 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00}, 1325 /* Line-Out as Input: disabled */ 1326 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1327 { } /* end */ 1328 }; 1329 1330 #ifdef CONFIG_SND_HDA_POWER_SAVE 1331 static struct hda_amp_list ad1981_loopbacks[] = { 1332 { 0x12, HDA_OUTPUT, 0 }, /* Front Mic */ 1333 { 0x13, HDA_OUTPUT, 0 }, /* Line */ 1334 { 0x1b, HDA_OUTPUT, 0 }, /* Aux */ 1335 { 0x1c, HDA_OUTPUT, 0 }, /* Mic */ 1336 { 0x1d, HDA_OUTPUT, 0 }, /* CD */ 1337 { } /* end */ 1338 }; 1339 #endif 1340 1341 /* 1342 * Patch for HP nx6320 1343 * 1344 * nx6320 uses EAPD in the reverse way - EAPD-on means the internal 1345 * speaker output enabled _and_ mute-LED off. 1346 */ 1347 1348 #define AD1981_HP_EVENT 0x37 1349 #define AD1981_MIC_EVENT 0x38 1350 1351 static struct hda_verb ad1981_hp_init_verbs[] = { 1352 {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x00 }, /* default off */ 1353 /* pin sensing on HP and Mic jacks */ 1354 {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT}, 1355 {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT}, 1356 {} 1357 }; 1358 1359 /* turn on/off EAPD (+ mute HP) as a master switch */ 1360 static int ad1981_hp_master_sw_put(struct snd_kcontrol *kcontrol, 1361 struct snd_ctl_elem_value *ucontrol) 1362 { 1363 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1364 struct ad198x_spec *spec = codec->spec; 1365 1366 if (! ad198x_eapd_put(kcontrol, ucontrol)) 1367 return 0; 1368 1369 /* toggle HP mute appropriately */ 1370 snd_hda_codec_amp_stereo(codec, 0x06, HDA_OUTPUT, 0, 1371 HDA_AMP_MUTE, 1372 spec->cur_eapd ? 0 : HDA_AMP_MUTE); 1373 return 1; 1374 } 1375 1376 /* bind volumes of both NID 0x05 and 0x06 */ 1377 static struct hda_bind_ctls ad1981_hp_bind_master_vol = { 1378 .ops = &snd_hda_bind_vol, 1379 .values = { 1380 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT), 1381 HDA_COMPOSE_AMP_VAL(0x06, 3, 0, HDA_OUTPUT), 1382 0 1383 }, 1384 }; 1385 1386 /* mute internal speaker if HP is plugged */ 1387 static void ad1981_hp_automute(struct hda_codec *codec) 1388 { 1389 unsigned int present; 1390 1391 present = snd_hda_codec_read(codec, 0x06, 0, 1392 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 1393 snd_hda_codec_amp_stereo(codec, 0x05, HDA_OUTPUT, 0, 1394 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 1395 } 1396 1397 /* toggle input of built-in and mic jack appropriately */ 1398 static void ad1981_hp_automic(struct hda_codec *codec) 1399 { 1400 static struct hda_verb mic_jack_on[] = { 1401 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1402 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 1403 {} 1404 }; 1405 static struct hda_verb mic_jack_off[] = { 1406 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1407 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 1408 {} 1409 }; 1410 unsigned int present; 1411 1412 present = snd_hda_codec_read(codec, 0x08, 0, 1413 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 1414 if (present) 1415 snd_hda_sequence_write(codec, mic_jack_on); 1416 else 1417 snd_hda_sequence_write(codec, mic_jack_off); 1418 } 1419 1420 /* unsolicited event for HP jack sensing */ 1421 static void ad1981_hp_unsol_event(struct hda_codec *codec, 1422 unsigned int res) 1423 { 1424 res >>= 26; 1425 switch (res) { 1426 case AD1981_HP_EVENT: 1427 ad1981_hp_automute(codec); 1428 break; 1429 case AD1981_MIC_EVENT: 1430 ad1981_hp_automic(codec); 1431 break; 1432 } 1433 } 1434 1435 static struct hda_input_mux ad1981_hp_capture_source = { 1436 .num_items = 3, 1437 .items = { 1438 { "Mic", 0x0 }, 1439 { "Docking-Station", 0x1 }, 1440 { "Mix", 0x2 }, 1441 }, 1442 }; 1443 1444 static struct snd_kcontrol_new ad1981_hp_mixers[] = { 1445 HDA_BIND_VOL("Master Playback Volume", &ad1981_hp_bind_master_vol), 1446 { 1447 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1448 .name = "Master Playback Switch", 1449 .info = ad198x_eapd_info, 1450 .get = ad198x_eapd_get, 1451 .put = ad1981_hp_master_sw_put, 1452 .private_value = 0x05, 1453 }, 1454 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT), 1455 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT), 1456 #if 0 1457 /* FIXME: analog mic/line loopback doesn't work with my tests... 1458 * (although recording is OK) 1459 */ 1460 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT), 1461 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT), 1462 HDA_CODEC_VOLUME("Docking-Station Playback Volume", 0x13, 0x0, HDA_OUTPUT), 1463 HDA_CODEC_MUTE("Docking-Station Playback Switch", 0x13, 0x0, HDA_OUTPUT), 1464 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT), 1465 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT), 1466 /* FIXME: does this laptop have analog CD connection? */ 1467 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT), 1468 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT), 1469 #endif 1470 HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT), 1471 HDA_CODEC_VOLUME("Internal Mic Boost", 0x18, 0x0, HDA_INPUT), 1472 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT), 1473 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT), 1474 { 1475 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1476 .name = "Capture Source", 1477 .info = ad198x_mux_enum_info, 1478 .get = ad198x_mux_enum_get, 1479 .put = ad198x_mux_enum_put, 1480 }, 1481 { } /* end */ 1482 }; 1483 1484 /* initialize jack-sensing, too */ 1485 static int ad1981_hp_init(struct hda_codec *codec) 1486 { 1487 ad198x_init(codec); 1488 ad1981_hp_automute(codec); 1489 ad1981_hp_automic(codec); 1490 return 0; 1491 } 1492 1493 /* configuration for Toshiba Laptops */ 1494 static struct hda_verb ad1981_toshiba_init_verbs[] = { 1495 {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x01 }, /* default on */ 1496 /* pin sensing on HP and Mic jacks */ 1497 {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT}, 1498 {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT}, 1499 {} 1500 }; 1501 1502 static struct snd_kcontrol_new ad1981_toshiba_mixers[] = { 1503 HDA_CODEC_VOLUME("Amp Volume", 0x1a, 0x0, HDA_OUTPUT), 1504 HDA_CODEC_MUTE("Amp Switch", 0x1a, 0x0, HDA_OUTPUT), 1505 { } 1506 }; 1507 1508 /* configuration for Lenovo Thinkpad T60 */ 1509 static struct snd_kcontrol_new ad1981_thinkpad_mixers[] = { 1510 HDA_CODEC_VOLUME("Master Playback Volume", 0x05, 0x0, HDA_OUTPUT), 1511 HDA_CODEC_MUTE("Master Playback Switch", 0x05, 0x0, HDA_OUTPUT), 1512 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT), 1513 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT), 1514 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT), 1515 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT), 1516 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT), 1517 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT), 1518 HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT), 1519 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT), 1520 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT), 1521 { 1522 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1523 .name = "Capture Source", 1524 .info = ad198x_mux_enum_info, 1525 .get = ad198x_mux_enum_get, 1526 .put = ad198x_mux_enum_put, 1527 }, 1528 /* identical with AD1983 */ 1529 { 1530 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1531 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source", 1532 .info = ad1983_spdif_route_info, 1533 .get = ad1983_spdif_route_get, 1534 .put = ad1983_spdif_route_put, 1535 }, 1536 { } /* end */ 1537 }; 1538 1539 static struct hda_input_mux ad1981_thinkpad_capture_source = { 1540 .num_items = 3, 1541 .items = { 1542 { "Mic", 0x0 }, 1543 { "Mix", 0x2 }, 1544 { "CD", 0x4 }, 1545 }, 1546 }; 1547 1548 /* models */ 1549 enum { 1550 AD1981_BASIC, 1551 AD1981_HP, 1552 AD1981_THINKPAD, 1553 AD1981_TOSHIBA, 1554 AD1981_MODELS 1555 }; 1556 1557 static const char *ad1981_models[AD1981_MODELS] = { 1558 [AD1981_HP] = "hp", 1559 [AD1981_THINKPAD] = "thinkpad", 1560 [AD1981_BASIC] = "basic", 1561 [AD1981_TOSHIBA] = "toshiba" 1562 }; 1563 1564 static struct snd_pci_quirk ad1981_cfg_tbl[] = { 1565 SND_PCI_QUIRK(0x1014, 0x0597, "Lenovo Z60", AD1981_THINKPAD), 1566 /* All HP models */ 1567 SND_PCI_QUIRK(0x103c, 0, "HP nx", AD1981_HP), 1568 SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba U205", AD1981_TOSHIBA), 1569 /* Lenovo Thinkpad T60/X60/Z6xx */ 1570 SND_PCI_QUIRK(0x17aa, 0, "Lenovo Thinkpad", AD1981_THINKPAD), 1571 /* HP nx6320 (reversed SSID, H/W bug) */ 1572 SND_PCI_QUIRK(0x30b0, 0x103c, "HP nx6320", AD1981_HP), 1573 {} 1574 }; 1575 1576 static int patch_ad1981(struct hda_codec *codec) 1577 { 1578 struct ad198x_spec *spec; 1579 int board_config; 1580 1581 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 1582 if (spec == NULL) 1583 return -ENOMEM; 1584 1585 codec->spec = spec; 1586 1587 spec->multiout.max_channels = 2; 1588 spec->multiout.num_dacs = ARRAY_SIZE(ad1981_dac_nids); 1589 spec->multiout.dac_nids = ad1981_dac_nids; 1590 spec->multiout.dig_out_nid = AD1981_SPDIF_OUT; 1591 spec->num_adc_nids = 1; 1592 spec->adc_nids = ad1981_adc_nids; 1593 spec->capsrc_nids = ad1981_capsrc_nids; 1594 spec->input_mux = &ad1981_capture_source; 1595 spec->num_mixers = 1; 1596 spec->mixers[0] = ad1981_mixers; 1597 spec->num_init_verbs = 1; 1598 spec->init_verbs[0] = ad1981_init_verbs; 1599 spec->spdif_route = 0; 1600 #ifdef CONFIG_SND_HDA_POWER_SAVE 1601 spec->loopback.amplist = ad1981_loopbacks; 1602 #endif 1603 spec->vmaster_nid = 0x05; 1604 1605 codec->patch_ops = ad198x_patch_ops; 1606 1607 /* override some parameters */ 1608 board_config = snd_hda_check_board_config(codec, AD1981_MODELS, 1609 ad1981_models, 1610 ad1981_cfg_tbl); 1611 switch (board_config) { 1612 case AD1981_HP: 1613 spec->mixers[0] = ad1981_hp_mixers; 1614 spec->num_init_verbs = 2; 1615 spec->init_verbs[1] = ad1981_hp_init_verbs; 1616 spec->multiout.dig_out_nid = 0; 1617 spec->input_mux = &ad1981_hp_capture_source; 1618 1619 codec->patch_ops.init = ad1981_hp_init; 1620 codec->patch_ops.unsol_event = ad1981_hp_unsol_event; 1621 break; 1622 case AD1981_THINKPAD: 1623 spec->mixers[0] = ad1981_thinkpad_mixers; 1624 spec->input_mux = &ad1981_thinkpad_capture_source; 1625 break; 1626 case AD1981_TOSHIBA: 1627 spec->mixers[0] = ad1981_hp_mixers; 1628 spec->mixers[1] = ad1981_toshiba_mixers; 1629 spec->num_init_verbs = 2; 1630 spec->init_verbs[1] = ad1981_toshiba_init_verbs; 1631 spec->multiout.dig_out_nid = 0; 1632 spec->input_mux = &ad1981_hp_capture_source; 1633 codec->patch_ops.init = ad1981_hp_init; 1634 codec->patch_ops.unsol_event = ad1981_hp_unsol_event; 1635 break; 1636 } 1637 return 0; 1638 } 1639 1640 1641 /* 1642 * AD1988 1643 * 1644 * Output pins and routes 1645 * 1646 * Pin Mix Sel DAC (*) 1647 * port-A 0x11 (mute/hp) <- 0x22 <- 0x37 <- 03/04/06 1648 * port-B 0x14 (mute/hp) <- 0x2b <- 0x30 <- 03/04/06 1649 * port-C 0x15 (mute) <- 0x2c <- 0x31 <- 05/0a 1650 * port-D 0x12 (mute/hp) <- 0x29 <- 04 1651 * port-E 0x17 (mute/hp) <- 0x26 <- 0x32 <- 05/0a 1652 * port-F 0x16 (mute) <- 0x2a <- 06 1653 * port-G 0x24 (mute) <- 0x27 <- 05 1654 * port-H 0x25 (mute) <- 0x28 <- 0a 1655 * mono 0x13 (mute/amp)<- 0x1e <- 0x36 <- 03/04/06 1656 * 1657 * DAC0 = 03h, DAC1 = 04h, DAC2 = 05h, DAC3 = 06h, DAC4 = 0ah 1658 * (*) DAC2/3/4 are swapped to DAC3/4/2 on AD198A rev.2 due to a h/w bug. 1659 * 1660 * Input pins and routes 1661 * 1662 * pin boost mix input # / adc input # 1663 * port-A 0x11 -> 0x38 -> mix 2, ADC 0 1664 * port-B 0x14 -> 0x39 -> mix 0, ADC 1 1665 * port-C 0x15 -> 0x3a -> 33:0 - mix 1, ADC 2 1666 * port-D 0x12 -> 0x3d -> mix 3, ADC 8 1667 * port-E 0x17 -> 0x3c -> 34:0 - mix 4, ADC 4 1668 * port-F 0x16 -> 0x3b -> mix 5, ADC 3 1669 * port-G 0x24 -> N/A -> 33:1 - mix 1, 34:1 - mix 4, ADC 6 1670 * port-H 0x25 -> N/A -> 33:2 - mix 1, 34:2 - mix 4, ADC 7 1671 * 1672 * 1673 * DAC assignment 1674 * 6stack - front/surr/CLFE/side/opt DACs - 04/06/05/0a/03 1675 * 3stack - front/surr/CLFE/opt DACs - 04/05/0a/03 1676 * 1677 * Inputs of Analog Mix (0x20) 1678 * 0:Port-B (front mic) 1679 * 1:Port-C/G/H (line-in) 1680 * 2:Port-A 1681 * 3:Port-D (line-in/2) 1682 * 4:Port-E/G/H (mic-in) 1683 * 5:Port-F (mic2-in) 1684 * 6:CD 1685 * 7:Beep 1686 * 1687 * ADC selection 1688 * 0:Port-A 1689 * 1:Port-B (front mic-in) 1690 * 2:Port-C (line-in) 1691 * 3:Port-F (mic2-in) 1692 * 4:Port-E (mic-in) 1693 * 5:CD 1694 * 6:Port-G 1695 * 7:Port-H 1696 * 8:Port-D (line-in/2) 1697 * 9:Mix 1698 * 1699 * Proposed pin assignments by the datasheet 1700 * 1701 * 6-stack 1702 * Port-A front headphone 1703 * B front mic-in 1704 * C rear line-in 1705 * D rear front-out 1706 * E rear mic-in 1707 * F rear surround 1708 * G rear CLFE 1709 * H rear side 1710 * 1711 * 3-stack 1712 * Port-A front headphone 1713 * B front mic 1714 * C rear line-in/surround 1715 * D rear front-out 1716 * E rear mic-in/CLFE 1717 * 1718 * laptop 1719 * Port-A headphone 1720 * B mic-in 1721 * C docking station 1722 * D internal speaker (with EAPD) 1723 * E/F quad mic array 1724 */ 1725 1726 1727 /* models */ 1728 enum { 1729 AD1988_6STACK, 1730 AD1988_6STACK_DIG, 1731 AD1988_3STACK, 1732 AD1988_3STACK_DIG, 1733 AD1988_LAPTOP, 1734 AD1988_LAPTOP_DIG, 1735 AD1988_AUTO, 1736 AD1988_MODEL_LAST, 1737 }; 1738 1739 /* reivision id to check workarounds */ 1740 #define AD1988A_REV2 0x100200 1741 1742 #define is_rev2(codec) \ 1743 ((codec)->vendor_id == 0x11d41988 && \ 1744 (codec)->revision_id == AD1988A_REV2) 1745 1746 /* 1747 * mixers 1748 */ 1749 1750 static hda_nid_t ad1988_6stack_dac_nids[4] = { 1751 0x04, 0x06, 0x05, 0x0a 1752 }; 1753 1754 static hda_nid_t ad1988_3stack_dac_nids[3] = { 1755 0x04, 0x05, 0x0a 1756 }; 1757 1758 /* for AD1988A revision-2, DAC2-4 are swapped */ 1759 static hda_nid_t ad1988_6stack_dac_nids_rev2[4] = { 1760 0x04, 0x05, 0x0a, 0x06 1761 }; 1762 1763 static hda_nid_t ad1988_3stack_dac_nids_rev2[3] = { 1764 0x04, 0x0a, 0x06 1765 }; 1766 1767 static hda_nid_t ad1988_adc_nids[3] = { 1768 0x08, 0x09, 0x0f 1769 }; 1770 1771 static hda_nid_t ad1988_capsrc_nids[3] = { 1772 0x0c, 0x0d, 0x0e 1773 }; 1774 1775 #define AD1988_SPDIF_OUT 0x02 1776 #define AD1988_SPDIF_IN 0x07 1777 1778 static struct hda_input_mux ad1988_6stack_capture_source = { 1779 .num_items = 5, 1780 .items = { 1781 { "Front Mic", 0x1 }, /* port-B */ 1782 { "Line", 0x2 }, /* port-C */ 1783 { "Mic", 0x4 }, /* port-E */ 1784 { "CD", 0x5 }, 1785 { "Mix", 0x9 }, 1786 }, 1787 }; 1788 1789 static struct hda_input_mux ad1988_laptop_capture_source = { 1790 .num_items = 3, 1791 .items = { 1792 { "Mic/Line", 0x1 }, /* port-B */ 1793 { "CD", 0x5 }, 1794 { "Mix", 0x9 }, 1795 }, 1796 }; 1797 1798 /* 1799 */ 1800 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol, 1801 struct snd_ctl_elem_info *uinfo) 1802 { 1803 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1804 struct ad198x_spec *spec = codec->spec; 1805 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode, 1806 spec->num_channel_mode); 1807 } 1808 1809 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol, 1810 struct snd_ctl_elem_value *ucontrol) 1811 { 1812 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1813 struct ad198x_spec *spec = codec->spec; 1814 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode, 1815 spec->num_channel_mode, spec->multiout.max_channels); 1816 } 1817 1818 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol, 1819 struct snd_ctl_elem_value *ucontrol) 1820 { 1821 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1822 struct ad198x_spec *spec = codec->spec; 1823 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode, 1824 spec->num_channel_mode, 1825 &spec->multiout.max_channels); 1826 if (err >= 0 && spec->need_dac_fix) 1827 spec->multiout.num_dacs = spec->multiout.max_channels / 2; 1828 return err; 1829 } 1830 1831 /* 6-stack mode */ 1832 static struct snd_kcontrol_new ad1988_6stack_mixers1[] = { 1833 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT), 1834 HDA_CODEC_VOLUME("Surround Playback Volume", 0x06, 0x0, HDA_OUTPUT), 1835 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT), 1836 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT), 1837 HDA_CODEC_VOLUME("Side Playback Volume", 0x0a, 0x0, HDA_OUTPUT), 1838 { } /* end */ 1839 }; 1840 1841 static struct snd_kcontrol_new ad1988_6stack_mixers1_rev2[] = { 1842 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT), 1843 HDA_CODEC_VOLUME("Surround Playback Volume", 0x05, 0x0, HDA_OUTPUT), 1844 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT), 1845 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0a, 2, 0x0, HDA_OUTPUT), 1846 HDA_CODEC_VOLUME("Side Playback Volume", 0x06, 0x0, HDA_OUTPUT), 1847 { } /* end */ 1848 }; 1849 1850 static struct snd_kcontrol_new ad1988_6stack_mixers2[] = { 1851 HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT), 1852 HDA_BIND_MUTE("Surround Playback Switch", 0x2a, 2, HDA_INPUT), 1853 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x27, 1, 2, HDA_INPUT), 1854 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x27, 2, 2, HDA_INPUT), 1855 HDA_BIND_MUTE("Side Playback Switch", 0x28, 2, HDA_INPUT), 1856 HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT), 1857 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT), 1858 1859 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT), 1860 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT), 1861 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT), 1862 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT), 1863 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT), 1864 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT), 1865 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT), 1866 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT), 1867 1868 HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT), 1869 HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT), 1870 1871 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT), 1872 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT), 1873 1874 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT), 1875 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT), 1876 1877 { } /* end */ 1878 }; 1879 1880 /* 3-stack mode */ 1881 static struct snd_kcontrol_new ad1988_3stack_mixers1[] = { 1882 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT), 1883 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT), 1884 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT), 1885 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT), 1886 { } /* end */ 1887 }; 1888 1889 static struct snd_kcontrol_new ad1988_3stack_mixers1_rev2[] = { 1890 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT), 1891 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT), 1892 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x06, 1, 0x0, HDA_OUTPUT), 1893 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x06, 2, 0x0, HDA_OUTPUT), 1894 { } /* end */ 1895 }; 1896 1897 static struct snd_kcontrol_new ad1988_3stack_mixers2[] = { 1898 HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT), 1899 HDA_BIND_MUTE("Surround Playback Switch", 0x2c, 2, HDA_INPUT), 1900 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x26, 1, 2, HDA_INPUT), 1901 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x26, 2, 2, HDA_INPUT), 1902 HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT), 1903 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT), 1904 1905 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT), 1906 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT), 1907 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT), 1908 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT), 1909 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT), 1910 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT), 1911 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT), 1912 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT), 1913 1914 HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT), 1915 HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT), 1916 1917 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT), 1918 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT), 1919 1920 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT), 1921 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT), 1922 { 1923 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1924 .name = "Channel Mode", 1925 .info = ad198x_ch_mode_info, 1926 .get = ad198x_ch_mode_get, 1927 .put = ad198x_ch_mode_put, 1928 }, 1929 1930 { } /* end */ 1931 }; 1932 1933 /* laptop mode */ 1934 static struct snd_kcontrol_new ad1988_laptop_mixers[] = { 1935 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT), 1936 HDA_CODEC_MUTE("PCM Playback Switch", 0x29, 0x0, HDA_INPUT), 1937 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT), 1938 1939 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT), 1940 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT), 1941 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x0, HDA_INPUT), 1942 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x0, HDA_INPUT), 1943 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT), 1944 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT), 1945 1946 HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT), 1947 HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT), 1948 1949 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT), 1950 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT), 1951 1952 HDA_CODEC_VOLUME("Mic Boost", 0x39, 0x0, HDA_OUTPUT), 1953 1954 { 1955 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1956 .name = "External Amplifier", 1957 .info = ad198x_eapd_info, 1958 .get = ad198x_eapd_get, 1959 .put = ad198x_eapd_put, 1960 .private_value = 0x12 | (1 << 8), /* port-D, inversed */ 1961 }, 1962 1963 { } /* end */ 1964 }; 1965 1966 /* capture */ 1967 static struct snd_kcontrol_new ad1988_capture_mixers[] = { 1968 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT), 1969 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT), 1970 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT), 1971 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT), 1972 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x0e, 0x0, HDA_OUTPUT), 1973 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x0e, 0x0, HDA_OUTPUT), 1974 { 1975 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1976 /* The multiple "Capture Source" controls confuse alsamixer 1977 * So call somewhat different.. 1978 */ 1979 /* .name = "Capture Source", */ 1980 .name = "Input Source", 1981 .count = 3, 1982 .info = ad198x_mux_enum_info, 1983 .get = ad198x_mux_enum_get, 1984 .put = ad198x_mux_enum_put, 1985 }, 1986 { } /* end */ 1987 }; 1988 1989 static int ad1988_spdif_playback_source_info(struct snd_kcontrol *kcontrol, 1990 struct snd_ctl_elem_info *uinfo) 1991 { 1992 static char *texts[] = { 1993 "PCM", "ADC1", "ADC2", "ADC3" 1994 }; 1995 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 1996 uinfo->count = 1; 1997 uinfo->value.enumerated.items = 4; 1998 if (uinfo->value.enumerated.item >= 4) 1999 uinfo->value.enumerated.item = 3; 2000 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 2001 return 0; 2002 } 2003 2004 static int ad1988_spdif_playback_source_get(struct snd_kcontrol *kcontrol, 2005 struct snd_ctl_elem_value *ucontrol) 2006 { 2007 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2008 unsigned int sel; 2009 2010 sel = snd_hda_codec_read(codec, 0x1d, 0, AC_VERB_GET_AMP_GAIN_MUTE, 2011 AC_AMP_GET_INPUT); 2012 if (!(sel & 0x80)) 2013 ucontrol->value.enumerated.item[0] = 0; 2014 else { 2015 sel = snd_hda_codec_read(codec, 0x0b, 0, 2016 AC_VERB_GET_CONNECT_SEL, 0); 2017 if (sel < 3) 2018 sel++; 2019 else 2020 sel = 0; 2021 ucontrol->value.enumerated.item[0] = sel; 2022 } 2023 return 0; 2024 } 2025 2026 static int ad1988_spdif_playback_source_put(struct snd_kcontrol *kcontrol, 2027 struct snd_ctl_elem_value *ucontrol) 2028 { 2029 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2030 unsigned int val, sel; 2031 int change; 2032 2033 val = ucontrol->value.enumerated.item[0]; 2034 if (val > 3) 2035 return -EINVAL; 2036 if (!val) { 2037 sel = snd_hda_codec_read(codec, 0x1d, 0, 2038 AC_VERB_GET_AMP_GAIN_MUTE, 2039 AC_AMP_GET_INPUT); 2040 change = sel & 0x80; 2041 if (change) { 2042 snd_hda_codec_write_cache(codec, 0x1d, 0, 2043 AC_VERB_SET_AMP_GAIN_MUTE, 2044 AMP_IN_UNMUTE(0)); 2045 snd_hda_codec_write_cache(codec, 0x1d, 0, 2046 AC_VERB_SET_AMP_GAIN_MUTE, 2047 AMP_IN_MUTE(1)); 2048 } 2049 } else { 2050 sel = snd_hda_codec_read(codec, 0x1d, 0, 2051 AC_VERB_GET_AMP_GAIN_MUTE, 2052 AC_AMP_GET_INPUT | 0x01); 2053 change = sel & 0x80; 2054 if (change) { 2055 snd_hda_codec_write_cache(codec, 0x1d, 0, 2056 AC_VERB_SET_AMP_GAIN_MUTE, 2057 AMP_IN_MUTE(0)); 2058 snd_hda_codec_write_cache(codec, 0x1d, 0, 2059 AC_VERB_SET_AMP_GAIN_MUTE, 2060 AMP_IN_UNMUTE(1)); 2061 } 2062 sel = snd_hda_codec_read(codec, 0x0b, 0, 2063 AC_VERB_GET_CONNECT_SEL, 0) + 1; 2064 change |= sel != val; 2065 if (change) 2066 snd_hda_codec_write_cache(codec, 0x0b, 0, 2067 AC_VERB_SET_CONNECT_SEL, 2068 val - 1); 2069 } 2070 return change; 2071 } 2072 2073 static struct snd_kcontrol_new ad1988_spdif_out_mixers[] = { 2074 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT), 2075 { 2076 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2077 .name = "IEC958 Playback Source", 2078 .info = ad1988_spdif_playback_source_info, 2079 .get = ad1988_spdif_playback_source_get, 2080 .put = ad1988_spdif_playback_source_put, 2081 }, 2082 { } /* end */ 2083 }; 2084 2085 static struct snd_kcontrol_new ad1988_spdif_in_mixers[] = { 2086 HDA_CODEC_VOLUME("IEC958 Capture Volume", 0x1c, 0x0, HDA_INPUT), 2087 { } /* end */ 2088 }; 2089 2090 2091 /* 2092 * initialization verbs 2093 */ 2094 2095 /* 2096 * for 6-stack (+dig) 2097 */ 2098 static struct hda_verb ad1988_6stack_init_verbs[] = { 2099 /* Front, Surround, CLFE, side DAC; unmute as default */ 2100 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2101 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2102 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2103 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2104 /* Port-A front headphon path */ 2105 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */ 2106 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2107 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2108 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2109 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2110 /* Port-D line-out path */ 2111 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2112 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2113 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2114 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2115 /* Port-F surround path */ 2116 {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2117 {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2118 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2119 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2120 /* Port-G CLFE path */ 2121 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2122 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2123 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2124 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2125 /* Port-H side path */ 2126 {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2127 {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2128 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2129 {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2130 /* Mono out path */ 2131 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */ 2132 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2133 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2134 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2135 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */ 2136 /* Port-B front mic-in path */ 2137 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2138 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2139 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2140 /* Port-C line-in path */ 2141 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2142 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2143 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2144 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0}, 2145 /* Port-E mic-in path */ 2146 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2147 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2148 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2149 {0x34, AC_VERB_SET_CONNECT_SEL, 0x0}, 2150 /* Analog CD Input */ 2151 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2152 2153 { } 2154 }; 2155 2156 static struct hda_verb ad1988_capture_init_verbs[] = { 2157 /* mute analog mix */ 2158 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2159 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2160 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 2161 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 2162 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 2163 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 2164 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 2165 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 2166 /* select ADCs - front-mic */ 2167 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1}, 2168 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1}, 2169 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1}, 2170 /* ADCs; muted */ 2171 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2172 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2173 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2174 2175 { } 2176 }; 2177 2178 static struct hda_verb ad1988_spdif_init_verbs[] = { 2179 /* SPDIF out sel */ 2180 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */ 2181 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0}, /* ADC1 */ 2182 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2183 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2184 /* SPDIF out pin */ 2185 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */ 2186 2187 { } 2188 }; 2189 2190 /* 2191 * verbs for 3stack (+dig) 2192 */ 2193 static struct hda_verb ad1988_3stack_ch2_init[] = { 2194 /* set port-C to line-in */ 2195 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 2196 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 2197 /* set port-E to mic-in */ 2198 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 2199 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 2200 { } /* end */ 2201 }; 2202 2203 static struct hda_verb ad1988_3stack_ch6_init[] = { 2204 /* set port-C to surround out */ 2205 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 2206 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 2207 /* set port-E to CLFE out */ 2208 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 2209 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 2210 { } /* end */ 2211 }; 2212 2213 static struct hda_channel_mode ad1988_3stack_modes[2] = { 2214 { 2, ad1988_3stack_ch2_init }, 2215 { 6, ad1988_3stack_ch6_init }, 2216 }; 2217 2218 static struct hda_verb ad1988_3stack_init_verbs[] = { 2219 /* Front, Surround, CLFE, side DAC; unmute as default */ 2220 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2221 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2222 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2223 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2224 /* Port-A front headphon path */ 2225 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */ 2226 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2227 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2228 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2229 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2230 /* Port-D line-out path */ 2231 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2232 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2233 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2234 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2235 /* Mono out path */ 2236 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */ 2237 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2238 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2239 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2240 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */ 2241 /* Port-B front mic-in path */ 2242 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2243 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2244 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2245 /* Port-C line-in/surround path - 6ch mode as default */ 2246 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2247 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2248 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2249 {0x31, AC_VERB_SET_CONNECT_SEL, 0x0}, /* output sel: DAC 0x05 */ 2250 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0}, 2251 /* Port-E mic-in/CLFE path - 6ch mode as default */ 2252 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2253 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2254 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2255 {0x32, AC_VERB_SET_CONNECT_SEL, 0x1}, /* output sel: DAC 0x0a */ 2256 {0x34, AC_VERB_SET_CONNECT_SEL, 0x0}, 2257 /* mute analog mix */ 2258 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2259 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2260 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 2261 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 2262 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 2263 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 2264 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 2265 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 2266 /* select ADCs - front-mic */ 2267 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1}, 2268 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1}, 2269 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1}, 2270 /* ADCs; muted */ 2271 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2272 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2273 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2274 { } 2275 }; 2276 2277 /* 2278 * verbs for laptop mode (+dig) 2279 */ 2280 static struct hda_verb ad1988_laptop_hp_on[] = { 2281 /* unmute port-A and mute port-D */ 2282 { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 2283 { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 2284 { } /* end */ 2285 }; 2286 static struct hda_verb ad1988_laptop_hp_off[] = { 2287 /* mute port-A and unmute port-D */ 2288 { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 2289 { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 2290 { } /* end */ 2291 }; 2292 2293 #define AD1988_HP_EVENT 0x01 2294 2295 static struct hda_verb ad1988_laptop_init_verbs[] = { 2296 /* Front, Surround, CLFE, side DAC; unmute as default */ 2297 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2298 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2299 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2300 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2301 /* Port-A front headphon path */ 2302 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */ 2303 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2304 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2305 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2306 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2307 /* unsolicited event for pin-sense */ 2308 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1988_HP_EVENT }, 2309 /* Port-D line-out path + EAPD */ 2310 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2311 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2312 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2313 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2314 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x00}, /* EAPD-off */ 2315 /* Mono out path */ 2316 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */ 2317 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2318 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2319 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2320 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */ 2321 /* Port-B mic-in path */ 2322 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2323 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2324 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2325 /* Port-C docking station - try to output */ 2326 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2327 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2328 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2329 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0}, 2330 /* mute analog mix */ 2331 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2332 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2333 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 2334 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 2335 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 2336 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 2337 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 2338 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 2339 /* select ADCs - mic */ 2340 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1}, 2341 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1}, 2342 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1}, 2343 /* ADCs; muted */ 2344 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2345 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2346 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2347 { } 2348 }; 2349 2350 static void ad1988_laptop_unsol_event(struct hda_codec *codec, unsigned int res) 2351 { 2352 if ((res >> 26) != AD1988_HP_EVENT) 2353 return; 2354 if (snd_hda_codec_read(codec, 0x11, 0, AC_VERB_GET_PIN_SENSE, 0) & (1 << 31)) 2355 snd_hda_sequence_write(codec, ad1988_laptop_hp_on); 2356 else 2357 snd_hda_sequence_write(codec, ad1988_laptop_hp_off); 2358 } 2359 2360 #ifdef CONFIG_SND_HDA_POWER_SAVE 2361 static struct hda_amp_list ad1988_loopbacks[] = { 2362 { 0x20, HDA_INPUT, 0 }, /* Front Mic */ 2363 { 0x20, HDA_INPUT, 1 }, /* Line */ 2364 { 0x20, HDA_INPUT, 4 }, /* Mic */ 2365 { 0x20, HDA_INPUT, 6 }, /* CD */ 2366 { } /* end */ 2367 }; 2368 #endif 2369 2370 /* 2371 * Automatic parse of I/O pins from the BIOS configuration 2372 */ 2373 2374 #define NUM_CONTROL_ALLOC 32 2375 #define NUM_VERB_ALLOC 32 2376 2377 enum { 2378 AD_CTL_WIDGET_VOL, 2379 AD_CTL_WIDGET_MUTE, 2380 AD_CTL_BIND_MUTE, 2381 }; 2382 static struct snd_kcontrol_new ad1988_control_templates[] = { 2383 HDA_CODEC_VOLUME(NULL, 0, 0, 0), 2384 HDA_CODEC_MUTE(NULL, 0, 0, 0), 2385 HDA_BIND_MUTE(NULL, 0, 0, 0), 2386 }; 2387 2388 /* add dynamic controls */ 2389 static int add_control(struct ad198x_spec *spec, int type, const char *name, 2390 unsigned long val) 2391 { 2392 struct snd_kcontrol_new *knew; 2393 2394 if (spec->num_kctl_used >= spec->num_kctl_alloc) { 2395 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC; 2396 2397 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */ 2398 if (! knew) 2399 return -ENOMEM; 2400 if (spec->kctl_alloc) { 2401 memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc); 2402 kfree(spec->kctl_alloc); 2403 } 2404 spec->kctl_alloc = knew; 2405 spec->num_kctl_alloc = num; 2406 } 2407 2408 knew = &spec->kctl_alloc[spec->num_kctl_used]; 2409 *knew = ad1988_control_templates[type]; 2410 knew->name = kstrdup(name, GFP_KERNEL); 2411 if (! knew->name) 2412 return -ENOMEM; 2413 knew->private_value = val; 2414 spec->num_kctl_used++; 2415 return 0; 2416 } 2417 2418 #define AD1988_PIN_CD_NID 0x18 2419 #define AD1988_PIN_BEEP_NID 0x10 2420 2421 static hda_nid_t ad1988_mixer_nids[8] = { 2422 /* A B C D E F G H */ 2423 0x22, 0x2b, 0x2c, 0x29, 0x26, 0x2a, 0x27, 0x28 2424 }; 2425 2426 static inline hda_nid_t ad1988_idx_to_dac(struct hda_codec *codec, int idx) 2427 { 2428 static hda_nid_t idx_to_dac[8] = { 2429 /* A B C D E F G H */ 2430 0x04, 0x06, 0x05, 0x04, 0x0a, 0x06, 0x05, 0x0a 2431 }; 2432 static hda_nid_t idx_to_dac_rev2[8] = { 2433 /* A B C D E F G H */ 2434 0x04, 0x05, 0x0a, 0x04, 0x06, 0x05, 0x0a, 0x06 2435 }; 2436 if (is_rev2(codec)) 2437 return idx_to_dac_rev2[idx]; 2438 else 2439 return idx_to_dac[idx]; 2440 } 2441 2442 static hda_nid_t ad1988_boost_nids[8] = { 2443 0x38, 0x39, 0x3a, 0x3d, 0x3c, 0x3b, 0, 0 2444 }; 2445 2446 static int ad1988_pin_idx(hda_nid_t nid) 2447 { 2448 static hda_nid_t ad1988_io_pins[8] = { 2449 0x11, 0x14, 0x15, 0x12, 0x17, 0x16, 0x24, 0x25 2450 }; 2451 int i; 2452 for (i = 0; i < ARRAY_SIZE(ad1988_io_pins); i++) 2453 if (ad1988_io_pins[i] == nid) 2454 return i; 2455 return 0; /* should be -1 */ 2456 } 2457 2458 static int ad1988_pin_to_loopback_idx(hda_nid_t nid) 2459 { 2460 static int loopback_idx[8] = { 2461 2, 0, 1, 3, 4, 5, 1, 4 2462 }; 2463 switch (nid) { 2464 case AD1988_PIN_CD_NID: 2465 return 6; 2466 default: 2467 return loopback_idx[ad1988_pin_idx(nid)]; 2468 } 2469 } 2470 2471 static int ad1988_pin_to_adc_idx(hda_nid_t nid) 2472 { 2473 static int adc_idx[8] = { 2474 0, 1, 2, 8, 4, 3, 6, 7 2475 }; 2476 switch (nid) { 2477 case AD1988_PIN_CD_NID: 2478 return 5; 2479 default: 2480 return adc_idx[ad1988_pin_idx(nid)]; 2481 } 2482 } 2483 2484 /* fill in the dac_nids table from the parsed pin configuration */ 2485 static int ad1988_auto_fill_dac_nids(struct hda_codec *codec, 2486 const struct auto_pin_cfg *cfg) 2487 { 2488 struct ad198x_spec *spec = codec->spec; 2489 int i, idx; 2490 2491 spec->multiout.dac_nids = spec->private_dac_nids; 2492 2493 /* check the pins hardwired to audio widget */ 2494 for (i = 0; i < cfg->line_outs; i++) { 2495 idx = ad1988_pin_idx(cfg->line_out_pins[i]); 2496 spec->multiout.dac_nids[i] = ad1988_idx_to_dac(codec, idx); 2497 } 2498 spec->multiout.num_dacs = cfg->line_outs; 2499 return 0; 2500 } 2501 2502 /* add playback controls from the parsed DAC table */ 2503 static int ad1988_auto_create_multi_out_ctls(struct ad198x_spec *spec, 2504 const struct auto_pin_cfg *cfg) 2505 { 2506 char name[32]; 2507 static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" }; 2508 hda_nid_t nid; 2509 int i, err; 2510 2511 for (i = 0; i < cfg->line_outs; i++) { 2512 hda_nid_t dac = spec->multiout.dac_nids[i]; 2513 if (! dac) 2514 continue; 2515 nid = ad1988_mixer_nids[ad1988_pin_idx(cfg->line_out_pins[i])]; 2516 if (i == 2) { 2517 /* Center/LFE */ 2518 err = add_control(spec, AD_CTL_WIDGET_VOL, 2519 "Center Playback Volume", 2520 HDA_COMPOSE_AMP_VAL(dac, 1, 0, HDA_OUTPUT)); 2521 if (err < 0) 2522 return err; 2523 err = add_control(spec, AD_CTL_WIDGET_VOL, 2524 "LFE Playback Volume", 2525 HDA_COMPOSE_AMP_VAL(dac, 2, 0, HDA_OUTPUT)); 2526 if (err < 0) 2527 return err; 2528 err = add_control(spec, AD_CTL_BIND_MUTE, 2529 "Center Playback Switch", 2530 HDA_COMPOSE_AMP_VAL(nid, 1, 2, HDA_INPUT)); 2531 if (err < 0) 2532 return err; 2533 err = add_control(spec, AD_CTL_BIND_MUTE, 2534 "LFE Playback Switch", 2535 HDA_COMPOSE_AMP_VAL(nid, 2, 2, HDA_INPUT)); 2536 if (err < 0) 2537 return err; 2538 } else { 2539 sprintf(name, "%s Playback Volume", chname[i]); 2540 err = add_control(spec, AD_CTL_WIDGET_VOL, name, 2541 HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT)); 2542 if (err < 0) 2543 return err; 2544 sprintf(name, "%s Playback Switch", chname[i]); 2545 err = add_control(spec, AD_CTL_BIND_MUTE, name, 2546 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT)); 2547 if (err < 0) 2548 return err; 2549 } 2550 } 2551 return 0; 2552 } 2553 2554 /* add playback controls for speaker and HP outputs */ 2555 static int ad1988_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin, 2556 const char *pfx) 2557 { 2558 struct ad198x_spec *spec = codec->spec; 2559 hda_nid_t nid; 2560 int idx, err; 2561 char name[32]; 2562 2563 if (! pin) 2564 return 0; 2565 2566 idx = ad1988_pin_idx(pin); 2567 nid = ad1988_idx_to_dac(codec, idx); 2568 /* specify the DAC as the extra output */ 2569 if (! spec->multiout.hp_nid) 2570 spec->multiout.hp_nid = nid; 2571 else 2572 spec->multiout.extra_out_nid[0] = nid; 2573 /* control HP volume/switch on the output mixer amp */ 2574 sprintf(name, "%s Playback Volume", pfx); 2575 if ((err = add_control(spec, AD_CTL_WIDGET_VOL, name, 2576 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0) 2577 return err; 2578 nid = ad1988_mixer_nids[idx]; 2579 sprintf(name, "%s Playback Switch", pfx); 2580 if ((err = add_control(spec, AD_CTL_BIND_MUTE, name, 2581 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0) 2582 return err; 2583 return 0; 2584 } 2585 2586 /* create input playback/capture controls for the given pin */ 2587 static int new_analog_input(struct ad198x_spec *spec, hda_nid_t pin, 2588 const char *ctlname, int boost) 2589 { 2590 char name[32]; 2591 int err, idx; 2592 2593 sprintf(name, "%s Playback Volume", ctlname); 2594 idx = ad1988_pin_to_loopback_idx(pin); 2595 if ((err = add_control(spec, AD_CTL_WIDGET_VOL, name, 2596 HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0) 2597 return err; 2598 sprintf(name, "%s Playback Switch", ctlname); 2599 if ((err = add_control(spec, AD_CTL_WIDGET_MUTE, name, 2600 HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0) 2601 return err; 2602 if (boost) { 2603 hda_nid_t bnid; 2604 idx = ad1988_pin_idx(pin); 2605 bnid = ad1988_boost_nids[idx]; 2606 if (bnid) { 2607 sprintf(name, "%s Boost", ctlname); 2608 return add_control(spec, AD_CTL_WIDGET_VOL, name, 2609 HDA_COMPOSE_AMP_VAL(bnid, 3, idx, HDA_OUTPUT)); 2610 2611 } 2612 } 2613 return 0; 2614 } 2615 2616 /* create playback/capture controls for input pins */ 2617 static int ad1988_auto_create_analog_input_ctls(struct ad198x_spec *spec, 2618 const struct auto_pin_cfg *cfg) 2619 { 2620 struct hda_input_mux *imux = &spec->private_imux; 2621 int i, err; 2622 2623 for (i = 0; i < AUTO_PIN_LAST; i++) { 2624 err = new_analog_input(spec, cfg->input_pins[i], 2625 auto_pin_cfg_labels[i], 2626 i <= AUTO_PIN_FRONT_MIC); 2627 if (err < 0) 2628 return err; 2629 imux->items[imux->num_items].label = auto_pin_cfg_labels[i]; 2630 imux->items[imux->num_items].index = ad1988_pin_to_adc_idx(cfg->input_pins[i]); 2631 imux->num_items++; 2632 } 2633 imux->items[imux->num_items].label = "Mix"; 2634 imux->items[imux->num_items].index = 9; 2635 imux->num_items++; 2636 2637 if ((err = add_control(spec, AD_CTL_WIDGET_VOL, 2638 "Analog Mix Playback Volume", 2639 HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0) 2640 return err; 2641 if ((err = add_control(spec, AD_CTL_WIDGET_MUTE, 2642 "Analog Mix Playback Switch", 2643 HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0) 2644 return err; 2645 2646 return 0; 2647 } 2648 2649 static void ad1988_auto_set_output_and_unmute(struct hda_codec *codec, 2650 hda_nid_t nid, int pin_type, 2651 int dac_idx) 2652 { 2653 /* set as output */ 2654 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type); 2655 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 2656 switch (nid) { 2657 case 0x11: /* port-A - DAC 04 */ 2658 snd_hda_codec_write(codec, 0x37, 0, AC_VERB_SET_CONNECT_SEL, 0x01); 2659 break; 2660 case 0x14: /* port-B - DAC 06 */ 2661 snd_hda_codec_write(codec, 0x30, 0, AC_VERB_SET_CONNECT_SEL, 0x02); 2662 break; 2663 case 0x15: /* port-C - DAC 05 */ 2664 snd_hda_codec_write(codec, 0x31, 0, AC_VERB_SET_CONNECT_SEL, 0x00); 2665 break; 2666 case 0x17: /* port-E - DAC 0a */ 2667 snd_hda_codec_write(codec, 0x32, 0, AC_VERB_SET_CONNECT_SEL, 0x01); 2668 break; 2669 case 0x13: /* mono - DAC 04 */ 2670 snd_hda_codec_write(codec, 0x36, 0, AC_VERB_SET_CONNECT_SEL, 0x01); 2671 break; 2672 } 2673 } 2674 2675 static void ad1988_auto_init_multi_out(struct hda_codec *codec) 2676 { 2677 struct ad198x_spec *spec = codec->spec; 2678 int i; 2679 2680 for (i = 0; i < spec->autocfg.line_outs; i++) { 2681 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 2682 ad1988_auto_set_output_and_unmute(codec, nid, PIN_OUT, i); 2683 } 2684 } 2685 2686 static void ad1988_auto_init_extra_out(struct hda_codec *codec) 2687 { 2688 struct ad198x_spec *spec = codec->spec; 2689 hda_nid_t pin; 2690 2691 pin = spec->autocfg.speaker_pins[0]; 2692 if (pin) /* connect to front */ 2693 ad1988_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 2694 pin = spec->autocfg.hp_pins[0]; 2695 if (pin) /* connect to front */ 2696 ad1988_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 2697 } 2698 2699 static void ad1988_auto_init_analog_input(struct hda_codec *codec) 2700 { 2701 struct ad198x_spec *spec = codec->spec; 2702 int i, idx; 2703 2704 for (i = 0; i < AUTO_PIN_LAST; i++) { 2705 hda_nid_t nid = spec->autocfg.input_pins[i]; 2706 if (! nid) 2707 continue; 2708 switch (nid) { 2709 case 0x15: /* port-C */ 2710 snd_hda_codec_write(codec, 0x33, 0, AC_VERB_SET_CONNECT_SEL, 0x0); 2711 break; 2712 case 0x17: /* port-E */ 2713 snd_hda_codec_write(codec, 0x34, 0, AC_VERB_SET_CONNECT_SEL, 0x0); 2714 break; 2715 } 2716 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 2717 i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN); 2718 if (nid != AD1988_PIN_CD_NID) 2719 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, 2720 AMP_OUT_MUTE); 2721 idx = ad1988_pin_idx(nid); 2722 if (ad1988_boost_nids[idx]) 2723 snd_hda_codec_write(codec, ad1988_boost_nids[idx], 0, 2724 AC_VERB_SET_AMP_GAIN_MUTE, 2725 AMP_OUT_ZERO); 2726 } 2727 } 2728 2729 /* parse the BIOS configuration and set up the alc_spec */ 2730 /* return 1 if successful, 0 if the proper config is not found, or a negative error code */ 2731 static int ad1988_parse_auto_config(struct hda_codec *codec) 2732 { 2733 struct ad198x_spec *spec = codec->spec; 2734 int err; 2735 2736 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0) 2737 return err; 2738 if ((err = ad1988_auto_fill_dac_nids(codec, &spec->autocfg)) < 0) 2739 return err; 2740 if (! spec->autocfg.line_outs) 2741 return 0; /* can't find valid BIOS pin config */ 2742 if ((err = ad1988_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 || 2743 (err = ad1988_auto_create_extra_out(codec, 2744 spec->autocfg.speaker_pins[0], 2745 "Speaker")) < 0 || 2746 (err = ad1988_auto_create_extra_out(codec, spec->autocfg.hp_pins[0], 2747 "Headphone")) < 0 || 2748 (err = ad1988_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0) 2749 return err; 2750 2751 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 2752 2753 if (spec->autocfg.dig_out_pin) 2754 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT; 2755 if (spec->autocfg.dig_in_pin) 2756 spec->dig_in_nid = AD1988_SPDIF_IN; 2757 2758 if (spec->kctl_alloc) 2759 spec->mixers[spec->num_mixers++] = spec->kctl_alloc; 2760 2761 spec->init_verbs[spec->num_init_verbs++] = ad1988_6stack_init_verbs; 2762 2763 spec->input_mux = &spec->private_imux; 2764 2765 return 1; 2766 } 2767 2768 /* init callback for auto-configuration model -- overriding the default init */ 2769 static int ad1988_auto_init(struct hda_codec *codec) 2770 { 2771 ad198x_init(codec); 2772 ad1988_auto_init_multi_out(codec); 2773 ad1988_auto_init_extra_out(codec); 2774 ad1988_auto_init_analog_input(codec); 2775 return 0; 2776 } 2777 2778 2779 /* 2780 */ 2781 2782 static const char *ad1988_models[AD1988_MODEL_LAST] = { 2783 [AD1988_6STACK] = "6stack", 2784 [AD1988_6STACK_DIG] = "6stack-dig", 2785 [AD1988_3STACK] = "3stack", 2786 [AD1988_3STACK_DIG] = "3stack-dig", 2787 [AD1988_LAPTOP] = "laptop", 2788 [AD1988_LAPTOP_DIG] = "laptop-dig", 2789 [AD1988_AUTO] = "auto", 2790 }; 2791 2792 static struct snd_pci_quirk ad1988_cfg_tbl[] = { 2793 SND_PCI_QUIRK(0x1043, 0x81ec, "Asus P5B-DLX", AD1988_6STACK_DIG), 2794 SND_PCI_QUIRK(0x1043, 0x81f6, "Asus M2N-SLI", AD1988_6STACK_DIG), 2795 {} 2796 }; 2797 2798 static int patch_ad1988(struct hda_codec *codec) 2799 { 2800 struct ad198x_spec *spec; 2801 int board_config; 2802 2803 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 2804 if (spec == NULL) 2805 return -ENOMEM; 2806 2807 codec->spec = spec; 2808 2809 if (is_rev2(codec)) 2810 snd_printk(KERN_INFO "patch_analog: AD1988A rev.2 is detected, enable workarounds\n"); 2811 2812 board_config = snd_hda_check_board_config(codec, AD1988_MODEL_LAST, 2813 ad1988_models, ad1988_cfg_tbl); 2814 if (board_config < 0) { 2815 printk(KERN_INFO "hda_codec: Unknown model for AD1988, trying auto-probe from BIOS...\n"); 2816 board_config = AD1988_AUTO; 2817 } 2818 2819 if (board_config == AD1988_AUTO) { 2820 /* automatic parse from the BIOS config */ 2821 int err = ad1988_parse_auto_config(codec); 2822 if (err < 0) { 2823 ad198x_free(codec); 2824 return err; 2825 } else if (! err) { 2826 printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS. Using 6-stack mode...\n"); 2827 board_config = AD1988_6STACK; 2828 } 2829 } 2830 2831 switch (board_config) { 2832 case AD1988_6STACK: 2833 case AD1988_6STACK_DIG: 2834 spec->multiout.max_channels = 8; 2835 spec->multiout.num_dacs = 4; 2836 if (is_rev2(codec)) 2837 spec->multiout.dac_nids = ad1988_6stack_dac_nids_rev2; 2838 else 2839 spec->multiout.dac_nids = ad1988_6stack_dac_nids; 2840 spec->input_mux = &ad1988_6stack_capture_source; 2841 spec->num_mixers = 2; 2842 if (is_rev2(codec)) 2843 spec->mixers[0] = ad1988_6stack_mixers1_rev2; 2844 else 2845 spec->mixers[0] = ad1988_6stack_mixers1; 2846 spec->mixers[1] = ad1988_6stack_mixers2; 2847 spec->num_init_verbs = 1; 2848 spec->init_verbs[0] = ad1988_6stack_init_verbs; 2849 if (board_config == AD1988_6STACK_DIG) { 2850 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT; 2851 spec->dig_in_nid = AD1988_SPDIF_IN; 2852 } 2853 break; 2854 case AD1988_3STACK: 2855 case AD1988_3STACK_DIG: 2856 spec->multiout.max_channels = 6; 2857 spec->multiout.num_dacs = 3; 2858 if (is_rev2(codec)) 2859 spec->multiout.dac_nids = ad1988_3stack_dac_nids_rev2; 2860 else 2861 spec->multiout.dac_nids = ad1988_3stack_dac_nids; 2862 spec->input_mux = &ad1988_6stack_capture_source; 2863 spec->channel_mode = ad1988_3stack_modes; 2864 spec->num_channel_mode = ARRAY_SIZE(ad1988_3stack_modes); 2865 spec->num_mixers = 2; 2866 if (is_rev2(codec)) 2867 spec->mixers[0] = ad1988_3stack_mixers1_rev2; 2868 else 2869 spec->mixers[0] = ad1988_3stack_mixers1; 2870 spec->mixers[1] = ad1988_3stack_mixers2; 2871 spec->num_init_verbs = 1; 2872 spec->init_verbs[0] = ad1988_3stack_init_verbs; 2873 if (board_config == AD1988_3STACK_DIG) 2874 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT; 2875 break; 2876 case AD1988_LAPTOP: 2877 case AD1988_LAPTOP_DIG: 2878 spec->multiout.max_channels = 2; 2879 spec->multiout.num_dacs = 1; 2880 spec->multiout.dac_nids = ad1988_3stack_dac_nids; 2881 spec->input_mux = &ad1988_laptop_capture_source; 2882 spec->num_mixers = 1; 2883 spec->mixers[0] = ad1988_laptop_mixers; 2884 spec->num_init_verbs = 1; 2885 spec->init_verbs[0] = ad1988_laptop_init_verbs; 2886 if (board_config == AD1988_LAPTOP_DIG) 2887 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT; 2888 break; 2889 } 2890 2891 spec->num_adc_nids = ARRAY_SIZE(ad1988_adc_nids); 2892 spec->adc_nids = ad1988_adc_nids; 2893 spec->capsrc_nids = ad1988_capsrc_nids; 2894 spec->mixers[spec->num_mixers++] = ad1988_capture_mixers; 2895 spec->init_verbs[spec->num_init_verbs++] = ad1988_capture_init_verbs; 2896 if (spec->multiout.dig_out_nid) { 2897 spec->mixers[spec->num_mixers++] = ad1988_spdif_out_mixers; 2898 spec->init_verbs[spec->num_init_verbs++] = ad1988_spdif_init_verbs; 2899 } 2900 if (spec->dig_in_nid) 2901 spec->mixers[spec->num_mixers++] = ad1988_spdif_in_mixers; 2902 2903 codec->patch_ops = ad198x_patch_ops; 2904 switch (board_config) { 2905 case AD1988_AUTO: 2906 codec->patch_ops.init = ad1988_auto_init; 2907 break; 2908 case AD1988_LAPTOP: 2909 case AD1988_LAPTOP_DIG: 2910 codec->patch_ops.unsol_event = ad1988_laptop_unsol_event; 2911 break; 2912 } 2913 #ifdef CONFIG_SND_HDA_POWER_SAVE 2914 spec->loopback.amplist = ad1988_loopbacks; 2915 #endif 2916 spec->vmaster_nid = 0x04; 2917 2918 return 0; 2919 } 2920 2921 2922 /* 2923 * AD1884 / AD1984 2924 * 2925 * port-B - front line/mic-in 2926 * port-E - aux in/out 2927 * port-F - aux in/out 2928 * port-C - rear line/mic-in 2929 * port-D - rear line/hp-out 2930 * port-A - front line/hp-out 2931 * 2932 * AD1984 = AD1884 + two digital mic-ins 2933 * 2934 * FIXME: 2935 * For simplicity, we share the single DAC for both HP and line-outs 2936 * right now. The inidividual playbacks could be easily implemented, 2937 * but no build-up framework is given, so far. 2938 */ 2939 2940 static hda_nid_t ad1884_dac_nids[1] = { 2941 0x04, 2942 }; 2943 2944 static hda_nid_t ad1884_adc_nids[2] = { 2945 0x08, 0x09, 2946 }; 2947 2948 static hda_nid_t ad1884_capsrc_nids[2] = { 2949 0x0c, 0x0d, 2950 }; 2951 2952 #define AD1884_SPDIF_OUT 0x02 2953 2954 static struct hda_input_mux ad1884_capture_source = { 2955 .num_items = 4, 2956 .items = { 2957 { "Front Mic", 0x0 }, 2958 { "Mic", 0x1 }, 2959 { "CD", 0x2 }, 2960 { "Mix", 0x3 }, 2961 }, 2962 }; 2963 2964 static struct snd_kcontrol_new ad1884_base_mixers[] = { 2965 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT), 2966 /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */ 2967 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT), 2968 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT), 2969 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT), 2970 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT), 2971 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT), 2972 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT), 2973 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT), 2974 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT), 2975 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT), 2976 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT), 2977 /* 2978 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x20, 0x03, HDA_INPUT), 2979 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x20, 0x03, HDA_INPUT), 2980 HDA_CODEC_VOLUME("Digital Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT), 2981 HDA_CODEC_MUTE("Digital Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT), 2982 */ 2983 HDA_CODEC_VOLUME("Mic Boost", 0x15, 0x0, HDA_INPUT), 2984 HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT), 2985 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT), 2986 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT), 2987 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT), 2988 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT), 2989 { 2990 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2991 /* The multiple "Capture Source" controls confuse alsamixer 2992 * So call somewhat different.. 2993 */ 2994 /* .name = "Capture Source", */ 2995 .name = "Input Source", 2996 .count = 2, 2997 .info = ad198x_mux_enum_info, 2998 .get = ad198x_mux_enum_get, 2999 .put = ad198x_mux_enum_put, 3000 }, 3001 /* SPDIF controls */ 3002 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT), 3003 { 3004 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3005 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source", 3006 /* identical with ad1983 */ 3007 .info = ad1983_spdif_route_info, 3008 .get = ad1983_spdif_route_get, 3009 .put = ad1983_spdif_route_put, 3010 }, 3011 { } /* end */ 3012 }; 3013 3014 static struct snd_kcontrol_new ad1984_dmic_mixers[] = { 3015 HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x05, 0x0, HDA_INPUT), 3016 HDA_CODEC_MUTE("Digital Mic Capture Switch", 0x05, 0x0, HDA_INPUT), 3017 HDA_CODEC_VOLUME_IDX("Digital Mic Capture Volume", 1, 0x06, 0x0, 3018 HDA_INPUT), 3019 HDA_CODEC_MUTE_IDX("Digital Mic Capture Switch", 1, 0x06, 0x0, 3020 HDA_INPUT), 3021 { } /* end */ 3022 }; 3023 3024 /* 3025 * initialization verbs 3026 */ 3027 static struct hda_verb ad1884_init_verbs[] = { 3028 /* DACs; mute as default */ 3029 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 3030 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 3031 /* Port-A (HP) mixer */ 3032 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3033 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3034 /* Port-A pin */ 3035 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3036 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3037 /* HP selector - select DAC2 */ 3038 {0x22, AC_VERB_SET_CONNECT_SEL, 0x1}, 3039 /* Port-D (Line-out) mixer */ 3040 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3041 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3042 /* Port-D pin */ 3043 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3044 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3045 /* Mono-out mixer */ 3046 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3047 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3048 /* Mono-out pin */ 3049 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3050 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3051 /* Mono selector */ 3052 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1}, 3053 /* Port-B (front mic) pin */ 3054 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3055 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3056 /* Port-C (rear mic) pin */ 3057 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3058 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3059 /* Analog mixer; mute as default */ 3060 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3061 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 3062 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 3063 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 3064 /* Analog Mix output amp */ 3065 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */ 3066 /* SPDIF output selector */ 3067 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */ 3068 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */ 3069 { } /* end */ 3070 }; 3071 3072 #ifdef CONFIG_SND_HDA_POWER_SAVE 3073 static struct hda_amp_list ad1884_loopbacks[] = { 3074 { 0x20, HDA_INPUT, 0 }, /* Front Mic */ 3075 { 0x20, HDA_INPUT, 1 }, /* Mic */ 3076 { 0x20, HDA_INPUT, 2 }, /* CD */ 3077 { 0x20, HDA_INPUT, 4 }, /* Docking */ 3078 { } /* end */ 3079 }; 3080 #endif 3081 3082 static const char *ad1884_slave_vols[] = { 3083 "PCM Playback Volume", 3084 "Mic Playback Volume", 3085 "Mono Playback Volume", 3086 "Front Mic Playback Volume", 3087 "Mic Playback Volume", 3088 "CD Playback Volume", 3089 "Internal Mic Playback Volume", 3090 "Docking Mic Playback Volume" 3091 "Beep Playback Volume", 3092 "IEC958 Playback Volume", 3093 NULL 3094 }; 3095 3096 static int patch_ad1884(struct hda_codec *codec) 3097 { 3098 struct ad198x_spec *spec; 3099 3100 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 3101 if (spec == NULL) 3102 return -ENOMEM; 3103 3104 mutex_init(&spec->amp_mutex); 3105 codec->spec = spec; 3106 3107 spec->multiout.max_channels = 2; 3108 spec->multiout.num_dacs = ARRAY_SIZE(ad1884_dac_nids); 3109 spec->multiout.dac_nids = ad1884_dac_nids; 3110 spec->multiout.dig_out_nid = AD1884_SPDIF_OUT; 3111 spec->num_adc_nids = ARRAY_SIZE(ad1884_adc_nids); 3112 spec->adc_nids = ad1884_adc_nids; 3113 spec->capsrc_nids = ad1884_capsrc_nids; 3114 spec->input_mux = &ad1884_capture_source; 3115 spec->num_mixers = 1; 3116 spec->mixers[0] = ad1884_base_mixers; 3117 spec->num_init_verbs = 1; 3118 spec->init_verbs[0] = ad1884_init_verbs; 3119 spec->spdif_route = 0; 3120 #ifdef CONFIG_SND_HDA_POWER_SAVE 3121 spec->loopback.amplist = ad1884_loopbacks; 3122 #endif 3123 spec->vmaster_nid = 0x04; 3124 /* we need to cover all playback volumes */ 3125 spec->slave_vols = ad1884_slave_vols; 3126 3127 codec->patch_ops = ad198x_patch_ops; 3128 3129 return 0; 3130 } 3131 3132 /* 3133 * Lenovo Thinkpad T61/X61 3134 */ 3135 static struct hda_input_mux ad1984_thinkpad_capture_source = { 3136 .num_items = 3, 3137 .items = { 3138 { "Mic", 0x0 }, 3139 { "Internal Mic", 0x1 }, 3140 { "Mix", 0x3 }, 3141 }, 3142 }; 3143 3144 3145 /* 3146 * Dell Precision T3400 3147 */ 3148 static struct hda_input_mux ad1984_dell_desktop_capture_source = { 3149 .num_items = 3, 3150 .items = { 3151 { "Front Mic", 0x0 }, 3152 { "Line-In", 0x1 }, 3153 { "Mix", 0x3 }, 3154 }, 3155 }; 3156 3157 3158 static struct snd_kcontrol_new ad1984_thinkpad_mixers[] = { 3159 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT), 3160 /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */ 3161 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT), 3162 HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT), 3163 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT), 3164 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT), 3165 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x20, 0x01, HDA_INPUT), 3166 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT), 3167 HDA_CODEC_VOLUME("Docking Mic Playback Volume", 0x20, 0x04, HDA_INPUT), 3168 HDA_CODEC_MUTE("Docking Mic Playback Switch", 0x20, 0x04, HDA_INPUT), 3169 HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT), 3170 HDA_CODEC_VOLUME("Internal Mic Boost", 0x15, 0x0, HDA_INPUT), 3171 HDA_CODEC_VOLUME("Docking Mic Boost", 0x25, 0x0, HDA_OUTPUT), 3172 HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT), 3173 HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT), 3174 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT), 3175 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT), 3176 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT), 3177 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT), 3178 { 3179 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3180 /* The multiple "Capture Source" controls confuse alsamixer 3181 * So call somewhat different.. 3182 */ 3183 /* .name = "Capture Source", */ 3184 .name = "Input Source", 3185 .count = 2, 3186 .info = ad198x_mux_enum_info, 3187 .get = ad198x_mux_enum_get, 3188 .put = ad198x_mux_enum_put, 3189 }, 3190 /* SPDIF controls */ 3191 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT), 3192 { 3193 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3194 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source", 3195 /* identical with ad1983 */ 3196 .info = ad1983_spdif_route_info, 3197 .get = ad1983_spdif_route_get, 3198 .put = ad1983_spdif_route_put, 3199 }, 3200 { } /* end */ 3201 }; 3202 3203 /* additional verbs */ 3204 static struct hda_verb ad1984_thinkpad_init_verbs[] = { 3205 /* Port-E (docking station mic) pin */ 3206 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3207 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3208 /* docking mic boost */ 3209 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3210 /* Analog mixer - docking mic; mute as default */ 3211 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 3212 /* enable EAPD bit */ 3213 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x02}, 3214 { } /* end */ 3215 }; 3216 3217 /* 3218 * Dell Precision T3400 3219 */ 3220 static struct snd_kcontrol_new ad1984_dell_desktop_mixers[] = { 3221 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT), 3222 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT), 3223 HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT), 3224 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT), 3225 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT), 3226 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT), 3227 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT), 3228 HDA_CODEC_VOLUME("Line-In Playback Volume", 0x20, 0x01, HDA_INPUT), 3229 HDA_CODEC_MUTE("Line-In Playback Switch", 0x20, 0x01, HDA_INPUT), 3230 /* 3231 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x20, 0x03, HDA_INPUT), 3232 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x20, 0x03, HDA_INPUT), 3233 */ 3234 HDA_CODEC_VOLUME("Line-In Boost", 0x15, 0x0, HDA_INPUT), 3235 HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT), 3236 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT), 3237 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT), 3238 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT), 3239 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT), 3240 { 3241 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3242 /* The multiple "Capture Source" controls confuse alsamixer 3243 * So call somewhat different.. 3244 */ 3245 /* .name = "Capture Source", */ 3246 .name = "Input Source", 3247 .count = 2, 3248 .info = ad198x_mux_enum_info, 3249 .get = ad198x_mux_enum_get, 3250 .put = ad198x_mux_enum_put, 3251 }, 3252 { } /* end */ 3253 }; 3254 3255 /* Digial MIC ADC NID 0x05 + 0x06 */ 3256 static int ad1984_pcm_dmic_prepare(struct hda_pcm_stream *hinfo, 3257 struct hda_codec *codec, 3258 unsigned int stream_tag, 3259 unsigned int format, 3260 struct snd_pcm_substream *substream) 3261 { 3262 snd_hda_codec_setup_stream(codec, 0x05 + substream->number, 3263 stream_tag, 0, format); 3264 return 0; 3265 } 3266 3267 static int ad1984_pcm_dmic_cleanup(struct hda_pcm_stream *hinfo, 3268 struct hda_codec *codec, 3269 struct snd_pcm_substream *substream) 3270 { 3271 snd_hda_codec_setup_stream(codec, 0x05 + substream->number, 3272 0, 0, 0); 3273 return 0; 3274 } 3275 3276 static struct hda_pcm_stream ad1984_pcm_dmic_capture = { 3277 .substreams = 2, 3278 .channels_min = 2, 3279 .channels_max = 2, 3280 .nid = 0x05, 3281 .ops = { 3282 .prepare = ad1984_pcm_dmic_prepare, 3283 .cleanup = ad1984_pcm_dmic_cleanup 3284 }, 3285 }; 3286 3287 static int ad1984_build_pcms(struct hda_codec *codec) 3288 { 3289 struct ad198x_spec *spec = codec->spec; 3290 struct hda_pcm *info; 3291 int err; 3292 3293 err = ad198x_build_pcms(codec); 3294 if (err < 0) 3295 return err; 3296 3297 info = spec->pcm_rec + codec->num_pcms; 3298 codec->num_pcms++; 3299 info->name = "AD1984 Digital Mic"; 3300 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad1984_pcm_dmic_capture; 3301 return 0; 3302 } 3303 3304 /* models */ 3305 enum { 3306 AD1984_BASIC, 3307 AD1984_THINKPAD, 3308 AD1984_DELL_DESKTOP, 3309 AD1984_MODELS 3310 }; 3311 3312 static const char *ad1984_models[AD1984_MODELS] = { 3313 [AD1984_BASIC] = "basic", 3314 [AD1984_THINKPAD] = "thinkpad", 3315 [AD1984_DELL_DESKTOP] = "dell_desktop", 3316 }; 3317 3318 static struct snd_pci_quirk ad1984_cfg_tbl[] = { 3319 /* Lenovo Thinkpad T61/X61 */ 3320 SND_PCI_QUIRK(0x17aa, 0, "Lenovo Thinkpad", AD1984_THINKPAD), 3321 SND_PCI_QUIRK(0x1028, 0x0214, "Dell T3400", AD1984_DELL_DESKTOP), 3322 {} 3323 }; 3324 3325 static int patch_ad1984(struct hda_codec *codec) 3326 { 3327 struct ad198x_spec *spec; 3328 int board_config, err; 3329 3330 err = patch_ad1884(codec); 3331 if (err < 0) 3332 return err; 3333 spec = codec->spec; 3334 board_config = snd_hda_check_board_config(codec, AD1984_MODELS, 3335 ad1984_models, ad1984_cfg_tbl); 3336 switch (board_config) { 3337 case AD1984_BASIC: 3338 /* additional digital mics */ 3339 spec->mixers[spec->num_mixers++] = ad1984_dmic_mixers; 3340 codec->patch_ops.build_pcms = ad1984_build_pcms; 3341 break; 3342 case AD1984_THINKPAD: 3343 spec->multiout.dig_out_nid = AD1884_SPDIF_OUT; 3344 spec->input_mux = &ad1984_thinkpad_capture_source; 3345 spec->mixers[0] = ad1984_thinkpad_mixers; 3346 spec->init_verbs[spec->num_init_verbs++] = ad1984_thinkpad_init_verbs; 3347 break; 3348 case AD1984_DELL_DESKTOP: 3349 spec->multiout.dig_out_nid = 0; 3350 spec->input_mux = &ad1984_dell_desktop_capture_source; 3351 spec->mixers[0] = ad1984_dell_desktop_mixers; 3352 break; 3353 } 3354 return 0; 3355 } 3356 3357 3358 /* 3359 * AD1882 3360 * 3361 * port-A - front hp-out 3362 * port-B - front mic-in 3363 * port-C - rear line-in, shared surr-out (3stack) 3364 * port-D - rear line-out 3365 * port-E - rear mic-in, shared clfe-out (3stack) 3366 * port-F - rear surr-out (6stack) 3367 * port-G - rear clfe-out (6stack) 3368 */ 3369 3370 static hda_nid_t ad1882_dac_nids[3] = { 3371 0x04, 0x03, 0x05 3372 }; 3373 3374 static hda_nid_t ad1882_adc_nids[2] = { 3375 0x08, 0x09, 3376 }; 3377 3378 static hda_nid_t ad1882_capsrc_nids[2] = { 3379 0x0c, 0x0d, 3380 }; 3381 3382 #define AD1882_SPDIF_OUT 0x02 3383 3384 /* list: 0x11, 0x39, 0x3a, 0x18, 0x3c, 0x3b, 0x12, 0x20 */ 3385 static struct hda_input_mux ad1882_capture_source = { 3386 .num_items = 5, 3387 .items = { 3388 { "Front Mic", 0x1 }, 3389 { "Mic", 0x4 }, 3390 { "Line", 0x2 }, 3391 { "CD", 0x3 }, 3392 { "Mix", 0x7 }, 3393 }, 3394 }; 3395 3396 static struct snd_kcontrol_new ad1882_base_mixers[] = { 3397 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT), 3398 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT), 3399 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT), 3400 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT), 3401 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT), 3402 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT), 3403 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT), 3404 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT), 3405 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT), 3406 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT), 3407 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT), 3408 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT), 3409 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x04, HDA_INPUT), 3410 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x04, HDA_INPUT), 3411 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x06, HDA_INPUT), 3412 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x06, HDA_INPUT), 3413 HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x07, HDA_INPUT), 3414 HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x07, HDA_INPUT), 3415 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT), 3416 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT), 3417 HDA_CODEC_VOLUME("Line-In Boost", 0x3a, 0x0, HDA_OUTPUT), 3418 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT), 3419 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT), 3420 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT), 3421 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT), 3422 { 3423 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3424 /* The multiple "Capture Source" controls confuse alsamixer 3425 * So call somewhat different.. 3426 */ 3427 /* .name = "Capture Source", */ 3428 .name = "Input Source", 3429 .count = 2, 3430 .info = ad198x_mux_enum_info, 3431 .get = ad198x_mux_enum_get, 3432 .put = ad198x_mux_enum_put, 3433 }, 3434 /* SPDIF controls */ 3435 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT), 3436 { 3437 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3438 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source", 3439 /* identical with ad1983 */ 3440 .info = ad1983_spdif_route_info, 3441 .get = ad1983_spdif_route_get, 3442 .put = ad1983_spdif_route_put, 3443 }, 3444 { } /* end */ 3445 }; 3446 3447 static struct snd_kcontrol_new ad1882_3stack_mixers[] = { 3448 HDA_CODEC_MUTE("Surround Playback Switch", 0x15, 0x0, HDA_OUTPUT), 3449 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x17, 1, 0x0, HDA_OUTPUT), 3450 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x17, 2, 0x0, HDA_OUTPUT), 3451 { 3452 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3453 .name = "Channel Mode", 3454 .info = ad198x_ch_mode_info, 3455 .get = ad198x_ch_mode_get, 3456 .put = ad198x_ch_mode_put, 3457 }, 3458 { } /* end */ 3459 }; 3460 3461 static struct snd_kcontrol_new ad1882_6stack_mixers[] = { 3462 HDA_CODEC_MUTE("Surround Playback Switch", 0x16, 0x0, HDA_OUTPUT), 3463 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x24, 1, 0x0, HDA_OUTPUT), 3464 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x24, 2, 0x0, HDA_OUTPUT), 3465 { } /* end */ 3466 }; 3467 3468 static struct hda_verb ad1882_ch2_init[] = { 3469 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3470 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3471 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 3472 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3473 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3474 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 3475 { } /* end */ 3476 }; 3477 3478 static struct hda_verb ad1882_ch4_init[] = { 3479 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3480 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3481 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3482 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3483 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3484 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 3485 { } /* end */ 3486 }; 3487 3488 static struct hda_verb ad1882_ch6_init[] = { 3489 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3490 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3491 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3492 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3493 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3494 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3495 { } /* end */ 3496 }; 3497 3498 static struct hda_channel_mode ad1882_modes[3] = { 3499 { 2, ad1882_ch2_init }, 3500 { 4, ad1882_ch4_init }, 3501 { 6, ad1882_ch6_init }, 3502 }; 3503 3504 /* 3505 * initialization verbs 3506 */ 3507 static struct hda_verb ad1882_init_verbs[] = { 3508 /* DACs; mute as default */ 3509 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 3510 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 3511 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 3512 /* Port-A (HP) mixer */ 3513 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3514 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3515 /* Port-A pin */ 3516 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3517 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3518 /* HP selector - select DAC2 */ 3519 {0x37, AC_VERB_SET_CONNECT_SEL, 0x1}, 3520 /* Port-D (Line-out) mixer */ 3521 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3522 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3523 /* Port-D pin */ 3524 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3525 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3526 /* Mono-out mixer */ 3527 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3528 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3529 /* Mono-out pin */ 3530 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3531 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3532 /* Port-B (front mic) pin */ 3533 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3534 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3535 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */ 3536 /* Port-C (line-in) pin */ 3537 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3538 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3539 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */ 3540 /* Port-C mixer - mute as input */ 3541 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3542 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 3543 /* Port-E (mic-in) pin */ 3544 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3545 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3546 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */ 3547 /* Port-E mixer - mute as input */ 3548 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3549 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 3550 /* Port-F (surround) */ 3551 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3552 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3553 /* Port-G (CLFE) */ 3554 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3555 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3556 /* Analog mixer; mute as default */ 3557 /* list: 0x39, 0x3a, 0x11, 0x12, 0x3c, 0x3b, 0x18, 0x1a */ 3558 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3559 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 3560 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 3561 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 3562 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 3563 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 3564 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 3565 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 3566 /* Analog Mix output amp */ 3567 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */ 3568 /* SPDIF output selector */ 3569 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */ 3570 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */ 3571 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */ 3572 { } /* end */ 3573 }; 3574 3575 #ifdef CONFIG_SND_HDA_POWER_SAVE 3576 static struct hda_amp_list ad1882_loopbacks[] = { 3577 { 0x20, HDA_INPUT, 0 }, /* Front Mic */ 3578 { 0x20, HDA_INPUT, 1 }, /* Mic */ 3579 { 0x20, HDA_INPUT, 4 }, /* Line */ 3580 { 0x20, HDA_INPUT, 6 }, /* CD */ 3581 { } /* end */ 3582 }; 3583 #endif 3584 3585 /* models */ 3586 enum { 3587 AD1882_3STACK, 3588 AD1882_6STACK, 3589 AD1882_MODELS 3590 }; 3591 3592 static const char *ad1882_models[AD1986A_MODELS] = { 3593 [AD1882_3STACK] = "3stack", 3594 [AD1882_6STACK] = "6stack", 3595 }; 3596 3597 3598 static int patch_ad1882(struct hda_codec *codec) 3599 { 3600 struct ad198x_spec *spec; 3601 int board_config; 3602 3603 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 3604 if (spec == NULL) 3605 return -ENOMEM; 3606 3607 mutex_init(&spec->amp_mutex); 3608 codec->spec = spec; 3609 3610 spec->multiout.max_channels = 6; 3611 spec->multiout.num_dacs = 3; 3612 spec->multiout.dac_nids = ad1882_dac_nids; 3613 spec->multiout.dig_out_nid = AD1882_SPDIF_OUT; 3614 spec->num_adc_nids = ARRAY_SIZE(ad1882_adc_nids); 3615 spec->adc_nids = ad1882_adc_nids; 3616 spec->capsrc_nids = ad1882_capsrc_nids; 3617 spec->input_mux = &ad1882_capture_source; 3618 spec->num_mixers = 1; 3619 spec->mixers[0] = ad1882_base_mixers; 3620 spec->num_init_verbs = 1; 3621 spec->init_verbs[0] = ad1882_init_verbs; 3622 spec->spdif_route = 0; 3623 #ifdef CONFIG_SND_HDA_POWER_SAVE 3624 spec->loopback.amplist = ad1882_loopbacks; 3625 #endif 3626 spec->vmaster_nid = 0x04; 3627 3628 codec->patch_ops = ad198x_patch_ops; 3629 3630 /* override some parameters */ 3631 board_config = snd_hda_check_board_config(codec, AD1882_MODELS, 3632 ad1882_models, NULL); 3633 switch (board_config) { 3634 default: 3635 case AD1882_3STACK: 3636 spec->num_mixers = 2; 3637 spec->mixers[1] = ad1882_3stack_mixers; 3638 spec->channel_mode = ad1882_modes; 3639 spec->num_channel_mode = ARRAY_SIZE(ad1882_modes); 3640 spec->need_dac_fix = 1; 3641 spec->multiout.max_channels = 2; 3642 spec->multiout.num_dacs = 1; 3643 break; 3644 case AD1882_6STACK: 3645 spec->num_mixers = 2; 3646 spec->mixers[1] = ad1882_6stack_mixers; 3647 break; 3648 } 3649 return 0; 3650 } 3651 3652 3653 /* 3654 * patch entries 3655 */ 3656 struct hda_codec_preset snd_hda_preset_analog[] = { 3657 { .id = 0x11d41882, .name = "AD1882", .patch = patch_ad1882 }, 3658 { .id = 0x11d41884, .name = "AD1884", .patch = patch_ad1884 }, 3659 { .id = 0x11d41981, .name = "AD1981", .patch = patch_ad1981 }, 3660 { .id = 0x11d41983, .name = "AD1983", .patch = patch_ad1983 }, 3661 { .id = 0x11d41984, .name = "AD1984", .patch = patch_ad1984 }, 3662 { .id = 0x11d41986, .name = "AD1986A", .patch = patch_ad1986a }, 3663 { .id = 0x11d41988, .name = "AD1988", .patch = patch_ad1988 }, 3664 { .id = 0x11d4198b, .name = "AD1988B", .patch = patch_ad1988 }, 3665 {} /* terminator */ 3666 }; 3667