1 /* 2 * Universal Interface for Intel High Definition Audio Codec 3 * 4 * HD audio interface patch for VIA VT1708 codec 5 * 6 * Copyright (c) 2006 Lydia Wang <lydiawang@viatech.com> 7 * Takashi Iwai <tiwai@suse.de> 8 * 9 * This driver is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This driver is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 22 */ 23 24 /* * * * * * * * * * * * * * Release History * * * * * * * * * * * * * * * * */ 25 /* */ 26 /* 2006-03-03 Lydia Wang Create the basic patch to support VT1708 codec */ 27 /* 2006-03-14 Lydia Wang Modify hard code for some pin widget nid */ 28 /* 2006-08-02 Lydia Wang Add support to VT1709 codec */ 29 /* 2006-09-08 Lydia Wang Fix internal loopback recording source select bug */ 30 /* 2007-09-12 Lydia Wang Add EAPD enable during driver initialization */ 31 /* 2007-09-17 Lydia Wang Add VT1708B codec support */ 32 /* */ 33 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 34 35 36 #include <linux/init.h> 37 #include <linux/delay.h> 38 #include <linux/slab.h> 39 #include <sound/core.h> 40 #include "hda_codec.h" 41 #include "hda_local.h" 42 #include "hda_patch.h" 43 44 /* amp values */ 45 #define AMP_VAL_IDX_SHIFT 19 46 #define AMP_VAL_IDX_MASK (0x0f<<19) 47 48 #define NUM_CONTROL_ALLOC 32 49 #define NUM_VERB_ALLOC 32 50 51 /* Pin Widget NID */ 52 #define VT1708_HP_NID 0x13 53 #define VT1708_DIGOUT_NID 0x14 54 #define VT1708_DIGIN_NID 0x16 55 #define VT1708_DIGIN_PIN 0x26 56 57 #define VT1709_HP_DAC_NID 0x28 58 #define VT1709_DIGOUT_NID 0x13 59 #define VT1709_DIGIN_NID 0x17 60 #define VT1709_DIGIN_PIN 0x25 61 62 #define VT1708B_HP_NID 0x25 63 #define VT1708B_DIGOUT_NID 0x12 64 #define VT1708B_DIGIN_NID 0x15 65 #define VT1708B_DIGIN_PIN 0x21 66 67 #define IS_VT1708_VENDORID(x) ((x) >= 0x11061708 && (x) <= 0x1106170b) 68 #define IS_VT1709_10CH_VENDORID(x) ((x) >= 0x1106e710 && (x) <= 0x1106e713) 69 #define IS_VT1709_6CH_VENDORID(x) ((x) >= 0x1106e714 && (x) <= 0x1106e717) 70 #define IS_VT1708B_8CH_VENDORID(x) ((x) >= 0x1106e720 && (x) <= 0x1106e723) 71 #define IS_VT1708B_4CH_VENDORID(x) ((x) >= 0x1106e724 && (x) <= 0x1106e727) 72 73 74 enum { 75 VIA_CTL_WIDGET_VOL, 76 VIA_CTL_WIDGET_MUTE, 77 }; 78 79 enum { 80 AUTO_SEQ_FRONT, 81 AUTO_SEQ_SURROUND, 82 AUTO_SEQ_CENLFE, 83 AUTO_SEQ_SIDE 84 }; 85 86 static struct snd_kcontrol_new vt1708_control_templates[] = { 87 HDA_CODEC_VOLUME(NULL, 0, 0, 0), 88 HDA_CODEC_MUTE(NULL, 0, 0, 0), 89 }; 90 91 92 struct via_spec { 93 /* codec parameterization */ 94 struct snd_kcontrol_new *mixers[3]; 95 unsigned int num_mixers; 96 97 struct hda_verb *init_verbs; 98 99 char *stream_name_analog; 100 struct hda_pcm_stream *stream_analog_playback; 101 struct hda_pcm_stream *stream_analog_capture; 102 103 char *stream_name_digital; 104 struct hda_pcm_stream *stream_digital_playback; 105 struct hda_pcm_stream *stream_digital_capture; 106 107 /* playback */ 108 struct hda_multi_out multiout; 109 110 /* capture */ 111 unsigned int num_adc_nids; 112 hda_nid_t *adc_nids; 113 hda_nid_t dig_in_nid; 114 115 /* capture source */ 116 const struct hda_input_mux *input_mux; 117 unsigned int cur_mux[3]; 118 119 /* PCM information */ 120 struct hda_pcm pcm_rec[2]; 121 122 /* dynamic controls, init_verbs and input_mux */ 123 struct auto_pin_cfg autocfg; 124 unsigned int num_kctl_alloc, num_kctl_used; 125 struct snd_kcontrol_new *kctl_alloc; 126 struct hda_input_mux private_imux; 127 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS]; 128 129 #ifdef CONFIG_SND_HDA_POWER_SAVE 130 struct hda_loopback_check loopback; 131 #endif 132 }; 133 134 static hda_nid_t vt1708_adc_nids[2] = { 135 /* ADC1-2 */ 136 0x15, 0x27 137 }; 138 139 static hda_nid_t vt1709_adc_nids[3] = { 140 /* ADC1-2 */ 141 0x14, 0x15, 0x16 142 }; 143 144 static hda_nid_t vt1708B_adc_nids[2] = { 145 /* ADC1-2 */ 146 0x13, 0x14 147 }; 148 149 /* add dynamic controls */ 150 static int via_add_control(struct via_spec *spec, int type, const char *name, 151 unsigned long val) 152 { 153 struct snd_kcontrol_new *knew; 154 155 if (spec->num_kctl_used >= spec->num_kctl_alloc) { 156 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC; 157 158 /* array + terminator */ 159 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); 160 if (!knew) 161 return -ENOMEM; 162 if (spec->kctl_alloc) { 163 memcpy(knew, spec->kctl_alloc, 164 sizeof(*knew) * spec->num_kctl_alloc); 165 kfree(spec->kctl_alloc); 166 } 167 spec->kctl_alloc = knew; 168 spec->num_kctl_alloc = num; 169 } 170 171 knew = &spec->kctl_alloc[spec->num_kctl_used]; 172 *knew = vt1708_control_templates[type]; 173 knew->name = kstrdup(name, GFP_KERNEL); 174 175 if (!knew->name) 176 return -ENOMEM; 177 knew->private_value = val; 178 spec->num_kctl_used++; 179 return 0; 180 } 181 182 /* create input playback/capture controls for the given pin */ 183 static int via_new_analog_input(struct via_spec *spec, hda_nid_t pin, 184 const char *ctlname, int idx, int mix_nid) 185 { 186 char name[32]; 187 int err; 188 189 sprintf(name, "%s Playback Volume", ctlname); 190 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 191 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); 192 if (err < 0) 193 return err; 194 sprintf(name, "%s Playback Switch", ctlname); 195 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 196 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); 197 if (err < 0) 198 return err; 199 return 0; 200 } 201 202 static void via_auto_set_output_and_unmute(struct hda_codec *codec, 203 hda_nid_t nid, int pin_type, 204 int dac_idx) 205 { 206 /* set as output */ 207 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 208 pin_type); 209 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, 210 AMP_OUT_UNMUTE); 211 } 212 213 214 static void via_auto_init_multi_out(struct hda_codec *codec) 215 { 216 struct via_spec *spec = codec->spec; 217 int i; 218 219 for (i = 0; i <= AUTO_SEQ_SIDE; i++) { 220 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 221 if (nid) 222 via_auto_set_output_and_unmute(codec, nid, PIN_OUT, i); 223 } 224 } 225 226 static void via_auto_init_hp_out(struct hda_codec *codec) 227 { 228 struct via_spec *spec = codec->spec; 229 hda_nid_t pin; 230 231 pin = spec->autocfg.hp_pins[0]; 232 if (pin) /* connect to front */ 233 via_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 234 } 235 236 static void via_auto_init_analog_input(struct hda_codec *codec) 237 { 238 struct via_spec *spec = codec->spec; 239 int i; 240 241 for (i = 0; i < AUTO_PIN_LAST; i++) { 242 hda_nid_t nid = spec->autocfg.input_pins[i]; 243 244 snd_hda_codec_write(codec, nid, 0, 245 AC_VERB_SET_PIN_WIDGET_CONTROL, 246 (i <= AUTO_PIN_FRONT_MIC ? 247 PIN_VREF50 : PIN_IN)); 248 249 } 250 } 251 /* 252 * input MUX handling 253 */ 254 static int via_mux_enum_info(struct snd_kcontrol *kcontrol, 255 struct snd_ctl_elem_info *uinfo) 256 { 257 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 258 struct via_spec *spec = codec->spec; 259 return snd_hda_input_mux_info(spec->input_mux, uinfo); 260 } 261 262 static int via_mux_enum_get(struct snd_kcontrol *kcontrol, 263 struct snd_ctl_elem_value *ucontrol) 264 { 265 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 266 struct via_spec *spec = codec->spec; 267 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 268 269 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx]; 270 return 0; 271 } 272 273 static int via_mux_enum_put(struct snd_kcontrol *kcontrol, 274 struct snd_ctl_elem_value *ucontrol) 275 { 276 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 277 struct via_spec *spec = codec->spec; 278 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 279 unsigned int vendor_id = codec->vendor_id; 280 281 /* AIW0 lydia 060801 add for correct sw0 input select */ 282 if (IS_VT1708_VENDORID(vendor_id) && (adc_idx == 0)) 283 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol, 284 0x18, &spec->cur_mux[adc_idx]); 285 else if ((IS_VT1709_10CH_VENDORID(vendor_id) || 286 IS_VT1709_6CH_VENDORID(vendor_id)) && adc_idx == 0) 287 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol, 288 0x19, &spec->cur_mux[adc_idx]); 289 else if ((IS_VT1708B_8CH_VENDORID(vendor_id) || 290 IS_VT1708B_4CH_VENDORID(vendor_id)) && adc_idx == 0) 291 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol, 292 0x17, &spec->cur_mux[adc_idx]); 293 else 294 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol, 295 spec->adc_nids[adc_idx], 296 &spec->cur_mux[adc_idx]); 297 } 298 299 /* capture mixer elements */ 300 static struct snd_kcontrol_new vt1708_capture_mixer[] = { 301 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_INPUT), 302 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_INPUT), 303 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x27, 0x0, HDA_INPUT), 304 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x27, 0x0, HDA_INPUT), 305 { 306 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 307 /* The multiple "Capture Source" controls confuse alsamixer 308 * So call somewhat different.. 309 */ 310 /* .name = "Capture Source", */ 311 .name = "Input Source", 312 .count = 1, 313 .info = via_mux_enum_info, 314 .get = via_mux_enum_get, 315 .put = via_mux_enum_put, 316 }, 317 { } /* end */ 318 }; 319 /* 320 * generic initialization of ADC, input mixers and output mixers 321 */ 322 static struct hda_verb vt1708_volume_init_verbs[] = { 323 /* 324 * Unmute ADC0-1 and set the default input to mic-in 325 */ 326 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 327 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 328 329 330 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 331 * mixer widget 332 */ 333 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ 334 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 335 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 336 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 337 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 338 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 339 340 /* 341 * Set up output mixers (0x19 - 0x1b) 342 */ 343 /* set vol=0 to output mixers */ 344 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 345 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 346 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 347 348 /* Setup default input to PW4 */ 349 {0x20, AC_VERB_SET_CONNECT_SEL, 0x1}, 350 /* PW9 Output enable */ 351 {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 352 { } 353 }; 354 355 static int via_playback_pcm_open(struct hda_pcm_stream *hinfo, 356 struct hda_codec *codec, 357 struct snd_pcm_substream *substream) 358 { 359 struct via_spec *spec = codec->spec; 360 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, 361 hinfo); 362 } 363 364 static int via_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 365 struct hda_codec *codec, 366 unsigned int stream_tag, 367 unsigned int format, 368 struct snd_pcm_substream *substream) 369 { 370 struct via_spec *spec = codec->spec; 371 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, 372 stream_tag, format, substream); 373 } 374 375 static int via_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 376 struct hda_codec *codec, 377 struct snd_pcm_substream *substream) 378 { 379 struct via_spec *spec = codec->spec; 380 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); 381 } 382 383 /* 384 * Digital out 385 */ 386 static int via_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, 387 struct hda_codec *codec, 388 struct snd_pcm_substream *substream) 389 { 390 struct via_spec *spec = codec->spec; 391 return snd_hda_multi_out_dig_open(codec, &spec->multiout); 392 } 393 394 static int via_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, 395 struct hda_codec *codec, 396 struct snd_pcm_substream *substream) 397 { 398 struct via_spec *spec = codec->spec; 399 return snd_hda_multi_out_dig_close(codec, &spec->multiout); 400 } 401 402 static int via_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 403 struct hda_codec *codec, 404 unsigned int stream_tag, 405 unsigned int format, 406 struct snd_pcm_substream *substream) 407 { 408 struct via_spec *spec = codec->spec; 409 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, 410 stream_tag, format, substream); 411 } 412 413 /* 414 * Analog capture 415 */ 416 static int via_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 417 struct hda_codec *codec, 418 unsigned int stream_tag, 419 unsigned int format, 420 struct snd_pcm_substream *substream) 421 { 422 struct via_spec *spec = codec->spec; 423 424 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 425 stream_tag, 0, format); 426 return 0; 427 } 428 429 static int via_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 430 struct hda_codec *codec, 431 struct snd_pcm_substream *substream) 432 { 433 struct via_spec *spec = codec->spec; 434 snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]); 435 return 0; 436 } 437 438 static struct hda_pcm_stream vt1708_pcm_analog_playback = { 439 .substreams = 1, 440 .channels_min = 2, 441 .channels_max = 8, 442 .nid = 0x10, /* NID to query formats and rates */ 443 .ops = { 444 .open = via_playback_pcm_open, 445 .prepare = via_playback_pcm_prepare, 446 .cleanup = via_playback_pcm_cleanup 447 }, 448 }; 449 450 static struct hda_pcm_stream vt1708_pcm_analog_s16_playback = { 451 .substreams = 1, 452 .channels_min = 2, 453 .channels_max = 8, 454 .nid = 0x10, /* NID to query formats and rates */ 455 /* We got noisy outputs on the right channel on VT1708 when 456 * 24bit samples are used. Until any workaround is found, 457 * disable the 24bit format, so far. 458 */ 459 .formats = SNDRV_PCM_FMTBIT_S16_LE, 460 .ops = { 461 .open = via_playback_pcm_open, 462 .prepare = via_playback_pcm_prepare, 463 .cleanup = via_playback_pcm_cleanup 464 }, 465 }; 466 467 static struct hda_pcm_stream vt1708_pcm_analog_capture = { 468 .substreams = 2, 469 .channels_min = 2, 470 .channels_max = 2, 471 .nid = 0x15, /* NID to query formats and rates */ 472 .ops = { 473 .prepare = via_capture_pcm_prepare, 474 .cleanup = via_capture_pcm_cleanup 475 }, 476 }; 477 478 static struct hda_pcm_stream vt1708_pcm_digital_playback = { 479 .substreams = 1, 480 .channels_min = 2, 481 .channels_max = 2, 482 /* NID is set in via_build_pcms */ 483 .ops = { 484 .open = via_dig_playback_pcm_open, 485 .close = via_dig_playback_pcm_close, 486 .prepare = via_dig_playback_pcm_prepare 487 }, 488 }; 489 490 static struct hda_pcm_stream vt1708_pcm_digital_capture = { 491 .substreams = 1, 492 .channels_min = 2, 493 .channels_max = 2, 494 }; 495 496 static int via_build_controls(struct hda_codec *codec) 497 { 498 struct via_spec *spec = codec->spec; 499 int err; 500 int i; 501 502 for (i = 0; i < spec->num_mixers; i++) { 503 err = snd_hda_add_new_ctls(codec, spec->mixers[i]); 504 if (err < 0) 505 return err; 506 } 507 508 if (spec->multiout.dig_out_nid) { 509 err = snd_hda_create_spdif_out_ctls(codec, 510 spec->multiout.dig_out_nid); 511 if (err < 0) 512 return err; 513 err = snd_hda_create_spdif_share_sw(codec, 514 &spec->multiout); 515 if (err < 0) 516 return err; 517 spec->multiout.share_spdif = 1; 518 } 519 if (spec->dig_in_nid) { 520 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid); 521 if (err < 0) 522 return err; 523 } 524 return 0; 525 } 526 527 static int via_build_pcms(struct hda_codec *codec) 528 { 529 struct via_spec *spec = codec->spec; 530 struct hda_pcm *info = spec->pcm_rec; 531 532 codec->num_pcms = 1; 533 codec->pcm_info = info; 534 535 info->name = spec->stream_name_analog; 536 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback); 537 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0]; 538 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture); 539 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; 540 541 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 542 spec->multiout.max_channels; 543 544 if (spec->multiout.dig_out_nid || spec->dig_in_nid) { 545 codec->num_pcms++; 546 info++; 547 info->name = spec->stream_name_digital; 548 info->pcm_type = HDA_PCM_TYPE_SPDIF; 549 if (spec->multiout.dig_out_nid) { 550 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 551 *(spec->stream_digital_playback); 552 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 553 spec->multiout.dig_out_nid; 554 } 555 if (spec->dig_in_nid) { 556 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 557 *(spec->stream_digital_capture); 558 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 559 spec->dig_in_nid; 560 } 561 } 562 563 return 0; 564 } 565 566 static void via_free(struct hda_codec *codec) 567 { 568 struct via_spec *spec = codec->spec; 569 unsigned int i; 570 571 if (!spec) 572 return; 573 574 if (spec->kctl_alloc) { 575 for (i = 0; i < spec->num_kctl_used; i++) 576 kfree(spec->kctl_alloc[i].name); 577 kfree(spec->kctl_alloc); 578 } 579 580 kfree(codec->spec); 581 } 582 583 static int via_init(struct hda_codec *codec) 584 { 585 struct via_spec *spec = codec->spec; 586 snd_hda_sequence_write(codec, spec->init_verbs); 587 /* Lydia Add for EAPD enable */ 588 if (!spec->dig_in_nid) { /* No Digital In connection */ 589 if (IS_VT1708_VENDORID(codec->vendor_id)) { 590 snd_hda_codec_write(codec, VT1708_DIGIN_PIN, 0, 591 AC_VERB_SET_PIN_WIDGET_CONTROL, 592 PIN_OUT); 593 snd_hda_codec_write(codec, VT1708_DIGIN_PIN, 0, 594 AC_VERB_SET_EAPD_BTLENABLE, 0x02); 595 } else if (IS_VT1709_10CH_VENDORID(codec->vendor_id) || 596 IS_VT1709_6CH_VENDORID(codec->vendor_id)) { 597 snd_hda_codec_write(codec, VT1709_DIGIN_PIN, 0, 598 AC_VERB_SET_PIN_WIDGET_CONTROL, 599 PIN_OUT); 600 snd_hda_codec_write(codec, VT1709_DIGIN_PIN, 0, 601 AC_VERB_SET_EAPD_BTLENABLE, 0x02); 602 } else if (IS_VT1708B_8CH_VENDORID(codec->vendor_id) || 603 IS_VT1708B_4CH_VENDORID(codec->vendor_id)) { 604 snd_hda_codec_write(codec, VT1708B_DIGIN_PIN, 0, 605 AC_VERB_SET_PIN_WIDGET_CONTROL, 606 PIN_OUT); 607 snd_hda_codec_write(codec, VT1708B_DIGIN_PIN, 0, 608 AC_VERB_SET_EAPD_BTLENABLE, 0x02); 609 } 610 } else /* enable SPDIF-input pin */ 611 snd_hda_codec_write(codec, spec->autocfg.dig_in_pin, 0, 612 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN); 613 614 return 0; 615 } 616 617 #ifdef CONFIG_SND_HDA_POWER_SAVE 618 static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid) 619 { 620 struct via_spec *spec = codec->spec; 621 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid); 622 } 623 #endif 624 625 /* 626 */ 627 static struct hda_codec_ops via_patch_ops = { 628 .build_controls = via_build_controls, 629 .build_pcms = via_build_pcms, 630 .init = via_init, 631 .free = via_free, 632 #ifdef CONFIG_SND_HDA_POWER_SAVE 633 .check_power_status = via_check_power_status, 634 #endif 635 }; 636 637 /* fill in the dac_nids table from the parsed pin configuration */ 638 static int vt1708_auto_fill_dac_nids(struct via_spec *spec, 639 const struct auto_pin_cfg *cfg) 640 { 641 int i; 642 hda_nid_t nid; 643 644 spec->multiout.num_dacs = cfg->line_outs; 645 646 spec->multiout.dac_nids = spec->private_dac_nids; 647 648 for(i = 0; i < 4; i++) { 649 nid = cfg->line_out_pins[i]; 650 if (nid) { 651 /* config dac list */ 652 switch (i) { 653 case AUTO_SEQ_FRONT: 654 spec->multiout.dac_nids[i] = 0x10; 655 break; 656 case AUTO_SEQ_CENLFE: 657 spec->multiout.dac_nids[i] = 0x12; 658 break; 659 case AUTO_SEQ_SURROUND: 660 spec->multiout.dac_nids[i] = 0x13; 661 break; 662 case AUTO_SEQ_SIDE: 663 spec->multiout.dac_nids[i] = 0x11; 664 break; 665 } 666 } 667 } 668 669 return 0; 670 } 671 672 /* add playback controls from the parsed DAC table */ 673 static int vt1708_auto_create_multi_out_ctls(struct via_spec *spec, 674 const struct auto_pin_cfg *cfg) 675 { 676 char name[32]; 677 static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" }; 678 hda_nid_t nid, nid_vol = 0; 679 int i, err; 680 681 for (i = 0; i <= AUTO_SEQ_SIDE; i++) { 682 nid = cfg->line_out_pins[i]; 683 684 if (!nid) 685 continue; 686 687 if (i != AUTO_SEQ_FRONT) 688 nid_vol = 0x1b - i + 1; 689 690 if (i == AUTO_SEQ_CENLFE) { 691 /* Center/LFE */ 692 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 693 "Center Playback Volume", 694 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, 695 HDA_OUTPUT)); 696 if (err < 0) 697 return err; 698 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 699 "LFE Playback Volume", 700 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, 701 HDA_OUTPUT)); 702 if (err < 0) 703 return err; 704 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 705 "Center Playback Switch", 706 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, 707 HDA_OUTPUT)); 708 if (err < 0) 709 return err; 710 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 711 "LFE Playback Switch", 712 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, 713 HDA_OUTPUT)); 714 if (err < 0) 715 return err; 716 } else if (i == AUTO_SEQ_FRONT){ 717 /* add control to mixer index 0 */ 718 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 719 "Master Front Playback Volume", 720 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, 721 HDA_INPUT)); 722 if (err < 0) 723 return err; 724 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 725 "Master Front Playback Switch", 726 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, 727 HDA_INPUT)); 728 if (err < 0) 729 return err; 730 731 /* add control to PW3 */ 732 sprintf(name, "%s Playback Volume", chname[i]); 733 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 734 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 735 HDA_OUTPUT)); 736 if (err < 0) 737 return err; 738 sprintf(name, "%s Playback Switch", chname[i]); 739 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 740 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 741 HDA_OUTPUT)); 742 if (err < 0) 743 return err; 744 } else { 745 sprintf(name, "%s Playback Volume", chname[i]); 746 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 747 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 748 HDA_OUTPUT)); 749 if (err < 0) 750 return err; 751 sprintf(name, "%s Playback Switch", chname[i]); 752 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 753 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 754 HDA_OUTPUT)); 755 if (err < 0) 756 return err; 757 } 758 } 759 760 return 0; 761 } 762 763 static int vt1708_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) 764 { 765 int err; 766 767 if (!pin) 768 return 0; 769 770 spec->multiout.hp_nid = VT1708_HP_NID; /* AOW3 */ 771 772 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 773 "Headphone Playback Volume", 774 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 775 if (err < 0) 776 return err; 777 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 778 "Headphone Playback Switch", 779 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 780 if (err < 0) 781 return err; 782 783 return 0; 784 } 785 786 /* create playback/capture controls for input pins */ 787 static int vt1708_auto_create_analog_input_ctls(struct via_spec *spec, 788 const struct auto_pin_cfg *cfg) 789 { 790 static char *labels[] = { 791 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL 792 }; 793 struct hda_input_mux *imux = &spec->private_imux; 794 int i, err, idx = 0; 795 796 /* for internal loopback recording select */ 797 imux->items[imux->num_items].label = "Stereo Mixer"; 798 imux->items[imux->num_items].index = idx; 799 imux->num_items++; 800 801 for (i = 0; i < AUTO_PIN_LAST; i++) { 802 if (!cfg->input_pins[i]) 803 continue; 804 805 switch (cfg->input_pins[i]) { 806 case 0x1d: /* Mic */ 807 idx = 2; 808 break; 809 810 case 0x1e: /* Line In */ 811 idx = 3; 812 break; 813 814 case 0x21: /* Front Mic */ 815 idx = 4; 816 break; 817 818 case 0x24: /* CD */ 819 idx = 1; 820 break; 821 } 822 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i], 823 idx, 0x17); 824 if (err < 0) 825 return err; 826 imux->items[imux->num_items].label = labels[i]; 827 imux->items[imux->num_items].index = idx; 828 imux->num_items++; 829 } 830 return 0; 831 } 832 833 #ifdef CONFIG_SND_HDA_POWER_SAVE 834 static struct hda_amp_list vt1708_loopbacks[] = { 835 { 0x17, HDA_INPUT, 1 }, 836 { 0x17, HDA_INPUT, 2 }, 837 { 0x17, HDA_INPUT, 3 }, 838 { 0x17, HDA_INPUT, 4 }, 839 { } /* end */ 840 }; 841 #endif 842 843 static int vt1708_parse_auto_config(struct hda_codec *codec) 844 { 845 struct via_spec *spec = codec->spec; 846 int err; 847 848 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); 849 if (err < 0) 850 return err; 851 err = vt1708_auto_fill_dac_nids(spec, &spec->autocfg); 852 if (err < 0) 853 return err; 854 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) 855 return 0; /* can't find valid BIOS pin config */ 856 857 err = vt1708_auto_create_multi_out_ctls(spec, &spec->autocfg); 858 if (err < 0) 859 return err; 860 err = vt1708_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); 861 if (err < 0) 862 return err; 863 err = vt1708_auto_create_analog_input_ctls(spec, &spec->autocfg); 864 if (err < 0) 865 return err; 866 867 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 868 869 if (spec->autocfg.dig_out_pin) 870 spec->multiout.dig_out_nid = VT1708_DIGOUT_NID; 871 if (spec->autocfg.dig_in_pin) 872 spec->dig_in_nid = VT1708_DIGIN_NID; 873 874 if (spec->kctl_alloc) 875 spec->mixers[spec->num_mixers++] = spec->kctl_alloc; 876 877 spec->init_verbs = vt1708_volume_init_verbs; 878 879 spec->input_mux = &spec->private_imux; 880 881 return 1; 882 } 883 884 /* init callback for auto-configuration model -- overriding the default init */ 885 static int via_auto_init(struct hda_codec *codec) 886 { 887 via_init(codec); 888 via_auto_init_multi_out(codec); 889 via_auto_init_hp_out(codec); 890 via_auto_init_analog_input(codec); 891 return 0; 892 } 893 894 static int patch_vt1708(struct hda_codec *codec) 895 { 896 struct via_spec *spec; 897 int err; 898 899 /* create a codec specific record */ 900 spec = kcalloc(1, sizeof(*spec), GFP_KERNEL); 901 if (spec == NULL) 902 return -ENOMEM; 903 904 codec->spec = spec; 905 906 /* automatic parse from the BIOS config */ 907 err = vt1708_parse_auto_config(codec); 908 if (err < 0) { 909 via_free(codec); 910 return err; 911 } else if (!err) { 912 printk(KERN_INFO "hda_codec: Cannot set up configuration " 913 "from BIOS. Using genenic mode...\n"); 914 } 915 916 917 spec->stream_name_analog = "VT1708 Analog"; 918 spec->stream_analog_playback = &vt1708_pcm_analog_playback; 919 /* disable 32bit format on VT1708 */ 920 if (codec->vendor_id == 0x11061708) 921 spec->stream_analog_playback = &vt1708_pcm_analog_s16_playback; 922 spec->stream_analog_capture = &vt1708_pcm_analog_capture; 923 924 spec->stream_name_digital = "VT1708 Digital"; 925 spec->stream_digital_playback = &vt1708_pcm_digital_playback; 926 spec->stream_digital_capture = &vt1708_pcm_digital_capture; 927 928 929 if (!spec->adc_nids && spec->input_mux) { 930 spec->adc_nids = vt1708_adc_nids; 931 spec->num_adc_nids = ARRAY_SIZE(vt1708_adc_nids); 932 spec->mixers[spec->num_mixers] = vt1708_capture_mixer; 933 spec->num_mixers++; 934 } 935 936 codec->patch_ops = via_patch_ops; 937 938 codec->patch_ops.init = via_auto_init; 939 #ifdef CONFIG_SND_HDA_POWER_SAVE 940 spec->loopback.amplist = vt1708_loopbacks; 941 #endif 942 943 return 0; 944 } 945 946 /* capture mixer elements */ 947 static struct snd_kcontrol_new vt1709_capture_mixer[] = { 948 HDA_CODEC_VOLUME("Capture Volume", 0x14, 0x0, HDA_INPUT), 949 HDA_CODEC_MUTE("Capture Switch", 0x14, 0x0, HDA_INPUT), 950 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x15, 0x0, HDA_INPUT), 951 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x15, 0x0, HDA_INPUT), 952 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x16, 0x0, HDA_INPUT), 953 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x16, 0x0, HDA_INPUT), 954 { 955 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 956 /* The multiple "Capture Source" controls confuse alsamixer 957 * So call somewhat different.. 958 */ 959 /* .name = "Capture Source", */ 960 .name = "Input Source", 961 .count = 1, 962 .info = via_mux_enum_info, 963 .get = via_mux_enum_get, 964 .put = via_mux_enum_put, 965 }, 966 { } /* end */ 967 }; 968 969 /* 970 * generic initialization of ADC, input mixers and output mixers 971 */ 972 static struct hda_verb vt1709_10ch_volume_init_verbs[] = { 973 /* 974 * Unmute ADC0-2 and set the default input to mic-in 975 */ 976 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 977 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 978 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 979 980 981 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 982 * mixer widget 983 */ 984 /* Amp Indices: AOW0=0, CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ 985 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 986 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 987 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 988 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 989 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 990 991 /* 992 * Set up output selector (0x1a, 0x1b, 0x29) 993 */ 994 /* set vol=0 to output mixers */ 995 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 996 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 997 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 998 999 /* 1000 * Unmute PW3 and PW4 1001 */ 1002 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1003 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1004 1005 /* Set input of PW4 as AOW4 */ 1006 {0x20, AC_VERB_SET_CONNECT_SEL, 0x1}, 1007 /* PW9 Output enable */ 1008 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 1009 { } 1010 }; 1011 1012 static struct hda_pcm_stream vt1709_10ch_pcm_analog_playback = { 1013 .substreams = 1, 1014 .channels_min = 2, 1015 .channels_max = 10, 1016 .nid = 0x10, /* NID to query formats and rates */ 1017 .ops = { 1018 .open = via_playback_pcm_open, 1019 .prepare = via_playback_pcm_prepare, 1020 .cleanup = via_playback_pcm_cleanup 1021 }, 1022 }; 1023 1024 static struct hda_pcm_stream vt1709_6ch_pcm_analog_playback = { 1025 .substreams = 1, 1026 .channels_min = 2, 1027 .channels_max = 6, 1028 .nid = 0x10, /* NID to query formats and rates */ 1029 .ops = { 1030 .open = via_playback_pcm_open, 1031 .prepare = via_playback_pcm_prepare, 1032 .cleanup = via_playback_pcm_cleanup 1033 }, 1034 }; 1035 1036 static struct hda_pcm_stream vt1709_pcm_analog_capture = { 1037 .substreams = 2, 1038 .channels_min = 2, 1039 .channels_max = 2, 1040 .nid = 0x14, /* NID to query formats and rates */ 1041 .ops = { 1042 .prepare = via_capture_pcm_prepare, 1043 .cleanup = via_capture_pcm_cleanup 1044 }, 1045 }; 1046 1047 static struct hda_pcm_stream vt1709_pcm_digital_playback = { 1048 .substreams = 1, 1049 .channels_min = 2, 1050 .channels_max = 2, 1051 /* NID is set in via_build_pcms */ 1052 .ops = { 1053 .open = via_dig_playback_pcm_open, 1054 .close = via_dig_playback_pcm_close 1055 }, 1056 }; 1057 1058 static struct hda_pcm_stream vt1709_pcm_digital_capture = { 1059 .substreams = 1, 1060 .channels_min = 2, 1061 .channels_max = 2, 1062 }; 1063 1064 static int vt1709_auto_fill_dac_nids(struct via_spec *spec, 1065 const struct auto_pin_cfg *cfg) 1066 { 1067 int i; 1068 hda_nid_t nid; 1069 1070 if (cfg->line_outs == 4) /* 10 channels */ 1071 spec->multiout.num_dacs = cfg->line_outs+1; /* AOW0~AOW4 */ 1072 else if (cfg->line_outs == 3) /* 6 channels */ 1073 spec->multiout.num_dacs = cfg->line_outs; /* AOW0~AOW2 */ 1074 1075 spec->multiout.dac_nids = spec->private_dac_nids; 1076 1077 if (cfg->line_outs == 4) { /* 10 channels */ 1078 for (i = 0; i < cfg->line_outs; i++) { 1079 nid = cfg->line_out_pins[i]; 1080 if (nid) { 1081 /* config dac list */ 1082 switch (i) { 1083 case AUTO_SEQ_FRONT: 1084 /* AOW0 */ 1085 spec->multiout.dac_nids[i] = 0x10; 1086 break; 1087 case AUTO_SEQ_CENLFE: 1088 /* AOW2 */ 1089 spec->multiout.dac_nids[i] = 0x12; 1090 break; 1091 case AUTO_SEQ_SURROUND: 1092 /* AOW3 */ 1093 spec->multiout.dac_nids[i] = 0x27; 1094 break; 1095 case AUTO_SEQ_SIDE: 1096 /* AOW1 */ 1097 spec->multiout.dac_nids[i] = 0x11; 1098 break; 1099 default: 1100 break; 1101 } 1102 } 1103 } 1104 spec->multiout.dac_nids[cfg->line_outs] = 0x28; /* AOW4 */ 1105 1106 } else if (cfg->line_outs == 3) { /* 6 channels */ 1107 for(i = 0; i < cfg->line_outs; i++) { 1108 nid = cfg->line_out_pins[i]; 1109 if (nid) { 1110 /* config dac list */ 1111 switch(i) { 1112 case AUTO_SEQ_FRONT: 1113 /* AOW0 */ 1114 spec->multiout.dac_nids[i] = 0x10; 1115 break; 1116 case AUTO_SEQ_CENLFE: 1117 /* AOW2 */ 1118 spec->multiout.dac_nids[i] = 0x12; 1119 break; 1120 case AUTO_SEQ_SURROUND: 1121 /* AOW1 */ 1122 spec->multiout.dac_nids[i] = 0x11; 1123 break; 1124 default: 1125 break; 1126 } 1127 } 1128 } 1129 } 1130 1131 return 0; 1132 } 1133 1134 /* add playback controls from the parsed DAC table */ 1135 static int vt1709_auto_create_multi_out_ctls(struct via_spec *spec, 1136 const struct auto_pin_cfg *cfg) 1137 { 1138 char name[32]; 1139 static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" }; 1140 hda_nid_t nid = 0; 1141 int i, err; 1142 1143 for (i = 0; i <= AUTO_SEQ_SIDE; i++) { 1144 nid = cfg->line_out_pins[i]; 1145 1146 if (!nid) 1147 continue; 1148 1149 if (i == AUTO_SEQ_CENLFE) { 1150 /* Center/LFE */ 1151 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 1152 "Center Playback Volume", 1153 HDA_COMPOSE_AMP_VAL(0x1b, 1, 0, 1154 HDA_OUTPUT)); 1155 if (err < 0) 1156 return err; 1157 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 1158 "LFE Playback Volume", 1159 HDA_COMPOSE_AMP_VAL(0x1b, 2, 0, 1160 HDA_OUTPUT)); 1161 if (err < 0) 1162 return err; 1163 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 1164 "Center Playback Switch", 1165 HDA_COMPOSE_AMP_VAL(0x1b, 1, 0, 1166 HDA_OUTPUT)); 1167 if (err < 0) 1168 return err; 1169 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 1170 "LFE Playback Switch", 1171 HDA_COMPOSE_AMP_VAL(0x1b, 2, 0, 1172 HDA_OUTPUT)); 1173 if (err < 0) 1174 return err; 1175 } else if (i == AUTO_SEQ_FRONT){ 1176 /* add control to mixer index 0 */ 1177 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 1178 "Master Front Playback Volume", 1179 HDA_COMPOSE_AMP_VAL(0x18, 3, 0, 1180 HDA_INPUT)); 1181 if (err < 0) 1182 return err; 1183 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 1184 "Master Front Playback Switch", 1185 HDA_COMPOSE_AMP_VAL(0x18, 3, 0, 1186 HDA_INPUT)); 1187 if (err < 0) 1188 return err; 1189 1190 /* add control to PW3 */ 1191 sprintf(name, "%s Playback Volume", chname[i]); 1192 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 1193 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 1194 HDA_OUTPUT)); 1195 if (err < 0) 1196 return err; 1197 sprintf(name, "%s Playback Switch", chname[i]); 1198 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 1199 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 1200 HDA_OUTPUT)); 1201 if (err < 0) 1202 return err; 1203 } else if (i == AUTO_SEQ_SURROUND) { 1204 sprintf(name, "%s Playback Volume", chname[i]); 1205 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 1206 HDA_COMPOSE_AMP_VAL(0x29, 3, 0, 1207 HDA_OUTPUT)); 1208 if (err < 0) 1209 return err; 1210 sprintf(name, "%s Playback Switch", chname[i]); 1211 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 1212 HDA_COMPOSE_AMP_VAL(0x29, 3, 0, 1213 HDA_OUTPUT)); 1214 if (err < 0) 1215 return err; 1216 } else if (i == AUTO_SEQ_SIDE) { 1217 sprintf(name, "%s Playback Volume", chname[i]); 1218 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 1219 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, 1220 HDA_OUTPUT)); 1221 if (err < 0) 1222 return err; 1223 sprintf(name, "%s Playback Switch", chname[i]); 1224 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 1225 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, 1226 HDA_OUTPUT)); 1227 if (err < 0) 1228 return err; 1229 } 1230 } 1231 1232 return 0; 1233 } 1234 1235 static int vt1709_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) 1236 { 1237 int err; 1238 1239 if (!pin) 1240 return 0; 1241 1242 if (spec->multiout.num_dacs == 5) /* 10 channels */ 1243 spec->multiout.hp_nid = VT1709_HP_DAC_NID; 1244 else if (spec->multiout.num_dacs == 3) /* 6 channels */ 1245 spec->multiout.hp_nid = 0; 1246 1247 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 1248 "Headphone Playback Volume", 1249 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 1250 if (err < 0) 1251 return err; 1252 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 1253 "Headphone Playback Switch", 1254 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 1255 if (err < 0) 1256 return err; 1257 1258 return 0; 1259 } 1260 1261 /* create playback/capture controls for input pins */ 1262 static int vt1709_auto_create_analog_input_ctls(struct via_spec *spec, 1263 const struct auto_pin_cfg *cfg) 1264 { 1265 static char *labels[] = { 1266 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL 1267 }; 1268 struct hda_input_mux *imux = &spec->private_imux; 1269 int i, err, idx = 0; 1270 1271 /* for internal loopback recording select */ 1272 imux->items[imux->num_items].label = "Stereo Mixer"; 1273 imux->items[imux->num_items].index = idx; 1274 imux->num_items++; 1275 1276 for (i = 0; i < AUTO_PIN_LAST; i++) { 1277 if (!cfg->input_pins[i]) 1278 continue; 1279 1280 switch (cfg->input_pins[i]) { 1281 case 0x1d: /* Mic */ 1282 idx = 2; 1283 break; 1284 1285 case 0x1e: /* Line In */ 1286 idx = 3; 1287 break; 1288 1289 case 0x21: /* Front Mic */ 1290 idx = 4; 1291 break; 1292 1293 case 0x23: /* CD */ 1294 idx = 1; 1295 break; 1296 } 1297 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i], 1298 idx, 0x18); 1299 if (err < 0) 1300 return err; 1301 imux->items[imux->num_items].label = labels[i]; 1302 imux->items[imux->num_items].index = idx; 1303 imux->num_items++; 1304 } 1305 return 0; 1306 } 1307 1308 static int vt1709_parse_auto_config(struct hda_codec *codec) 1309 { 1310 struct via_spec *spec = codec->spec; 1311 int err; 1312 1313 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); 1314 if (err < 0) 1315 return err; 1316 err = vt1709_auto_fill_dac_nids(spec, &spec->autocfg); 1317 if (err < 0) 1318 return err; 1319 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) 1320 return 0; /* can't find valid BIOS pin config */ 1321 1322 err = vt1709_auto_create_multi_out_ctls(spec, &spec->autocfg); 1323 if (err < 0) 1324 return err; 1325 err = vt1709_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); 1326 if (err < 0) 1327 return err; 1328 err = vt1709_auto_create_analog_input_ctls(spec, &spec->autocfg); 1329 if (err < 0) 1330 return err; 1331 1332 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 1333 1334 if (spec->autocfg.dig_out_pin) 1335 spec->multiout.dig_out_nid = VT1709_DIGOUT_NID; 1336 if (spec->autocfg.dig_in_pin) 1337 spec->dig_in_nid = VT1709_DIGIN_NID; 1338 1339 if (spec->kctl_alloc) 1340 spec->mixers[spec->num_mixers++] = spec->kctl_alloc; 1341 1342 spec->input_mux = &spec->private_imux; 1343 1344 return 1; 1345 } 1346 1347 #ifdef CONFIG_SND_HDA_POWER_SAVE 1348 static struct hda_amp_list vt1709_loopbacks[] = { 1349 { 0x18, HDA_INPUT, 1 }, 1350 { 0x18, HDA_INPUT, 2 }, 1351 { 0x18, HDA_INPUT, 3 }, 1352 { 0x18, HDA_INPUT, 4 }, 1353 { } /* end */ 1354 }; 1355 #endif 1356 1357 static int patch_vt1709_10ch(struct hda_codec *codec) 1358 { 1359 struct via_spec *spec; 1360 int err; 1361 1362 /* create a codec specific record */ 1363 spec = kcalloc(1, sizeof(*spec), GFP_KERNEL); 1364 if (spec == NULL) 1365 return -ENOMEM; 1366 1367 codec->spec = spec; 1368 1369 err = vt1709_parse_auto_config(codec); 1370 if (err < 0) { 1371 via_free(codec); 1372 return err; 1373 } else if (!err) { 1374 printk(KERN_INFO "hda_codec: Cannot set up configuration. " 1375 "Using genenic mode...\n"); 1376 } 1377 1378 spec->init_verbs = vt1709_10ch_volume_init_verbs; 1379 1380 spec->stream_name_analog = "VT1709 Analog"; 1381 spec->stream_analog_playback = &vt1709_10ch_pcm_analog_playback; 1382 spec->stream_analog_capture = &vt1709_pcm_analog_capture; 1383 1384 spec->stream_name_digital = "VT1709 Digital"; 1385 spec->stream_digital_playback = &vt1709_pcm_digital_playback; 1386 spec->stream_digital_capture = &vt1709_pcm_digital_capture; 1387 1388 1389 if (!spec->adc_nids && spec->input_mux) { 1390 spec->adc_nids = vt1709_adc_nids; 1391 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids); 1392 spec->mixers[spec->num_mixers] = vt1709_capture_mixer; 1393 spec->num_mixers++; 1394 } 1395 1396 codec->patch_ops = via_patch_ops; 1397 1398 codec->patch_ops.init = via_auto_init; 1399 #ifdef CONFIG_SND_HDA_POWER_SAVE 1400 spec->loopback.amplist = vt1709_loopbacks; 1401 #endif 1402 1403 return 0; 1404 } 1405 /* 1406 * generic initialization of ADC, input mixers and output mixers 1407 */ 1408 static struct hda_verb vt1709_6ch_volume_init_verbs[] = { 1409 /* 1410 * Unmute ADC0-2 and set the default input to mic-in 1411 */ 1412 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1413 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1414 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1415 1416 1417 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 1418 * mixer widget 1419 */ 1420 /* Amp Indices: AOW0=0, CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ 1421 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1422 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 1423 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 1424 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 1425 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 1426 1427 /* 1428 * Set up output selector (0x1a, 0x1b, 0x29) 1429 */ 1430 /* set vol=0 to output mixers */ 1431 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1432 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1433 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1434 1435 /* 1436 * Unmute PW3 and PW4 1437 */ 1438 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1439 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1440 1441 /* Set input of PW4 as MW0 */ 1442 {0x20, AC_VERB_SET_CONNECT_SEL, 0}, 1443 /* PW9 Output enable */ 1444 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 1445 { } 1446 }; 1447 1448 static int patch_vt1709_6ch(struct hda_codec *codec) 1449 { 1450 struct via_spec *spec; 1451 int err; 1452 1453 /* create a codec specific record */ 1454 spec = kcalloc(1, sizeof(*spec), GFP_KERNEL); 1455 if (spec == NULL) 1456 return -ENOMEM; 1457 1458 codec->spec = spec; 1459 1460 err = vt1709_parse_auto_config(codec); 1461 if (err < 0) { 1462 via_free(codec); 1463 return err; 1464 } else if (!err) { 1465 printk(KERN_INFO "hda_codec: Cannot set up configuration. " 1466 "Using genenic mode...\n"); 1467 } 1468 1469 spec->init_verbs = vt1709_6ch_volume_init_verbs; 1470 1471 spec->stream_name_analog = "VT1709 Analog"; 1472 spec->stream_analog_playback = &vt1709_6ch_pcm_analog_playback; 1473 spec->stream_analog_capture = &vt1709_pcm_analog_capture; 1474 1475 spec->stream_name_digital = "VT1709 Digital"; 1476 spec->stream_digital_playback = &vt1709_pcm_digital_playback; 1477 spec->stream_digital_capture = &vt1709_pcm_digital_capture; 1478 1479 1480 if (!spec->adc_nids && spec->input_mux) { 1481 spec->adc_nids = vt1709_adc_nids; 1482 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids); 1483 spec->mixers[spec->num_mixers] = vt1709_capture_mixer; 1484 spec->num_mixers++; 1485 } 1486 1487 codec->patch_ops = via_patch_ops; 1488 1489 codec->patch_ops.init = via_auto_init; 1490 #ifdef CONFIG_SND_HDA_POWER_SAVE 1491 spec->loopback.amplist = vt1709_loopbacks; 1492 #endif 1493 return 0; 1494 } 1495 1496 /* capture mixer elements */ 1497 static struct snd_kcontrol_new vt1708B_capture_mixer[] = { 1498 HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT), 1499 HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT), 1500 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT), 1501 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT), 1502 { 1503 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1504 /* The multiple "Capture Source" controls confuse alsamixer 1505 * So call somewhat different.. 1506 */ 1507 /* .name = "Capture Source", */ 1508 .name = "Input Source", 1509 .count = 1, 1510 .info = via_mux_enum_info, 1511 .get = via_mux_enum_get, 1512 .put = via_mux_enum_put, 1513 }, 1514 { } /* end */ 1515 }; 1516 /* 1517 * generic initialization of ADC, input mixers and output mixers 1518 */ 1519 static struct hda_verb vt1708B_8ch_volume_init_verbs[] = { 1520 /* 1521 * Unmute ADC0-1 and set the default input to mic-in 1522 */ 1523 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1524 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1525 1526 1527 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 1528 * mixer widget 1529 */ 1530 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ 1531 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1532 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 1533 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 1534 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 1535 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 1536 1537 /* 1538 * Set up output mixers 1539 */ 1540 /* set vol=0 to output mixers */ 1541 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1542 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1543 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1544 1545 /* Setup default input to PW4 */ 1546 {0x1d, AC_VERB_SET_CONNECT_SEL, 0x1}, 1547 /* PW9 Output enable */ 1548 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 1549 /* PW10 Input enable */ 1550 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 1551 { } 1552 }; 1553 1554 static struct hda_verb vt1708B_4ch_volume_init_verbs[] = { 1555 /* 1556 * Unmute ADC0-1 and set the default input to mic-in 1557 */ 1558 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1559 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1560 1561 1562 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 1563 * mixer widget 1564 */ 1565 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ 1566 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1567 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 1568 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 1569 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 1570 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 1571 1572 /* 1573 * Set up output mixers 1574 */ 1575 /* set vol=0 to output mixers */ 1576 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1577 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1578 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1579 1580 /* Setup default input of PW4 to MW0 */ 1581 {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0}, 1582 /* PW9 Output enable */ 1583 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 1584 /* PW10 Input enable */ 1585 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 1586 { } 1587 }; 1588 1589 static struct hda_pcm_stream vt1708B_8ch_pcm_analog_playback = { 1590 .substreams = 1, 1591 .channels_min = 2, 1592 .channels_max = 8, 1593 .nid = 0x10, /* NID to query formats and rates */ 1594 .ops = { 1595 .open = via_playback_pcm_open, 1596 .prepare = via_playback_pcm_prepare, 1597 .cleanup = via_playback_pcm_cleanup 1598 }, 1599 }; 1600 1601 static struct hda_pcm_stream vt1708B_4ch_pcm_analog_playback = { 1602 .substreams = 1, 1603 .channels_min = 2, 1604 .channels_max = 4, 1605 .nid = 0x10, /* NID to query formats and rates */ 1606 .ops = { 1607 .open = via_playback_pcm_open, 1608 .prepare = via_playback_pcm_prepare, 1609 .cleanup = via_playback_pcm_cleanup 1610 }, 1611 }; 1612 1613 static struct hda_pcm_stream vt1708B_pcm_analog_capture = { 1614 .substreams = 2, 1615 .channels_min = 2, 1616 .channels_max = 2, 1617 .nid = 0x13, /* NID to query formats and rates */ 1618 .ops = { 1619 .prepare = via_capture_pcm_prepare, 1620 .cleanup = via_capture_pcm_cleanup 1621 }, 1622 }; 1623 1624 static struct hda_pcm_stream vt1708B_pcm_digital_playback = { 1625 .substreams = 1, 1626 .channels_min = 2, 1627 .channels_max = 2, 1628 /* NID is set in via_build_pcms */ 1629 .ops = { 1630 .open = via_dig_playback_pcm_open, 1631 .close = via_dig_playback_pcm_close, 1632 .prepare = via_dig_playback_pcm_prepare 1633 }, 1634 }; 1635 1636 static struct hda_pcm_stream vt1708B_pcm_digital_capture = { 1637 .substreams = 1, 1638 .channels_min = 2, 1639 .channels_max = 2, 1640 }; 1641 1642 /* fill in the dac_nids table from the parsed pin configuration */ 1643 static int vt1708B_auto_fill_dac_nids(struct via_spec *spec, 1644 const struct auto_pin_cfg *cfg) 1645 { 1646 int i; 1647 hda_nid_t nid; 1648 1649 spec->multiout.num_dacs = cfg->line_outs; 1650 1651 spec->multiout.dac_nids = spec->private_dac_nids; 1652 1653 for (i = 0; i < 4; i++) { 1654 nid = cfg->line_out_pins[i]; 1655 if (nid) { 1656 /* config dac list */ 1657 switch (i) { 1658 case AUTO_SEQ_FRONT: 1659 spec->multiout.dac_nids[i] = 0x10; 1660 break; 1661 case AUTO_SEQ_CENLFE: 1662 spec->multiout.dac_nids[i] = 0x24; 1663 break; 1664 case AUTO_SEQ_SURROUND: 1665 spec->multiout.dac_nids[i] = 0x25; 1666 break; 1667 case AUTO_SEQ_SIDE: 1668 spec->multiout.dac_nids[i] = 0x11; 1669 break; 1670 } 1671 } 1672 } 1673 1674 return 0; 1675 } 1676 1677 /* add playback controls from the parsed DAC table */ 1678 static int vt1708B_auto_create_multi_out_ctls(struct via_spec *spec, 1679 const struct auto_pin_cfg *cfg) 1680 { 1681 char name[32]; 1682 static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" }; 1683 hda_nid_t nid_vols[] = {0x16, 0x27, 0x26, 0x18}; 1684 hda_nid_t nid, nid_vol = 0; 1685 int i, err; 1686 1687 for (i = 0; i <= AUTO_SEQ_SIDE; i++) { 1688 nid = cfg->line_out_pins[i]; 1689 1690 if (!nid) 1691 continue; 1692 1693 nid_vol = nid_vols[i]; 1694 1695 if (i == AUTO_SEQ_CENLFE) { 1696 /* Center/LFE */ 1697 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 1698 "Center Playback Volume", 1699 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, 1700 HDA_OUTPUT)); 1701 if (err < 0) 1702 return err; 1703 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 1704 "LFE Playback Volume", 1705 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, 1706 HDA_OUTPUT)); 1707 if (err < 0) 1708 return err; 1709 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 1710 "Center Playback Switch", 1711 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, 1712 HDA_OUTPUT)); 1713 if (err < 0) 1714 return err; 1715 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 1716 "LFE Playback Switch", 1717 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, 1718 HDA_OUTPUT)); 1719 if (err < 0) 1720 return err; 1721 } else if (i == AUTO_SEQ_FRONT) { 1722 /* add control to mixer index 0 */ 1723 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 1724 "Master Front Playback Volume", 1725 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 1726 HDA_INPUT)); 1727 if (err < 0) 1728 return err; 1729 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 1730 "Master Front Playback Switch", 1731 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 1732 HDA_INPUT)); 1733 if (err < 0) 1734 return err; 1735 1736 /* add control to PW3 */ 1737 sprintf(name, "%s Playback Volume", chname[i]); 1738 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 1739 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 1740 HDA_OUTPUT)); 1741 if (err < 0) 1742 return err; 1743 sprintf(name, "%s Playback Switch", chname[i]); 1744 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 1745 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 1746 HDA_OUTPUT)); 1747 if (err < 0) 1748 return err; 1749 } else { 1750 sprintf(name, "%s Playback Volume", chname[i]); 1751 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 1752 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 1753 HDA_OUTPUT)); 1754 if (err < 0) 1755 return err; 1756 sprintf(name, "%s Playback Switch", chname[i]); 1757 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 1758 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 1759 HDA_OUTPUT)); 1760 if (err < 0) 1761 return err; 1762 } 1763 } 1764 1765 return 0; 1766 } 1767 1768 static int vt1708B_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) 1769 { 1770 int err; 1771 1772 if (!pin) 1773 return 0; 1774 1775 spec->multiout.hp_nid = VT1708B_HP_NID; /* AOW3 */ 1776 1777 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 1778 "Headphone Playback Volume", 1779 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 1780 if (err < 0) 1781 return err; 1782 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 1783 "Headphone Playback Switch", 1784 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 1785 if (err < 0) 1786 return err; 1787 1788 return 0; 1789 } 1790 1791 /* create playback/capture controls for input pins */ 1792 static int vt1708B_auto_create_analog_input_ctls(struct via_spec *spec, 1793 const struct auto_pin_cfg *cfg) 1794 { 1795 static char *labels[] = { 1796 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL 1797 }; 1798 struct hda_input_mux *imux = &spec->private_imux; 1799 int i, err, idx = 0; 1800 1801 /* for internal loopback recording select */ 1802 imux->items[imux->num_items].label = "Stereo Mixer"; 1803 imux->items[imux->num_items].index = idx; 1804 imux->num_items++; 1805 1806 for (i = 0; i < AUTO_PIN_LAST; i++) { 1807 if (!cfg->input_pins[i]) 1808 continue; 1809 1810 switch (cfg->input_pins[i]) { 1811 case 0x1a: /* Mic */ 1812 idx = 2; 1813 break; 1814 1815 case 0x1b: /* Line In */ 1816 idx = 3; 1817 break; 1818 1819 case 0x1e: /* Front Mic */ 1820 idx = 4; 1821 break; 1822 1823 case 0x1f: /* CD */ 1824 idx = 1; 1825 break; 1826 } 1827 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i], 1828 idx, 0x16); 1829 if (err < 0) 1830 return err; 1831 imux->items[imux->num_items].label = labels[i]; 1832 imux->items[imux->num_items].index = idx; 1833 imux->num_items++; 1834 } 1835 return 0; 1836 } 1837 1838 static int vt1708B_parse_auto_config(struct hda_codec *codec) 1839 { 1840 struct via_spec *spec = codec->spec; 1841 int err; 1842 1843 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); 1844 if (err < 0) 1845 return err; 1846 err = vt1708B_auto_fill_dac_nids(spec, &spec->autocfg); 1847 if (err < 0) 1848 return err; 1849 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) 1850 return 0; /* can't find valid BIOS pin config */ 1851 1852 err = vt1708B_auto_create_multi_out_ctls(spec, &spec->autocfg); 1853 if (err < 0) 1854 return err; 1855 err = vt1708B_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); 1856 if (err < 0) 1857 return err; 1858 err = vt1708B_auto_create_analog_input_ctls(spec, &spec->autocfg); 1859 if (err < 0) 1860 return err; 1861 1862 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 1863 1864 if (spec->autocfg.dig_out_pin) 1865 spec->multiout.dig_out_nid = VT1708B_DIGOUT_NID; 1866 if (spec->autocfg.dig_in_pin) 1867 spec->dig_in_nid = VT1708B_DIGIN_NID; 1868 1869 if (spec->kctl_alloc) 1870 spec->mixers[spec->num_mixers++] = spec->kctl_alloc; 1871 1872 spec->input_mux = &spec->private_imux; 1873 1874 return 1; 1875 } 1876 1877 #ifdef CONFIG_SND_HDA_POWER_SAVE 1878 static struct hda_amp_list vt1708B_loopbacks[] = { 1879 { 0x16, HDA_INPUT, 1 }, 1880 { 0x16, HDA_INPUT, 2 }, 1881 { 0x16, HDA_INPUT, 3 }, 1882 { 0x16, HDA_INPUT, 4 }, 1883 { } /* end */ 1884 }; 1885 #endif 1886 1887 static int patch_vt1708B_8ch(struct hda_codec *codec) 1888 { 1889 struct via_spec *spec; 1890 int err; 1891 1892 /* create a codec specific record */ 1893 spec = kcalloc(1, sizeof(*spec), GFP_KERNEL); 1894 if (spec == NULL) 1895 return -ENOMEM; 1896 1897 codec->spec = spec; 1898 1899 /* automatic parse from the BIOS config */ 1900 err = vt1708B_parse_auto_config(codec); 1901 if (err < 0) { 1902 via_free(codec); 1903 return err; 1904 } else if (!err) { 1905 printk(KERN_INFO "hda_codec: Cannot set up configuration " 1906 "from BIOS. Using genenic mode...\n"); 1907 } 1908 1909 spec->init_verbs = vt1708B_8ch_volume_init_verbs; 1910 1911 spec->stream_name_analog = "VT1708B Analog"; 1912 spec->stream_analog_playback = &vt1708B_8ch_pcm_analog_playback; 1913 spec->stream_analog_capture = &vt1708B_pcm_analog_capture; 1914 1915 spec->stream_name_digital = "VT1708B Digital"; 1916 spec->stream_digital_playback = &vt1708B_pcm_digital_playback; 1917 spec->stream_digital_capture = &vt1708B_pcm_digital_capture; 1918 1919 if (!spec->adc_nids && spec->input_mux) { 1920 spec->adc_nids = vt1708B_adc_nids; 1921 spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids); 1922 spec->mixers[spec->num_mixers] = vt1708B_capture_mixer; 1923 spec->num_mixers++; 1924 } 1925 1926 codec->patch_ops = via_patch_ops; 1927 1928 codec->patch_ops.init = via_auto_init; 1929 #ifdef CONFIG_SND_HDA_POWER_SAVE 1930 spec->loopback.amplist = vt1708B_loopbacks; 1931 #endif 1932 1933 return 0; 1934 } 1935 1936 static int patch_vt1708B_4ch(struct hda_codec *codec) 1937 { 1938 struct via_spec *spec; 1939 int err; 1940 1941 /* create a codec specific record */ 1942 spec = kcalloc(1, sizeof(*spec), GFP_KERNEL); 1943 if (spec == NULL) 1944 return -ENOMEM; 1945 1946 codec->spec = spec; 1947 1948 /* automatic parse from the BIOS config */ 1949 err = vt1708B_parse_auto_config(codec); 1950 if (err < 0) { 1951 via_free(codec); 1952 return err; 1953 } else if (!err) { 1954 printk(KERN_INFO "hda_codec: Cannot set up configuration " 1955 "from BIOS. Using genenic mode...\n"); 1956 } 1957 1958 spec->init_verbs = vt1708B_4ch_volume_init_verbs; 1959 1960 spec->stream_name_analog = "VT1708B Analog"; 1961 spec->stream_analog_playback = &vt1708B_4ch_pcm_analog_playback; 1962 spec->stream_analog_capture = &vt1708B_pcm_analog_capture; 1963 1964 spec->stream_name_digital = "VT1708B Digital"; 1965 spec->stream_digital_playback = &vt1708B_pcm_digital_playback; 1966 spec->stream_digital_capture = &vt1708B_pcm_digital_capture; 1967 1968 if (!spec->adc_nids && spec->input_mux) { 1969 spec->adc_nids = vt1708B_adc_nids; 1970 spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids); 1971 spec->mixers[spec->num_mixers] = vt1708B_capture_mixer; 1972 spec->num_mixers++; 1973 } 1974 1975 codec->patch_ops = via_patch_ops; 1976 1977 codec->patch_ops.init = via_auto_init; 1978 #ifdef CONFIG_SND_HDA_POWER_SAVE 1979 spec->loopback.amplist = vt1708B_loopbacks; 1980 #endif 1981 1982 return 0; 1983 } 1984 1985 /* 1986 * patch entries 1987 */ 1988 struct hda_codec_preset snd_hda_preset_via[] = { 1989 { .id = 0x11061708, .name = "VIA VT1708", .patch = patch_vt1708}, 1990 { .id = 0x11061709, .name = "VIA VT1708", .patch = patch_vt1708}, 1991 { .id = 0x1106170A, .name = "VIA VT1708", .patch = patch_vt1708}, 1992 { .id = 0x1106170B, .name = "VIA VT1708", .patch = patch_vt1708}, 1993 { .id = 0x1106E710, .name = "VIA VT1709 10-Ch", 1994 .patch = patch_vt1709_10ch}, 1995 { .id = 0x1106E711, .name = "VIA VT1709 10-Ch", 1996 .patch = patch_vt1709_10ch}, 1997 { .id = 0x1106E712, .name = "VIA VT1709 10-Ch", 1998 .patch = patch_vt1709_10ch}, 1999 { .id = 0x1106E713, .name = "VIA VT1709 10-Ch", 2000 .patch = patch_vt1709_10ch}, 2001 { .id = 0x1106E714, .name = "VIA VT1709 6-Ch", 2002 .patch = patch_vt1709_6ch}, 2003 { .id = 0x1106E715, .name = "VIA VT1709 6-Ch", 2004 .patch = patch_vt1709_6ch}, 2005 { .id = 0x1106E716, .name = "VIA VT1709 6-Ch", 2006 .patch = patch_vt1709_6ch}, 2007 { .id = 0x1106E717, .name = "VIA VT1709 6-Ch", 2008 .patch = patch_vt1709_6ch}, 2009 { .id = 0x1106E720, .name = "VIA VT1708B 8-Ch", 2010 .patch = patch_vt1708B_8ch}, 2011 { .id = 0x1106E721, .name = "VIA VT1708B 8-Ch", 2012 .patch = patch_vt1708B_8ch}, 2013 { .id = 0x1106E722, .name = "VIA VT1708B 8-Ch", 2014 .patch = patch_vt1708B_8ch}, 2015 { .id = 0x1106E723, .name = "VIA VT1708B 8-Ch", 2016 .patch = patch_vt1708B_8ch}, 2017 { .id = 0x1106E724, .name = "VIA VT1708B 4-Ch", 2018 .patch = patch_vt1708B_4ch}, 2019 { .id = 0x1106E725, .name = "VIA VT1708B 4-Ch", 2020 .patch = patch_vt1708B_4ch}, 2021 { .id = 0x1106E726, .name = "VIA VT1708B 4-Ch", 2022 .patch = patch_vt1708B_4ch}, 2023 { .id = 0x1106E727, .name = "VIA VT1708B 4-Ch", 2024 .patch = patch_vt1708B_4ch}, 2025 {} /* terminator */ 2026 }; 2027