1 /* 2 * Universal Interface for Intel High Definition Audio Codec 3 * 4 * HD audio interface patch for VIA VT1702/VT1708/VT1709 codec 5 * 6 * Copyright (c) 2006-2008 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 /* 2007-11-14 Lydia Wang Add VT1708A codec HP and CD pin connect config */ 33 /* 2008-02-03 Lydia Wang Fix Rear channels and Back channels inverse issue */ 34 /* 2008-03-06 Lydia Wang Add VT1702 codec and VT1708S codec support */ 35 /* 2008-04-09 Lydia Wang Add mute front speaker when HP plugin */ 36 /* 2008-04-09 Lydia Wang Add Independent HP feature */ 37 /* 2008-05-28 Lydia Wang Add second S/PDIF Out support for VT1702 */ 38 /* 2008-09-15 Logan Li Add VT1708S Mic Boost workaround/backdoor */ 39 /* */ 40 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 41 42 43 #include <linux/init.h> 44 #include <linux/delay.h> 45 #include <linux/slab.h> 46 #include <sound/core.h> 47 #include <sound/asoundef.h> 48 #include "hda_codec.h" 49 #include "hda_local.h" 50 51 /* amp values */ 52 #define AMP_VAL_IDX_SHIFT 19 53 #define AMP_VAL_IDX_MASK (0x0f<<19) 54 55 /* Pin Widget NID */ 56 #define VT1708_HP_NID 0x13 57 #define VT1708_DIGOUT_NID 0x14 58 #define VT1708_DIGIN_NID 0x16 59 #define VT1708_DIGIN_PIN 0x26 60 #define VT1708_HP_PIN_NID 0x20 61 #define VT1708_CD_PIN_NID 0x24 62 63 #define VT1709_HP_DAC_NID 0x28 64 #define VT1709_DIGOUT_NID 0x13 65 #define VT1709_DIGIN_NID 0x17 66 #define VT1709_DIGIN_PIN 0x25 67 68 #define VT1708B_HP_NID 0x25 69 #define VT1708B_DIGOUT_NID 0x12 70 #define VT1708B_DIGIN_NID 0x15 71 #define VT1708B_DIGIN_PIN 0x21 72 73 #define VT1708S_HP_NID 0x25 74 #define VT1708S_DIGOUT_NID 0x12 75 76 #define VT1702_HP_NID 0x17 77 #define VT1702_DIGOUT_NID 0x11 78 79 #define IS_VT1708_VENDORID(x) ((x) >= 0x11061708 && (x) <= 0x1106170b) 80 #define IS_VT1709_10CH_VENDORID(x) ((x) >= 0x1106e710 && (x) <= 0x1106e713) 81 #define IS_VT1709_6CH_VENDORID(x) ((x) >= 0x1106e714 && (x) <= 0x1106e717) 82 #define IS_VT1708B_8CH_VENDORID(x) ((x) >= 0x1106e720 && (x) <= 0x1106e723) 83 #define IS_VT1708B_4CH_VENDORID(x) ((x) >= 0x1106e724 && (x) <= 0x1106e727) 84 #define IS_VT1708S_VENDORID(x) ((x) >= 0x11060397 && (x) <= 0x11067397) 85 #define IS_VT1702_VENDORID(x) ((x) >= 0x11060398 && (x) <= 0x11067398) 86 87 enum VIA_HDA_CODEC { 88 UNKNOWN = -1, 89 VT1708, 90 VT1709_10CH, 91 VT1709_6CH, 92 VT1708B_8CH, 93 VT1708B_4CH, 94 VT1708S, 95 VT1702, 96 CODEC_TYPES, 97 }; 98 99 static enum VIA_HDA_CODEC get_codec_type(u32 vendor_id) 100 { 101 u16 ven_id = vendor_id >> 16; 102 u16 dev_id = vendor_id & 0xffff; 103 enum VIA_HDA_CODEC codec_type; 104 105 /* get codec type */ 106 if (ven_id != 0x1106) 107 codec_type = UNKNOWN; 108 else if (dev_id >= 0x1708 && dev_id <= 0x170b) 109 codec_type = VT1708; 110 else if (dev_id >= 0xe710 && dev_id <= 0xe713) 111 codec_type = VT1709_10CH; 112 else if (dev_id >= 0xe714 && dev_id <= 0xe717) 113 codec_type = VT1709_6CH; 114 else if (dev_id >= 0xe720 && dev_id <= 0xe723) 115 codec_type = VT1708B_8CH; 116 else if (dev_id >= 0xe724 && dev_id <= 0xe727) 117 codec_type = VT1708B_4CH; 118 else if ((dev_id & 0xfff) == 0x397 119 && (dev_id >> 12) < 8) 120 codec_type = VT1708S; 121 else if ((dev_id & 0xfff) == 0x398 122 && (dev_id >> 12) < 8) 123 codec_type = VT1702; 124 else 125 codec_type = UNKNOWN; 126 return codec_type; 127 }; 128 129 #define VIA_HP_EVENT 0x01 130 #define VIA_GPIO_EVENT 0x02 131 132 enum { 133 VIA_CTL_WIDGET_VOL, 134 VIA_CTL_WIDGET_MUTE, 135 }; 136 137 enum { 138 AUTO_SEQ_FRONT = 0, 139 AUTO_SEQ_SURROUND, 140 AUTO_SEQ_CENLFE, 141 AUTO_SEQ_SIDE 142 }; 143 144 /* Some VT1708S based boards gets the micboost setting wrong, so we have 145 * to apply some brute-force and re-write the TLV's by software. */ 146 static int mic_boost_tlv(struct snd_kcontrol *kcontrol, int op_flag, 147 unsigned int size, unsigned int __user *_tlv) 148 { 149 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 150 hda_nid_t nid = get_amp_nid(kcontrol); 151 152 if (get_codec_type(codec->vendor_id) == VT1708S 153 && (nid == 0x1a || nid == 0x1e)) { 154 if (size < 4 * sizeof(unsigned int)) 155 return -ENOMEM; 156 if (put_user(1, _tlv)) /* SNDRV_CTL_TLVT_DB_SCALE */ 157 return -EFAULT; 158 if (put_user(2 * sizeof(unsigned int), _tlv + 1)) 159 return -EFAULT; 160 if (put_user(0, _tlv + 2)) /* offset = 0 */ 161 return -EFAULT; 162 if (put_user(1000, _tlv + 3)) /* step size = 10 dB */ 163 return -EFAULT; 164 } 165 return 0; 166 } 167 168 static int mic_boost_volume_info(struct snd_kcontrol *kcontrol, 169 struct snd_ctl_elem_info *uinfo) 170 { 171 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 172 hda_nid_t nid = get_amp_nid(kcontrol); 173 174 if (get_codec_type(codec->vendor_id) == VT1708S 175 && (nid == 0x1a || nid == 0x1e)) { 176 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 177 uinfo->count = 2; 178 uinfo->value.integer.min = 0; 179 uinfo->value.integer.max = 3; 180 } 181 return 0; 182 } 183 184 static struct snd_kcontrol_new vt1708_control_templates[] = { 185 HDA_CODEC_VOLUME(NULL, 0, 0, 0), 186 HDA_CODEC_MUTE(NULL, 0, 0, 0), 187 }; 188 189 190 struct via_spec { 191 /* codec parameterization */ 192 struct snd_kcontrol_new *mixers[3]; 193 unsigned int num_mixers; 194 195 struct hda_verb *init_verbs[5]; 196 unsigned int num_iverbs; 197 198 char *stream_name_analog; 199 struct hda_pcm_stream *stream_analog_playback; 200 struct hda_pcm_stream *stream_analog_capture; 201 202 char *stream_name_digital; 203 struct hda_pcm_stream *stream_digital_playback; 204 struct hda_pcm_stream *stream_digital_capture; 205 206 /* playback */ 207 struct hda_multi_out multiout; 208 hda_nid_t extra_dig_out_nid; 209 210 /* capture */ 211 unsigned int num_adc_nids; 212 hda_nid_t *adc_nids; 213 hda_nid_t dig_in_nid; 214 215 /* capture source */ 216 const struct hda_input_mux *input_mux; 217 unsigned int cur_mux[3]; 218 219 /* PCM information */ 220 struct hda_pcm pcm_rec[3]; 221 222 /* dynamic controls, init_verbs and input_mux */ 223 struct auto_pin_cfg autocfg; 224 struct snd_array kctls; 225 struct hda_input_mux private_imux[2]; 226 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS]; 227 228 /* HP mode source */ 229 const struct hda_input_mux *hp_mux; 230 unsigned int hp_independent_mode; 231 232 #ifdef CONFIG_SND_HDA_POWER_SAVE 233 struct hda_loopback_check loopback; 234 #endif 235 }; 236 237 static hda_nid_t vt1708_adc_nids[2] = { 238 /* ADC1-2 */ 239 0x15, 0x27 240 }; 241 242 static hda_nid_t vt1709_adc_nids[3] = { 243 /* ADC1-2 */ 244 0x14, 0x15, 0x16 245 }; 246 247 static hda_nid_t vt1708B_adc_nids[2] = { 248 /* ADC1-2 */ 249 0x13, 0x14 250 }; 251 252 static hda_nid_t vt1708S_adc_nids[2] = { 253 /* ADC1-2 */ 254 0x13, 0x14 255 }; 256 257 static hda_nid_t vt1702_adc_nids[3] = { 258 /* ADC1-2 */ 259 0x12, 0x20, 0x1F 260 }; 261 262 /* add dynamic controls */ 263 static int via_add_control(struct via_spec *spec, int type, const char *name, 264 unsigned long val) 265 { 266 struct snd_kcontrol_new *knew; 267 268 snd_array_init(&spec->kctls, sizeof(*knew), 32); 269 knew = snd_array_new(&spec->kctls); 270 if (!knew) 271 return -ENOMEM; 272 *knew = vt1708_control_templates[type]; 273 knew->name = kstrdup(name, GFP_KERNEL); 274 if (!knew->name) 275 return -ENOMEM; 276 knew->private_value = val; 277 return 0; 278 } 279 280 static void via_free_kctls(struct hda_codec *codec) 281 { 282 struct via_spec *spec = codec->spec; 283 284 if (spec->kctls.list) { 285 struct snd_kcontrol_new *kctl = spec->kctls.list; 286 int i; 287 for (i = 0; i < spec->kctls.used; i++) 288 kfree(kctl[i].name); 289 } 290 snd_array_free(&spec->kctls); 291 } 292 293 /* create input playback/capture controls for the given pin */ 294 static int via_new_analog_input(struct via_spec *spec, hda_nid_t pin, 295 const char *ctlname, int idx, int mix_nid) 296 { 297 char name[32]; 298 int err; 299 300 sprintf(name, "%s Playback Volume", ctlname); 301 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 302 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); 303 if (err < 0) 304 return err; 305 sprintf(name, "%s Playback Switch", ctlname); 306 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 307 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); 308 if (err < 0) 309 return err; 310 return 0; 311 } 312 313 static void via_auto_set_output_and_unmute(struct hda_codec *codec, 314 hda_nid_t nid, int pin_type, 315 int dac_idx) 316 { 317 /* set as output */ 318 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 319 pin_type); 320 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, 321 AMP_OUT_UNMUTE); 322 } 323 324 325 static void via_auto_init_multi_out(struct hda_codec *codec) 326 { 327 struct via_spec *spec = codec->spec; 328 int i; 329 330 for (i = 0; i <= AUTO_SEQ_SIDE; i++) { 331 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 332 if (nid) 333 via_auto_set_output_and_unmute(codec, nid, PIN_OUT, i); 334 } 335 } 336 337 static void via_auto_init_hp_out(struct hda_codec *codec) 338 { 339 struct via_spec *spec = codec->spec; 340 hda_nid_t pin; 341 342 pin = spec->autocfg.hp_pins[0]; 343 if (pin) /* connect to front */ 344 via_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 345 } 346 347 static void via_auto_init_analog_input(struct hda_codec *codec) 348 { 349 struct via_spec *spec = codec->spec; 350 int i; 351 352 for (i = 0; i < AUTO_PIN_LAST; i++) { 353 hda_nid_t nid = spec->autocfg.input_pins[i]; 354 355 snd_hda_codec_write(codec, nid, 0, 356 AC_VERB_SET_PIN_WIDGET_CONTROL, 357 (i <= AUTO_PIN_FRONT_MIC ? 358 PIN_VREF50 : PIN_IN)); 359 360 } 361 } 362 /* 363 * input MUX handling 364 */ 365 static int via_mux_enum_info(struct snd_kcontrol *kcontrol, 366 struct snd_ctl_elem_info *uinfo) 367 { 368 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 369 struct via_spec *spec = codec->spec; 370 return snd_hda_input_mux_info(spec->input_mux, uinfo); 371 } 372 373 static int via_mux_enum_get(struct snd_kcontrol *kcontrol, 374 struct snd_ctl_elem_value *ucontrol) 375 { 376 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 377 struct via_spec *spec = codec->spec; 378 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 379 380 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx]; 381 return 0; 382 } 383 384 static int via_mux_enum_put(struct snd_kcontrol *kcontrol, 385 struct snd_ctl_elem_value *ucontrol) 386 { 387 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 388 struct via_spec *spec = codec->spec; 389 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 390 unsigned int vendor_id = codec->vendor_id; 391 392 /* AIW0 lydia 060801 add for correct sw0 input select */ 393 if (IS_VT1708_VENDORID(vendor_id) && (adc_idx == 0)) 394 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol, 395 0x18, &spec->cur_mux[adc_idx]); 396 else if ((IS_VT1709_10CH_VENDORID(vendor_id) || 397 IS_VT1709_6CH_VENDORID(vendor_id)) && (adc_idx == 0)) 398 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol, 399 0x19, &spec->cur_mux[adc_idx]); 400 else if ((IS_VT1708B_8CH_VENDORID(vendor_id) || 401 IS_VT1708B_4CH_VENDORID(vendor_id)) && (adc_idx == 0)) 402 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol, 403 0x17, &spec->cur_mux[adc_idx]); 404 else if (IS_VT1702_VENDORID(vendor_id) && (adc_idx == 0)) 405 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol, 406 0x13, &spec->cur_mux[adc_idx]); 407 else 408 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol, 409 spec->adc_nids[adc_idx], 410 &spec->cur_mux[adc_idx]); 411 } 412 413 static int via_independent_hp_info(struct snd_kcontrol *kcontrol, 414 struct snd_ctl_elem_info *uinfo) 415 { 416 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 417 struct via_spec *spec = codec->spec; 418 return snd_hda_input_mux_info(spec->hp_mux, uinfo); 419 } 420 421 static int via_independent_hp_get(struct snd_kcontrol *kcontrol, 422 struct snd_ctl_elem_value *ucontrol) 423 { 424 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 425 struct via_spec *spec = codec->spec; 426 hda_nid_t nid = spec->autocfg.hp_pins[0]; 427 unsigned int pinsel = snd_hda_codec_read(codec, nid, 0, 428 AC_VERB_GET_CONNECT_SEL, 429 0x00); 430 431 ucontrol->value.enumerated.item[0] = pinsel; 432 433 return 0; 434 } 435 436 static int via_independent_hp_put(struct snd_kcontrol *kcontrol, 437 struct snd_ctl_elem_value *ucontrol) 438 { 439 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 440 struct via_spec *spec = codec->spec; 441 hda_nid_t nid = spec->autocfg.hp_pins[0]; 442 unsigned int pinsel = ucontrol->value.enumerated.item[0]; 443 unsigned int con_nid = snd_hda_codec_read(codec, nid, 0, 444 AC_VERB_GET_CONNECT_LIST, 0) & 0xff; 445 446 if (con_nid == spec->multiout.hp_nid) { 447 if (pinsel == 0) { 448 if (!spec->hp_independent_mode) { 449 if (spec->multiout.num_dacs > 1) 450 spec->multiout.num_dacs -= 1; 451 spec->hp_independent_mode = 1; 452 } 453 } else if (pinsel == 1) { 454 if (spec->hp_independent_mode) { 455 if (spec->multiout.num_dacs > 1) 456 spec->multiout.num_dacs += 1; 457 spec->hp_independent_mode = 0; 458 } 459 } 460 } else { 461 if (pinsel == 0) { 462 if (spec->hp_independent_mode) { 463 if (spec->multiout.num_dacs > 1) 464 spec->multiout.num_dacs += 1; 465 spec->hp_independent_mode = 0; 466 } 467 } else if (pinsel == 1) { 468 if (!spec->hp_independent_mode) { 469 if (spec->multiout.num_dacs > 1) 470 spec->multiout.num_dacs -= 1; 471 spec->hp_independent_mode = 1; 472 } 473 } 474 } 475 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, 476 pinsel); 477 478 if (spec->multiout.hp_nid && 479 spec->multiout.hp_nid != spec->multiout.dac_nids[HDA_FRONT]) 480 snd_hda_codec_setup_stream(codec, 481 spec->multiout.hp_nid, 482 0, 0, 0); 483 484 return 0; 485 } 486 487 static struct snd_kcontrol_new via_hp_mixer[] = { 488 { 489 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 490 .name = "Independent HP", 491 .count = 1, 492 .info = via_independent_hp_info, 493 .get = via_independent_hp_get, 494 .put = via_independent_hp_put, 495 }, 496 { } /* end */ 497 }; 498 499 /* capture mixer elements */ 500 static struct snd_kcontrol_new vt1708_capture_mixer[] = { 501 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_INPUT), 502 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_INPUT), 503 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x27, 0x0, HDA_INPUT), 504 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x27, 0x0, HDA_INPUT), 505 { 506 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 507 /* The multiple "Capture Source" controls confuse alsamixer 508 * So call somewhat different.. 509 */ 510 /* .name = "Capture Source", */ 511 .name = "Input Source", 512 .count = 1, 513 .info = via_mux_enum_info, 514 .get = via_mux_enum_get, 515 .put = via_mux_enum_put, 516 }, 517 { } /* end */ 518 }; 519 /* 520 * generic initialization of ADC, input mixers and output mixers 521 */ 522 static struct hda_verb vt1708_volume_init_verbs[] = { 523 /* 524 * Unmute ADC0-1 and set the default input to mic-in 525 */ 526 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 527 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 528 529 530 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 531 * mixer widget 532 */ 533 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ 534 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 535 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 536 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 537 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 538 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 539 540 /* 541 * Set up output mixers (0x19 - 0x1b) 542 */ 543 /* set vol=0 to output mixers */ 544 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 545 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 546 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 547 548 /* Setup default input to PW4 */ 549 {0x20, AC_VERB_SET_CONNECT_SEL, 0x1}, 550 /* PW9 Output enable */ 551 {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 552 { } 553 }; 554 555 static int via_playback_pcm_open(struct hda_pcm_stream *hinfo, 556 struct hda_codec *codec, 557 struct snd_pcm_substream *substream) 558 { 559 struct via_spec *spec = codec->spec; 560 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, 561 hinfo); 562 } 563 564 static int via_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 565 struct hda_codec *codec, 566 unsigned int stream_tag, 567 unsigned int format, 568 struct snd_pcm_substream *substream) 569 { 570 struct via_spec *spec = codec->spec; 571 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, 572 stream_tag, format, substream); 573 } 574 575 static int via_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 576 struct hda_codec *codec, 577 struct snd_pcm_substream *substream) 578 { 579 struct via_spec *spec = codec->spec; 580 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); 581 } 582 583 584 static void playback_multi_pcm_prep_0(struct hda_codec *codec, 585 unsigned int stream_tag, 586 unsigned int format, 587 struct snd_pcm_substream *substream) 588 { 589 struct via_spec *spec = codec->spec; 590 struct hda_multi_out *mout = &spec->multiout; 591 hda_nid_t *nids = mout->dac_nids; 592 int chs = substream->runtime->channels; 593 int i; 594 595 mutex_lock(&codec->spdif_mutex); 596 if (mout->dig_out_nid && mout->dig_out_used != HDA_DIG_EXCLUSIVE) { 597 if (chs == 2 && 598 snd_hda_is_supported_format(codec, mout->dig_out_nid, 599 format) && 600 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) { 601 mout->dig_out_used = HDA_DIG_ANALOG_DUP; 602 /* turn off SPDIF once; otherwise the IEC958 bits won't 603 * be updated */ 604 if (codec->spdif_ctls & AC_DIG1_ENABLE) 605 snd_hda_codec_write(codec, mout->dig_out_nid, 0, 606 AC_VERB_SET_DIGI_CONVERT_1, 607 codec->spdif_ctls & 608 ~AC_DIG1_ENABLE & 0xff); 609 snd_hda_codec_setup_stream(codec, mout->dig_out_nid, 610 stream_tag, 0, format); 611 /* turn on again (if needed) */ 612 if (codec->spdif_ctls & AC_DIG1_ENABLE) 613 snd_hda_codec_write(codec, mout->dig_out_nid, 0, 614 AC_VERB_SET_DIGI_CONVERT_1, 615 codec->spdif_ctls & 0xff); 616 } else { 617 mout->dig_out_used = 0; 618 snd_hda_codec_setup_stream(codec, mout->dig_out_nid, 619 0, 0, 0); 620 } 621 } 622 mutex_unlock(&codec->spdif_mutex); 623 624 /* front */ 625 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag, 626 0, format); 627 628 if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] && 629 !spec->hp_independent_mode) 630 /* headphone out will just decode front left/right (stereo) */ 631 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag, 632 0, format); 633 634 /* extra outputs copied from front */ 635 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) 636 if (mout->extra_out_nid[i]) 637 snd_hda_codec_setup_stream(codec, 638 mout->extra_out_nid[i], 639 stream_tag, 0, format); 640 641 /* surrounds */ 642 for (i = 1; i < mout->num_dacs; i++) { 643 if (chs >= (i + 1) * 2) /* independent out */ 644 snd_hda_codec_setup_stream(codec, nids[i], stream_tag, 645 i * 2, format); 646 else /* copy front */ 647 snd_hda_codec_setup_stream(codec, nids[i], stream_tag, 648 0, format); 649 } 650 } 651 652 static int via_playback_multi_pcm_prepare(struct hda_pcm_stream *hinfo, 653 struct hda_codec *codec, 654 unsigned int stream_tag, 655 unsigned int format, 656 struct snd_pcm_substream *substream) 657 { 658 struct via_spec *spec = codec->spec; 659 struct hda_multi_out *mout = &spec->multiout; 660 hda_nid_t *nids = mout->dac_nids; 661 662 if (substream->number == 0) 663 playback_multi_pcm_prep_0(codec, stream_tag, format, 664 substream); 665 else { 666 if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] && 667 spec->hp_independent_mode) 668 snd_hda_codec_setup_stream(codec, mout->hp_nid, 669 stream_tag, 0, format); 670 } 671 672 return 0; 673 } 674 675 static int via_playback_multi_pcm_cleanup(struct hda_pcm_stream *hinfo, 676 struct hda_codec *codec, 677 struct snd_pcm_substream *substream) 678 { 679 struct via_spec *spec = codec->spec; 680 struct hda_multi_out *mout = &spec->multiout; 681 hda_nid_t *nids = mout->dac_nids; 682 int i; 683 684 if (substream->number == 0) { 685 for (i = 0; i < mout->num_dacs; i++) 686 snd_hda_codec_setup_stream(codec, nids[i], 0, 0, 0); 687 688 if (mout->hp_nid && !spec->hp_independent_mode) 689 snd_hda_codec_setup_stream(codec, mout->hp_nid, 690 0, 0, 0); 691 692 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) 693 if (mout->extra_out_nid[i]) 694 snd_hda_codec_setup_stream(codec, 695 mout->extra_out_nid[i], 696 0, 0, 0); 697 mutex_lock(&codec->spdif_mutex); 698 if (mout->dig_out_nid && 699 mout->dig_out_used == HDA_DIG_ANALOG_DUP) { 700 snd_hda_codec_setup_stream(codec, mout->dig_out_nid, 701 0, 0, 0); 702 mout->dig_out_used = 0; 703 } 704 mutex_unlock(&codec->spdif_mutex); 705 } else { 706 if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] && 707 spec->hp_independent_mode) 708 snd_hda_codec_setup_stream(codec, mout->hp_nid, 709 0, 0, 0); 710 } 711 712 return 0; 713 } 714 715 /* 716 * Digital out 717 */ 718 static int via_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, 719 struct hda_codec *codec, 720 struct snd_pcm_substream *substream) 721 { 722 struct via_spec *spec = codec->spec; 723 return snd_hda_multi_out_dig_open(codec, &spec->multiout); 724 } 725 726 static int via_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, 727 struct hda_codec *codec, 728 struct snd_pcm_substream *substream) 729 { 730 struct via_spec *spec = codec->spec; 731 return snd_hda_multi_out_dig_close(codec, &spec->multiout); 732 } 733 734 /* setup SPDIF output stream */ 735 static void setup_dig_playback_stream(struct hda_codec *codec, hda_nid_t nid, 736 unsigned int stream_tag, unsigned int format) 737 { 738 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */ 739 if (codec->spdif_ctls & AC_DIG1_ENABLE) 740 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1, 741 codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff); 742 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format); 743 /* turn on again (if needed) */ 744 if (codec->spdif_ctls & AC_DIG1_ENABLE) 745 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1, 746 codec->spdif_ctls & 0xff); 747 } 748 749 static int via_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 750 struct hda_codec *codec, 751 unsigned int stream_tag, 752 unsigned int format, 753 struct snd_pcm_substream *substream) 754 { 755 struct via_spec *spec = codec->spec; 756 hda_nid_t nid; 757 758 /* 1st or 2nd S/PDIF */ 759 if (substream->number == 0) 760 nid = spec->multiout.dig_out_nid; 761 else if (substream->number == 1) 762 nid = spec->extra_dig_out_nid; 763 else 764 return -1; 765 766 mutex_lock(&codec->spdif_mutex); 767 setup_dig_playback_stream(codec, nid, stream_tag, format); 768 mutex_unlock(&codec->spdif_mutex); 769 return 0; 770 } 771 772 /* 773 * Analog capture 774 */ 775 static int via_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 776 struct hda_codec *codec, 777 unsigned int stream_tag, 778 unsigned int format, 779 struct snd_pcm_substream *substream) 780 { 781 struct via_spec *spec = codec->spec; 782 783 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 784 stream_tag, 0, format); 785 return 0; 786 } 787 788 static int via_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 789 struct hda_codec *codec, 790 struct snd_pcm_substream *substream) 791 { 792 struct via_spec *spec = codec->spec; 793 snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]); 794 return 0; 795 } 796 797 static struct hda_pcm_stream vt1708_pcm_analog_playback = { 798 .substreams = 2, 799 .channels_min = 2, 800 .channels_max = 8, 801 .nid = 0x10, /* NID to query formats and rates */ 802 .ops = { 803 .open = via_playback_pcm_open, 804 .prepare = via_playback_multi_pcm_prepare, 805 .cleanup = via_playback_multi_pcm_cleanup 806 }, 807 }; 808 809 static struct hda_pcm_stream vt1708_pcm_analog_s16_playback = { 810 .substreams = 1, 811 .channels_min = 2, 812 .channels_max = 8, 813 .nid = 0x10, /* NID to query formats and rates */ 814 /* We got noisy outputs on the right channel on VT1708 when 815 * 24bit samples are used. Until any workaround is found, 816 * disable the 24bit format, so far. 817 */ 818 .formats = SNDRV_PCM_FMTBIT_S16_LE, 819 .ops = { 820 .open = via_playback_pcm_open, 821 .prepare = via_playback_pcm_prepare, 822 .cleanup = via_playback_pcm_cleanup 823 }, 824 }; 825 826 static struct hda_pcm_stream vt1708_pcm_analog_capture = { 827 .substreams = 2, 828 .channels_min = 2, 829 .channels_max = 2, 830 .nid = 0x15, /* NID to query formats and rates */ 831 .ops = { 832 .prepare = via_capture_pcm_prepare, 833 .cleanup = via_capture_pcm_cleanup 834 }, 835 }; 836 837 static struct hda_pcm_stream vt1708_pcm_digital_playback = { 838 .substreams = 1, 839 .channels_min = 2, 840 .channels_max = 2, 841 /* NID is set in via_build_pcms */ 842 .ops = { 843 .open = via_dig_playback_pcm_open, 844 .close = via_dig_playback_pcm_close, 845 .prepare = via_dig_playback_pcm_prepare 846 }, 847 }; 848 849 static struct hda_pcm_stream vt1708_pcm_digital_capture = { 850 .substreams = 1, 851 .channels_min = 2, 852 .channels_max = 2, 853 }; 854 855 static int via_build_controls(struct hda_codec *codec) 856 { 857 struct via_spec *spec = codec->spec; 858 int err; 859 int i; 860 861 for (i = 0; i < spec->num_mixers; i++) { 862 err = snd_hda_add_new_ctls(codec, spec->mixers[i]); 863 if (err < 0) 864 return err; 865 } 866 867 if (spec->multiout.dig_out_nid) { 868 err = snd_hda_create_spdif_out_ctls(codec, 869 spec->multiout.dig_out_nid); 870 if (err < 0) 871 return err; 872 err = snd_hda_create_spdif_share_sw(codec, 873 &spec->multiout); 874 if (err < 0) 875 return err; 876 spec->multiout.share_spdif = 1; 877 878 if (spec->extra_dig_out_nid) { 879 err = snd_hda_create_spdif_out_ctls(codec, 880 spec->extra_dig_out_nid); 881 if (err < 0) 882 return err; 883 } 884 } 885 if (spec->dig_in_nid) { 886 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid); 887 if (err < 0) 888 return err; 889 } 890 via_free_kctls(codec); /* no longer needed */ 891 return 0; 892 } 893 894 static int via_build_pcms(struct hda_codec *codec) 895 { 896 struct via_spec *spec = codec->spec; 897 struct hda_pcm *info = spec->pcm_rec; 898 899 codec->num_pcms = 1; 900 codec->pcm_info = info; 901 902 info->name = spec->stream_name_analog; 903 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback); 904 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0]; 905 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture); 906 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; 907 908 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 909 spec->multiout.max_channels; 910 911 if (spec->multiout.dig_out_nid || spec->dig_in_nid) { 912 codec->num_pcms++; 913 info++; 914 info->name = spec->stream_name_digital; 915 info->pcm_type = HDA_PCM_TYPE_SPDIF; 916 if (spec->multiout.dig_out_nid) { 917 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 918 *(spec->stream_digital_playback); 919 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 920 spec->multiout.dig_out_nid; 921 } 922 if (spec->dig_in_nid) { 923 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 924 *(spec->stream_digital_capture); 925 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 926 spec->dig_in_nid; 927 } 928 } 929 930 return 0; 931 } 932 933 static void via_free(struct hda_codec *codec) 934 { 935 struct via_spec *spec = codec->spec; 936 937 if (!spec) 938 return; 939 940 via_free_kctls(codec); 941 kfree(codec->spec); 942 } 943 944 /* mute internal speaker if HP is plugged */ 945 static void via_hp_automute(struct hda_codec *codec) 946 { 947 unsigned int present; 948 struct via_spec *spec = codec->spec; 949 950 present = snd_hda_codec_read(codec, spec->autocfg.hp_pins[0], 0, 951 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 952 snd_hda_codec_amp_stereo(codec, spec->autocfg.line_out_pins[0], 953 HDA_OUTPUT, 0, HDA_AMP_MUTE, 954 present ? HDA_AMP_MUTE : 0); 955 } 956 957 static void via_gpio_control(struct hda_codec *codec) 958 { 959 unsigned int gpio_data; 960 unsigned int vol_counter; 961 unsigned int vol; 962 unsigned int master_vol; 963 964 struct via_spec *spec = codec->spec; 965 966 gpio_data = snd_hda_codec_read(codec, codec->afg, 0, 967 AC_VERB_GET_GPIO_DATA, 0) & 0x03; 968 969 vol_counter = (snd_hda_codec_read(codec, codec->afg, 0, 970 0xF84, 0) & 0x3F0000) >> 16; 971 972 vol = vol_counter & 0x1F; 973 master_vol = snd_hda_codec_read(codec, 0x1A, 0, 974 AC_VERB_GET_AMP_GAIN_MUTE, 975 AC_AMP_GET_INPUT); 976 977 if (gpio_data == 0x02) { 978 /* unmute line out */ 979 snd_hda_codec_amp_stereo(codec, spec->autocfg.line_out_pins[0], 980 HDA_OUTPUT, 0, HDA_AMP_MUTE, 0); 981 982 if (vol_counter & 0x20) { 983 /* decrease volume */ 984 if (vol > master_vol) 985 vol = master_vol; 986 snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT, 987 0, HDA_AMP_VOLMASK, 988 master_vol-vol); 989 } else { 990 /* increase volume */ 991 snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT, 0, 992 HDA_AMP_VOLMASK, 993 ((master_vol+vol) > 0x2A) ? 0x2A : 994 (master_vol+vol)); 995 } 996 } else if (!(gpio_data & 0x02)) { 997 /* mute line out */ 998 snd_hda_codec_amp_stereo(codec, 999 spec->autocfg.line_out_pins[0], 1000 HDA_OUTPUT, 0, HDA_AMP_MUTE, 1001 HDA_AMP_MUTE); 1002 } 1003 } 1004 1005 /* unsolicited event for jack sensing */ 1006 static void via_unsol_event(struct hda_codec *codec, 1007 unsigned int res) 1008 { 1009 res >>= 26; 1010 if (res == VIA_HP_EVENT) 1011 via_hp_automute(codec); 1012 else if (res == VIA_GPIO_EVENT) 1013 via_gpio_control(codec); 1014 } 1015 1016 static hda_nid_t slave_dig_outs[] = { 1017 0, 1018 }; 1019 1020 static int via_init(struct hda_codec *codec) 1021 { 1022 struct via_spec *spec = codec->spec; 1023 int i; 1024 for (i = 0; i < spec->num_iverbs; i++) 1025 snd_hda_sequence_write(codec, spec->init_verbs[i]); 1026 1027 /* Lydia Add for EAPD enable */ 1028 if (!spec->dig_in_nid) { /* No Digital In connection */ 1029 if (IS_VT1708_VENDORID(codec->vendor_id)) { 1030 snd_hda_codec_write(codec, VT1708_DIGIN_PIN, 0, 1031 AC_VERB_SET_PIN_WIDGET_CONTROL, 1032 PIN_OUT); 1033 snd_hda_codec_write(codec, VT1708_DIGIN_PIN, 0, 1034 AC_VERB_SET_EAPD_BTLENABLE, 0x02); 1035 } else if (IS_VT1709_10CH_VENDORID(codec->vendor_id) || 1036 IS_VT1709_6CH_VENDORID(codec->vendor_id)) { 1037 snd_hda_codec_write(codec, VT1709_DIGIN_PIN, 0, 1038 AC_VERB_SET_PIN_WIDGET_CONTROL, 1039 PIN_OUT); 1040 snd_hda_codec_write(codec, VT1709_DIGIN_PIN, 0, 1041 AC_VERB_SET_EAPD_BTLENABLE, 0x02); 1042 } else if (IS_VT1708B_8CH_VENDORID(codec->vendor_id) || 1043 IS_VT1708B_4CH_VENDORID(codec->vendor_id)) { 1044 snd_hda_codec_write(codec, VT1708B_DIGIN_PIN, 0, 1045 AC_VERB_SET_PIN_WIDGET_CONTROL, 1046 PIN_OUT); 1047 snd_hda_codec_write(codec, VT1708B_DIGIN_PIN, 0, 1048 AC_VERB_SET_EAPD_BTLENABLE, 0x02); 1049 } 1050 } else /* enable SPDIF-input pin */ 1051 snd_hda_codec_write(codec, spec->autocfg.dig_in_pin, 0, 1052 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN); 1053 1054 /* no slave outs */ 1055 codec->slave_dig_outs = slave_dig_outs; 1056 1057 return 0; 1058 } 1059 1060 #ifdef CONFIG_SND_HDA_POWER_SAVE 1061 static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid) 1062 { 1063 struct via_spec *spec = codec->spec; 1064 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid); 1065 } 1066 #endif 1067 1068 /* 1069 */ 1070 static struct hda_codec_ops via_patch_ops = { 1071 .build_controls = via_build_controls, 1072 .build_pcms = via_build_pcms, 1073 .init = via_init, 1074 .free = via_free, 1075 #ifdef CONFIG_SND_HDA_POWER_SAVE 1076 .check_power_status = via_check_power_status, 1077 #endif 1078 }; 1079 1080 /* fill in the dac_nids table from the parsed pin configuration */ 1081 static int vt1708_auto_fill_dac_nids(struct via_spec *spec, 1082 const struct auto_pin_cfg *cfg) 1083 { 1084 int i; 1085 hda_nid_t nid; 1086 1087 spec->multiout.num_dacs = cfg->line_outs; 1088 1089 spec->multiout.dac_nids = spec->private_dac_nids; 1090 1091 for(i = 0; i < 4; i++) { 1092 nid = cfg->line_out_pins[i]; 1093 if (nid) { 1094 /* config dac list */ 1095 switch (i) { 1096 case AUTO_SEQ_FRONT: 1097 spec->multiout.dac_nids[i] = 0x10; 1098 break; 1099 case AUTO_SEQ_CENLFE: 1100 spec->multiout.dac_nids[i] = 0x12; 1101 break; 1102 case AUTO_SEQ_SURROUND: 1103 spec->multiout.dac_nids[i] = 0x11; 1104 break; 1105 case AUTO_SEQ_SIDE: 1106 spec->multiout.dac_nids[i] = 0x13; 1107 break; 1108 } 1109 } 1110 } 1111 1112 return 0; 1113 } 1114 1115 /* add playback controls from the parsed DAC table */ 1116 static int vt1708_auto_create_multi_out_ctls(struct via_spec *spec, 1117 const struct auto_pin_cfg *cfg) 1118 { 1119 char name[32]; 1120 static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" }; 1121 hda_nid_t nid, nid_vol = 0; 1122 int i, err; 1123 1124 for (i = 0; i <= AUTO_SEQ_SIDE; i++) { 1125 nid = cfg->line_out_pins[i]; 1126 1127 if (!nid) 1128 continue; 1129 1130 if (i != AUTO_SEQ_FRONT) 1131 nid_vol = 0x18 + i; 1132 1133 if (i == AUTO_SEQ_CENLFE) { 1134 /* Center/LFE */ 1135 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 1136 "Center Playback Volume", 1137 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, 1138 HDA_OUTPUT)); 1139 if (err < 0) 1140 return err; 1141 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 1142 "LFE Playback Volume", 1143 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, 1144 HDA_OUTPUT)); 1145 if (err < 0) 1146 return err; 1147 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 1148 "Center Playback Switch", 1149 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, 1150 HDA_OUTPUT)); 1151 if (err < 0) 1152 return err; 1153 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 1154 "LFE Playback Switch", 1155 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, 1156 HDA_OUTPUT)); 1157 if (err < 0) 1158 return err; 1159 } else if (i == AUTO_SEQ_FRONT){ 1160 /* add control to mixer index 0 */ 1161 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 1162 "Master Front Playback Volume", 1163 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, 1164 HDA_INPUT)); 1165 if (err < 0) 1166 return err; 1167 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 1168 "Master Front Playback Switch", 1169 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, 1170 HDA_INPUT)); 1171 if (err < 0) 1172 return err; 1173 1174 /* add control to PW3 */ 1175 sprintf(name, "%s Playback Volume", chname[i]); 1176 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 1177 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 1178 HDA_OUTPUT)); 1179 if (err < 0) 1180 return err; 1181 sprintf(name, "%s Playback Switch", chname[i]); 1182 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 1183 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 1184 HDA_OUTPUT)); 1185 if (err < 0) 1186 return err; 1187 } else { 1188 sprintf(name, "%s Playback Volume", chname[i]); 1189 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 1190 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 1191 HDA_OUTPUT)); 1192 if (err < 0) 1193 return err; 1194 sprintf(name, "%s Playback Switch", chname[i]); 1195 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 1196 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 1197 HDA_OUTPUT)); 1198 if (err < 0) 1199 return err; 1200 } 1201 } 1202 1203 return 0; 1204 } 1205 1206 static void create_hp_imux(struct via_spec *spec) 1207 { 1208 int i; 1209 struct hda_input_mux *imux = &spec->private_imux[1]; 1210 static const char *texts[] = { "OFF", "ON", NULL}; 1211 1212 /* for hp mode select */ 1213 i = 0; 1214 while (texts[i] != NULL) { 1215 imux->items[imux->num_items].label = texts[i]; 1216 imux->items[imux->num_items].index = i; 1217 imux->num_items++; 1218 i++; 1219 } 1220 1221 spec->hp_mux = &spec->private_imux[1]; 1222 } 1223 1224 static int vt1708_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) 1225 { 1226 int err; 1227 1228 if (!pin) 1229 return 0; 1230 1231 spec->multiout.hp_nid = VT1708_HP_NID; /* AOW3 */ 1232 1233 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 1234 "Headphone Playback Volume", 1235 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 1236 if (err < 0) 1237 return err; 1238 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 1239 "Headphone Playback Switch", 1240 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 1241 if (err < 0) 1242 return err; 1243 1244 create_hp_imux(spec); 1245 1246 return 0; 1247 } 1248 1249 /* create playback/capture controls for input pins */ 1250 static int vt1708_auto_create_analog_input_ctls(struct via_spec *spec, 1251 const struct auto_pin_cfg *cfg) 1252 { 1253 static char *labels[] = { 1254 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL 1255 }; 1256 struct hda_input_mux *imux = &spec->private_imux[0]; 1257 int i, err, idx = 0; 1258 1259 /* for internal loopback recording select */ 1260 imux->items[imux->num_items].label = "Stereo Mixer"; 1261 imux->items[imux->num_items].index = idx; 1262 imux->num_items++; 1263 1264 for (i = 0; i < AUTO_PIN_LAST; i++) { 1265 if (!cfg->input_pins[i]) 1266 continue; 1267 1268 switch (cfg->input_pins[i]) { 1269 case 0x1d: /* Mic */ 1270 idx = 2; 1271 break; 1272 1273 case 0x1e: /* Line In */ 1274 idx = 3; 1275 break; 1276 1277 case 0x21: /* Front Mic */ 1278 idx = 4; 1279 break; 1280 1281 case 0x24: /* CD */ 1282 idx = 1; 1283 break; 1284 } 1285 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i], 1286 idx, 0x17); 1287 if (err < 0) 1288 return err; 1289 imux->items[imux->num_items].label = labels[i]; 1290 imux->items[imux->num_items].index = idx; 1291 imux->num_items++; 1292 } 1293 return 0; 1294 } 1295 1296 #ifdef CONFIG_SND_HDA_POWER_SAVE 1297 static struct hda_amp_list vt1708_loopbacks[] = { 1298 { 0x17, HDA_INPUT, 1 }, 1299 { 0x17, HDA_INPUT, 2 }, 1300 { 0x17, HDA_INPUT, 3 }, 1301 { 0x17, HDA_INPUT, 4 }, 1302 { } /* end */ 1303 }; 1304 #endif 1305 1306 static void vt1708_set_pinconfig_connect(struct hda_codec *codec, hda_nid_t nid) 1307 { 1308 unsigned int def_conf; 1309 unsigned char seqassoc; 1310 1311 def_conf = snd_hda_codec_get_pincfg(codec, nid); 1312 seqassoc = (unsigned char) get_defcfg_association(def_conf); 1313 seqassoc = (seqassoc << 4) | get_defcfg_sequence(def_conf); 1314 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE) { 1315 if (seqassoc == 0xff) { 1316 def_conf = def_conf & (~(AC_JACK_PORT_BOTH << 30)); 1317 snd_hda_codec_set_pincfg(codec, nid, def_conf); 1318 } 1319 } 1320 1321 return; 1322 } 1323 1324 static int vt1708_parse_auto_config(struct hda_codec *codec) 1325 { 1326 struct via_spec *spec = codec->spec; 1327 int err; 1328 1329 /* Add HP and CD pin config connect bit re-config action */ 1330 vt1708_set_pinconfig_connect(codec, VT1708_HP_PIN_NID); 1331 vt1708_set_pinconfig_connect(codec, VT1708_CD_PIN_NID); 1332 1333 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); 1334 if (err < 0) 1335 return err; 1336 err = vt1708_auto_fill_dac_nids(spec, &spec->autocfg); 1337 if (err < 0) 1338 return err; 1339 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) 1340 return 0; /* can't find valid BIOS pin config */ 1341 1342 err = vt1708_auto_create_multi_out_ctls(spec, &spec->autocfg); 1343 if (err < 0) 1344 return err; 1345 err = vt1708_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); 1346 if (err < 0) 1347 return err; 1348 err = vt1708_auto_create_analog_input_ctls(spec, &spec->autocfg); 1349 if (err < 0) 1350 return err; 1351 1352 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 1353 1354 if (spec->autocfg.dig_outs) 1355 spec->multiout.dig_out_nid = VT1708_DIGOUT_NID; 1356 if (spec->autocfg.dig_in_pin) 1357 spec->dig_in_nid = VT1708_DIGIN_NID; 1358 1359 if (spec->kctls.list) 1360 spec->mixers[spec->num_mixers++] = spec->kctls.list; 1361 1362 spec->init_verbs[spec->num_iverbs++] = vt1708_volume_init_verbs; 1363 1364 spec->input_mux = &spec->private_imux[0]; 1365 1366 if (spec->hp_mux) 1367 spec->mixers[spec->num_mixers++] = via_hp_mixer; 1368 1369 return 1; 1370 } 1371 1372 /* init callback for auto-configuration model -- overriding the default init */ 1373 static int via_auto_init(struct hda_codec *codec) 1374 { 1375 via_init(codec); 1376 via_auto_init_multi_out(codec); 1377 via_auto_init_hp_out(codec); 1378 via_auto_init_analog_input(codec); 1379 return 0; 1380 } 1381 1382 static int patch_vt1708(struct hda_codec *codec) 1383 { 1384 struct via_spec *spec; 1385 int err; 1386 1387 /* create a codec specific record */ 1388 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 1389 if (spec == NULL) 1390 return -ENOMEM; 1391 1392 codec->spec = spec; 1393 1394 /* automatic parse from the BIOS config */ 1395 err = vt1708_parse_auto_config(codec); 1396 if (err < 0) { 1397 via_free(codec); 1398 return err; 1399 } else if (!err) { 1400 printk(KERN_INFO "hda_codec: Cannot set up configuration " 1401 "from BIOS. Using genenic mode...\n"); 1402 } 1403 1404 1405 spec->stream_name_analog = "VT1708 Analog"; 1406 spec->stream_analog_playback = &vt1708_pcm_analog_playback; 1407 /* disable 32bit format on VT1708 */ 1408 if (codec->vendor_id == 0x11061708) 1409 spec->stream_analog_playback = &vt1708_pcm_analog_s16_playback; 1410 spec->stream_analog_capture = &vt1708_pcm_analog_capture; 1411 1412 spec->stream_name_digital = "VT1708 Digital"; 1413 spec->stream_digital_playback = &vt1708_pcm_digital_playback; 1414 spec->stream_digital_capture = &vt1708_pcm_digital_capture; 1415 1416 1417 if (!spec->adc_nids && spec->input_mux) { 1418 spec->adc_nids = vt1708_adc_nids; 1419 spec->num_adc_nids = ARRAY_SIZE(vt1708_adc_nids); 1420 spec->mixers[spec->num_mixers] = vt1708_capture_mixer; 1421 spec->num_mixers++; 1422 } 1423 1424 codec->patch_ops = via_patch_ops; 1425 1426 codec->patch_ops.init = via_auto_init; 1427 #ifdef CONFIG_SND_HDA_POWER_SAVE 1428 spec->loopback.amplist = vt1708_loopbacks; 1429 #endif 1430 1431 return 0; 1432 } 1433 1434 /* capture mixer elements */ 1435 static struct snd_kcontrol_new vt1709_capture_mixer[] = { 1436 HDA_CODEC_VOLUME("Capture Volume", 0x14, 0x0, HDA_INPUT), 1437 HDA_CODEC_MUTE("Capture Switch", 0x14, 0x0, HDA_INPUT), 1438 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x15, 0x0, HDA_INPUT), 1439 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x15, 0x0, HDA_INPUT), 1440 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x16, 0x0, HDA_INPUT), 1441 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x16, 0x0, HDA_INPUT), 1442 { 1443 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1444 /* The multiple "Capture Source" controls confuse alsamixer 1445 * So call somewhat different.. 1446 */ 1447 /* .name = "Capture Source", */ 1448 .name = "Input Source", 1449 .count = 1, 1450 .info = via_mux_enum_info, 1451 .get = via_mux_enum_get, 1452 .put = via_mux_enum_put, 1453 }, 1454 { } /* end */ 1455 }; 1456 1457 static struct hda_verb vt1709_uniwill_init_verbs[] = { 1458 {0x20, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT}, 1459 { } 1460 }; 1461 1462 /* 1463 * generic initialization of ADC, input mixers and output mixers 1464 */ 1465 static struct hda_verb vt1709_10ch_volume_init_verbs[] = { 1466 /* 1467 * Unmute ADC0-2 and set the default input to mic-in 1468 */ 1469 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1470 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1471 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1472 1473 1474 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 1475 * mixer widget 1476 */ 1477 /* Amp Indices: AOW0=0, CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ 1478 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1479 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 1480 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 1481 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 1482 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 1483 1484 /* 1485 * Set up output selector (0x1a, 0x1b, 0x29) 1486 */ 1487 /* set vol=0 to output mixers */ 1488 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1489 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1490 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1491 1492 /* 1493 * Unmute PW3 and PW4 1494 */ 1495 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1496 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1497 1498 /* Set input of PW4 as AOW4 */ 1499 {0x20, AC_VERB_SET_CONNECT_SEL, 0x1}, 1500 /* PW9 Output enable */ 1501 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 1502 { } 1503 }; 1504 1505 static struct hda_pcm_stream vt1709_10ch_pcm_analog_playback = { 1506 .substreams = 1, 1507 .channels_min = 2, 1508 .channels_max = 10, 1509 .nid = 0x10, /* NID to query formats and rates */ 1510 .ops = { 1511 .open = via_playback_pcm_open, 1512 .prepare = via_playback_pcm_prepare, 1513 .cleanup = via_playback_pcm_cleanup 1514 }, 1515 }; 1516 1517 static struct hda_pcm_stream vt1709_6ch_pcm_analog_playback = { 1518 .substreams = 1, 1519 .channels_min = 2, 1520 .channels_max = 6, 1521 .nid = 0x10, /* NID to query formats and rates */ 1522 .ops = { 1523 .open = via_playback_pcm_open, 1524 .prepare = via_playback_pcm_prepare, 1525 .cleanup = via_playback_pcm_cleanup 1526 }, 1527 }; 1528 1529 static struct hda_pcm_stream vt1709_pcm_analog_capture = { 1530 .substreams = 2, 1531 .channels_min = 2, 1532 .channels_max = 2, 1533 .nid = 0x14, /* NID to query formats and rates */ 1534 .ops = { 1535 .prepare = via_capture_pcm_prepare, 1536 .cleanup = via_capture_pcm_cleanup 1537 }, 1538 }; 1539 1540 static struct hda_pcm_stream vt1709_pcm_digital_playback = { 1541 .substreams = 1, 1542 .channels_min = 2, 1543 .channels_max = 2, 1544 /* NID is set in via_build_pcms */ 1545 .ops = { 1546 .open = via_dig_playback_pcm_open, 1547 .close = via_dig_playback_pcm_close 1548 }, 1549 }; 1550 1551 static struct hda_pcm_stream vt1709_pcm_digital_capture = { 1552 .substreams = 1, 1553 .channels_min = 2, 1554 .channels_max = 2, 1555 }; 1556 1557 static int vt1709_auto_fill_dac_nids(struct via_spec *spec, 1558 const struct auto_pin_cfg *cfg) 1559 { 1560 int i; 1561 hda_nid_t nid; 1562 1563 if (cfg->line_outs == 4) /* 10 channels */ 1564 spec->multiout.num_dacs = cfg->line_outs+1; /* AOW0~AOW4 */ 1565 else if (cfg->line_outs == 3) /* 6 channels */ 1566 spec->multiout.num_dacs = cfg->line_outs; /* AOW0~AOW2 */ 1567 1568 spec->multiout.dac_nids = spec->private_dac_nids; 1569 1570 if (cfg->line_outs == 4) { /* 10 channels */ 1571 for (i = 0; i < cfg->line_outs; i++) { 1572 nid = cfg->line_out_pins[i]; 1573 if (nid) { 1574 /* config dac list */ 1575 switch (i) { 1576 case AUTO_SEQ_FRONT: 1577 /* AOW0 */ 1578 spec->multiout.dac_nids[i] = 0x10; 1579 break; 1580 case AUTO_SEQ_CENLFE: 1581 /* AOW2 */ 1582 spec->multiout.dac_nids[i] = 0x12; 1583 break; 1584 case AUTO_SEQ_SURROUND: 1585 /* AOW3 */ 1586 spec->multiout.dac_nids[i] = 0x11; 1587 break; 1588 case AUTO_SEQ_SIDE: 1589 /* AOW1 */ 1590 spec->multiout.dac_nids[i] = 0x27; 1591 break; 1592 default: 1593 break; 1594 } 1595 } 1596 } 1597 spec->multiout.dac_nids[cfg->line_outs] = 0x28; /* AOW4 */ 1598 1599 } else if (cfg->line_outs == 3) { /* 6 channels */ 1600 for(i = 0; i < cfg->line_outs; i++) { 1601 nid = cfg->line_out_pins[i]; 1602 if (nid) { 1603 /* config dac list */ 1604 switch(i) { 1605 case AUTO_SEQ_FRONT: 1606 /* AOW0 */ 1607 spec->multiout.dac_nids[i] = 0x10; 1608 break; 1609 case AUTO_SEQ_CENLFE: 1610 /* AOW2 */ 1611 spec->multiout.dac_nids[i] = 0x12; 1612 break; 1613 case AUTO_SEQ_SURROUND: 1614 /* AOW1 */ 1615 spec->multiout.dac_nids[i] = 0x11; 1616 break; 1617 default: 1618 break; 1619 } 1620 } 1621 } 1622 } 1623 1624 return 0; 1625 } 1626 1627 /* add playback controls from the parsed DAC table */ 1628 static int vt1709_auto_create_multi_out_ctls(struct via_spec *spec, 1629 const struct auto_pin_cfg *cfg) 1630 { 1631 char name[32]; 1632 static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" }; 1633 hda_nid_t nid = 0; 1634 int i, err; 1635 1636 for (i = 0; i <= AUTO_SEQ_SIDE; i++) { 1637 nid = cfg->line_out_pins[i]; 1638 1639 if (!nid) 1640 continue; 1641 1642 if (i == AUTO_SEQ_CENLFE) { 1643 /* Center/LFE */ 1644 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 1645 "Center Playback Volume", 1646 HDA_COMPOSE_AMP_VAL(0x1b, 1, 0, 1647 HDA_OUTPUT)); 1648 if (err < 0) 1649 return err; 1650 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 1651 "LFE Playback Volume", 1652 HDA_COMPOSE_AMP_VAL(0x1b, 2, 0, 1653 HDA_OUTPUT)); 1654 if (err < 0) 1655 return err; 1656 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 1657 "Center Playback Switch", 1658 HDA_COMPOSE_AMP_VAL(0x1b, 1, 0, 1659 HDA_OUTPUT)); 1660 if (err < 0) 1661 return err; 1662 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 1663 "LFE Playback Switch", 1664 HDA_COMPOSE_AMP_VAL(0x1b, 2, 0, 1665 HDA_OUTPUT)); 1666 if (err < 0) 1667 return err; 1668 } else if (i == AUTO_SEQ_FRONT){ 1669 /* add control to mixer index 0 */ 1670 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 1671 "Master Front Playback Volume", 1672 HDA_COMPOSE_AMP_VAL(0x18, 3, 0, 1673 HDA_INPUT)); 1674 if (err < 0) 1675 return err; 1676 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 1677 "Master Front Playback Switch", 1678 HDA_COMPOSE_AMP_VAL(0x18, 3, 0, 1679 HDA_INPUT)); 1680 if (err < 0) 1681 return err; 1682 1683 /* add control to PW3 */ 1684 sprintf(name, "%s Playback Volume", chname[i]); 1685 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 1686 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 1687 HDA_OUTPUT)); 1688 if (err < 0) 1689 return err; 1690 sprintf(name, "%s Playback Switch", chname[i]); 1691 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 1692 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 1693 HDA_OUTPUT)); 1694 if (err < 0) 1695 return err; 1696 } else if (i == AUTO_SEQ_SURROUND) { 1697 sprintf(name, "%s Playback Volume", chname[i]); 1698 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 1699 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, 1700 HDA_OUTPUT)); 1701 if (err < 0) 1702 return err; 1703 sprintf(name, "%s Playback Switch", chname[i]); 1704 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 1705 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, 1706 HDA_OUTPUT)); 1707 if (err < 0) 1708 return err; 1709 } else if (i == AUTO_SEQ_SIDE) { 1710 sprintf(name, "%s Playback Volume", chname[i]); 1711 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 1712 HDA_COMPOSE_AMP_VAL(0x29, 3, 0, 1713 HDA_OUTPUT)); 1714 if (err < 0) 1715 return err; 1716 sprintf(name, "%s Playback Switch", chname[i]); 1717 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 1718 HDA_COMPOSE_AMP_VAL(0x29, 3, 0, 1719 HDA_OUTPUT)); 1720 if (err < 0) 1721 return err; 1722 } 1723 } 1724 1725 return 0; 1726 } 1727 1728 static int vt1709_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) 1729 { 1730 int err; 1731 1732 if (!pin) 1733 return 0; 1734 1735 if (spec->multiout.num_dacs == 5) /* 10 channels */ 1736 spec->multiout.hp_nid = VT1709_HP_DAC_NID; 1737 else if (spec->multiout.num_dacs == 3) /* 6 channels */ 1738 spec->multiout.hp_nid = 0; 1739 1740 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 1741 "Headphone Playback Volume", 1742 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 1743 if (err < 0) 1744 return err; 1745 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 1746 "Headphone Playback Switch", 1747 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 1748 if (err < 0) 1749 return err; 1750 1751 return 0; 1752 } 1753 1754 /* create playback/capture controls for input pins */ 1755 static int vt1709_auto_create_analog_input_ctls(struct via_spec *spec, 1756 const struct auto_pin_cfg *cfg) 1757 { 1758 static char *labels[] = { 1759 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL 1760 }; 1761 struct hda_input_mux *imux = &spec->private_imux[0]; 1762 int i, err, idx = 0; 1763 1764 /* for internal loopback recording select */ 1765 imux->items[imux->num_items].label = "Stereo Mixer"; 1766 imux->items[imux->num_items].index = idx; 1767 imux->num_items++; 1768 1769 for (i = 0; i < AUTO_PIN_LAST; i++) { 1770 if (!cfg->input_pins[i]) 1771 continue; 1772 1773 switch (cfg->input_pins[i]) { 1774 case 0x1d: /* Mic */ 1775 idx = 2; 1776 break; 1777 1778 case 0x1e: /* Line In */ 1779 idx = 3; 1780 break; 1781 1782 case 0x21: /* Front Mic */ 1783 idx = 4; 1784 break; 1785 1786 case 0x23: /* CD */ 1787 idx = 1; 1788 break; 1789 } 1790 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i], 1791 idx, 0x18); 1792 if (err < 0) 1793 return err; 1794 imux->items[imux->num_items].label = labels[i]; 1795 imux->items[imux->num_items].index = idx; 1796 imux->num_items++; 1797 } 1798 return 0; 1799 } 1800 1801 static int vt1709_parse_auto_config(struct hda_codec *codec) 1802 { 1803 struct via_spec *spec = codec->spec; 1804 int err; 1805 1806 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); 1807 if (err < 0) 1808 return err; 1809 err = vt1709_auto_fill_dac_nids(spec, &spec->autocfg); 1810 if (err < 0) 1811 return err; 1812 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) 1813 return 0; /* can't find valid BIOS pin config */ 1814 1815 err = vt1709_auto_create_multi_out_ctls(spec, &spec->autocfg); 1816 if (err < 0) 1817 return err; 1818 err = vt1709_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); 1819 if (err < 0) 1820 return err; 1821 err = vt1709_auto_create_analog_input_ctls(spec, &spec->autocfg); 1822 if (err < 0) 1823 return err; 1824 1825 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 1826 1827 if (spec->autocfg.dig_outs) 1828 spec->multiout.dig_out_nid = VT1709_DIGOUT_NID; 1829 if (spec->autocfg.dig_in_pin) 1830 spec->dig_in_nid = VT1709_DIGIN_NID; 1831 1832 if (spec->kctls.list) 1833 spec->mixers[spec->num_mixers++] = spec->kctls.list; 1834 1835 spec->input_mux = &spec->private_imux[0]; 1836 1837 if (spec->hp_mux) 1838 spec->mixers[spec->num_mixers++] = via_hp_mixer; 1839 1840 return 1; 1841 } 1842 1843 #ifdef CONFIG_SND_HDA_POWER_SAVE 1844 static struct hda_amp_list vt1709_loopbacks[] = { 1845 { 0x18, HDA_INPUT, 1 }, 1846 { 0x18, HDA_INPUT, 2 }, 1847 { 0x18, HDA_INPUT, 3 }, 1848 { 0x18, HDA_INPUT, 4 }, 1849 { } /* end */ 1850 }; 1851 #endif 1852 1853 static int patch_vt1709_10ch(struct hda_codec *codec) 1854 { 1855 struct via_spec *spec; 1856 int err; 1857 1858 /* create a codec specific record */ 1859 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 1860 if (spec == NULL) 1861 return -ENOMEM; 1862 1863 codec->spec = spec; 1864 1865 err = vt1709_parse_auto_config(codec); 1866 if (err < 0) { 1867 via_free(codec); 1868 return err; 1869 } else if (!err) { 1870 printk(KERN_INFO "hda_codec: Cannot set up configuration. " 1871 "Using genenic mode...\n"); 1872 } 1873 1874 spec->init_verbs[spec->num_iverbs++] = vt1709_10ch_volume_init_verbs; 1875 spec->init_verbs[spec->num_iverbs++] = vt1709_uniwill_init_verbs; 1876 1877 spec->stream_name_analog = "VT1709 Analog"; 1878 spec->stream_analog_playback = &vt1709_10ch_pcm_analog_playback; 1879 spec->stream_analog_capture = &vt1709_pcm_analog_capture; 1880 1881 spec->stream_name_digital = "VT1709 Digital"; 1882 spec->stream_digital_playback = &vt1709_pcm_digital_playback; 1883 spec->stream_digital_capture = &vt1709_pcm_digital_capture; 1884 1885 1886 if (!spec->adc_nids && spec->input_mux) { 1887 spec->adc_nids = vt1709_adc_nids; 1888 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids); 1889 spec->mixers[spec->num_mixers] = vt1709_capture_mixer; 1890 spec->num_mixers++; 1891 } 1892 1893 codec->patch_ops = via_patch_ops; 1894 1895 codec->patch_ops.init = via_auto_init; 1896 codec->patch_ops.unsol_event = via_unsol_event; 1897 #ifdef CONFIG_SND_HDA_POWER_SAVE 1898 spec->loopback.amplist = vt1709_loopbacks; 1899 #endif 1900 1901 return 0; 1902 } 1903 /* 1904 * generic initialization of ADC, input mixers and output mixers 1905 */ 1906 static struct hda_verb vt1709_6ch_volume_init_verbs[] = { 1907 /* 1908 * Unmute ADC0-2 and set the default input to mic-in 1909 */ 1910 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1911 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1912 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1913 1914 1915 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 1916 * mixer widget 1917 */ 1918 /* Amp Indices: AOW0=0, CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ 1919 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1920 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 1921 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 1922 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 1923 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 1924 1925 /* 1926 * Set up output selector (0x1a, 0x1b, 0x29) 1927 */ 1928 /* set vol=0 to output mixers */ 1929 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1930 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1931 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1932 1933 /* 1934 * Unmute PW3 and PW4 1935 */ 1936 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1937 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1938 1939 /* Set input of PW4 as MW0 */ 1940 {0x20, AC_VERB_SET_CONNECT_SEL, 0}, 1941 /* PW9 Output enable */ 1942 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 1943 { } 1944 }; 1945 1946 static int patch_vt1709_6ch(struct hda_codec *codec) 1947 { 1948 struct via_spec *spec; 1949 int err; 1950 1951 /* create a codec specific record */ 1952 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 1953 if (spec == NULL) 1954 return -ENOMEM; 1955 1956 codec->spec = spec; 1957 1958 err = vt1709_parse_auto_config(codec); 1959 if (err < 0) { 1960 via_free(codec); 1961 return err; 1962 } else if (!err) { 1963 printk(KERN_INFO "hda_codec: Cannot set up configuration. " 1964 "Using genenic mode...\n"); 1965 } 1966 1967 spec->init_verbs[spec->num_iverbs++] = vt1709_6ch_volume_init_verbs; 1968 spec->init_verbs[spec->num_iverbs++] = vt1709_uniwill_init_verbs; 1969 1970 spec->stream_name_analog = "VT1709 Analog"; 1971 spec->stream_analog_playback = &vt1709_6ch_pcm_analog_playback; 1972 spec->stream_analog_capture = &vt1709_pcm_analog_capture; 1973 1974 spec->stream_name_digital = "VT1709 Digital"; 1975 spec->stream_digital_playback = &vt1709_pcm_digital_playback; 1976 spec->stream_digital_capture = &vt1709_pcm_digital_capture; 1977 1978 1979 if (!spec->adc_nids && spec->input_mux) { 1980 spec->adc_nids = vt1709_adc_nids; 1981 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids); 1982 spec->mixers[spec->num_mixers] = vt1709_capture_mixer; 1983 spec->num_mixers++; 1984 } 1985 1986 codec->patch_ops = via_patch_ops; 1987 1988 codec->patch_ops.init = via_auto_init; 1989 codec->patch_ops.unsol_event = via_unsol_event; 1990 #ifdef CONFIG_SND_HDA_POWER_SAVE 1991 spec->loopback.amplist = vt1709_loopbacks; 1992 #endif 1993 return 0; 1994 } 1995 1996 /* capture mixer elements */ 1997 static struct snd_kcontrol_new vt1708B_capture_mixer[] = { 1998 HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT), 1999 HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT), 2000 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT), 2001 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT), 2002 { 2003 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2004 /* The multiple "Capture Source" controls confuse alsamixer 2005 * So call somewhat different.. 2006 */ 2007 /* .name = "Capture Source", */ 2008 .name = "Input Source", 2009 .count = 1, 2010 .info = via_mux_enum_info, 2011 .get = via_mux_enum_get, 2012 .put = via_mux_enum_put, 2013 }, 2014 { } /* end */ 2015 }; 2016 /* 2017 * generic initialization of ADC, input mixers and output mixers 2018 */ 2019 static struct hda_verb vt1708B_8ch_volume_init_verbs[] = { 2020 /* 2021 * Unmute ADC0-1 and set the default input to mic-in 2022 */ 2023 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2024 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2025 2026 2027 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 2028 * mixer widget 2029 */ 2030 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ 2031 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2032 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2033 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 2034 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 2035 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 2036 2037 /* 2038 * Set up output mixers 2039 */ 2040 /* set vol=0 to output mixers */ 2041 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2042 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2043 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2044 2045 /* Setup default input to PW4 */ 2046 {0x1d, AC_VERB_SET_CONNECT_SEL, 0x1}, 2047 /* PW9 Output enable */ 2048 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 2049 /* PW10 Input enable */ 2050 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 2051 { } 2052 }; 2053 2054 static struct hda_verb vt1708B_4ch_volume_init_verbs[] = { 2055 /* 2056 * Unmute ADC0-1 and set the default input to mic-in 2057 */ 2058 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2059 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2060 2061 2062 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 2063 * mixer widget 2064 */ 2065 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ 2066 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2067 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2068 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 2069 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 2070 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 2071 2072 /* 2073 * Set up output mixers 2074 */ 2075 /* set vol=0 to output mixers */ 2076 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2077 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2078 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2079 2080 /* Setup default input of PW4 to MW0 */ 2081 {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0}, 2082 /* PW9 Output enable */ 2083 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 2084 /* PW10 Input enable */ 2085 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 2086 { } 2087 }; 2088 2089 static struct hda_verb vt1708B_uniwill_init_verbs[] = { 2090 {0x1D, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT}, 2091 { } 2092 }; 2093 2094 static struct hda_pcm_stream vt1708B_8ch_pcm_analog_playback = { 2095 .substreams = 2, 2096 .channels_min = 2, 2097 .channels_max = 8, 2098 .nid = 0x10, /* NID to query formats and rates */ 2099 .ops = { 2100 .open = via_playback_pcm_open, 2101 .prepare = via_playback_multi_pcm_prepare, 2102 .cleanup = via_playback_multi_pcm_cleanup 2103 }, 2104 }; 2105 2106 static struct hda_pcm_stream vt1708B_4ch_pcm_analog_playback = { 2107 .substreams = 2, 2108 .channels_min = 2, 2109 .channels_max = 4, 2110 .nid = 0x10, /* NID to query formats and rates */ 2111 .ops = { 2112 .open = via_playback_pcm_open, 2113 .prepare = via_playback_multi_pcm_prepare, 2114 .cleanup = via_playback_multi_pcm_cleanup 2115 }, 2116 }; 2117 2118 static struct hda_pcm_stream vt1708B_pcm_analog_capture = { 2119 .substreams = 2, 2120 .channels_min = 2, 2121 .channels_max = 2, 2122 .nid = 0x13, /* NID to query formats and rates */ 2123 .ops = { 2124 .prepare = via_capture_pcm_prepare, 2125 .cleanup = via_capture_pcm_cleanup 2126 }, 2127 }; 2128 2129 static struct hda_pcm_stream vt1708B_pcm_digital_playback = { 2130 .substreams = 1, 2131 .channels_min = 2, 2132 .channels_max = 2, 2133 /* NID is set in via_build_pcms */ 2134 .ops = { 2135 .open = via_dig_playback_pcm_open, 2136 .close = via_dig_playback_pcm_close, 2137 .prepare = via_dig_playback_pcm_prepare 2138 }, 2139 }; 2140 2141 static struct hda_pcm_stream vt1708B_pcm_digital_capture = { 2142 .substreams = 1, 2143 .channels_min = 2, 2144 .channels_max = 2, 2145 }; 2146 2147 /* fill in the dac_nids table from the parsed pin configuration */ 2148 static int vt1708B_auto_fill_dac_nids(struct via_spec *spec, 2149 const struct auto_pin_cfg *cfg) 2150 { 2151 int i; 2152 hda_nid_t nid; 2153 2154 spec->multiout.num_dacs = cfg->line_outs; 2155 2156 spec->multiout.dac_nids = spec->private_dac_nids; 2157 2158 for (i = 0; i < 4; i++) { 2159 nid = cfg->line_out_pins[i]; 2160 if (nid) { 2161 /* config dac list */ 2162 switch (i) { 2163 case AUTO_SEQ_FRONT: 2164 spec->multiout.dac_nids[i] = 0x10; 2165 break; 2166 case AUTO_SEQ_CENLFE: 2167 spec->multiout.dac_nids[i] = 0x24; 2168 break; 2169 case AUTO_SEQ_SURROUND: 2170 spec->multiout.dac_nids[i] = 0x11; 2171 break; 2172 case AUTO_SEQ_SIDE: 2173 spec->multiout.dac_nids[i] = 0x25; 2174 break; 2175 } 2176 } 2177 } 2178 2179 return 0; 2180 } 2181 2182 /* add playback controls from the parsed DAC table */ 2183 static int vt1708B_auto_create_multi_out_ctls(struct via_spec *spec, 2184 const struct auto_pin_cfg *cfg) 2185 { 2186 char name[32]; 2187 static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" }; 2188 hda_nid_t nid_vols[] = {0x16, 0x18, 0x26, 0x27}; 2189 hda_nid_t nid, nid_vol = 0; 2190 int i, err; 2191 2192 for (i = 0; i <= AUTO_SEQ_SIDE; i++) { 2193 nid = cfg->line_out_pins[i]; 2194 2195 if (!nid) 2196 continue; 2197 2198 nid_vol = nid_vols[i]; 2199 2200 if (i == AUTO_SEQ_CENLFE) { 2201 /* Center/LFE */ 2202 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 2203 "Center Playback Volume", 2204 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, 2205 HDA_OUTPUT)); 2206 if (err < 0) 2207 return err; 2208 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 2209 "LFE Playback Volume", 2210 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, 2211 HDA_OUTPUT)); 2212 if (err < 0) 2213 return err; 2214 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 2215 "Center Playback Switch", 2216 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, 2217 HDA_OUTPUT)); 2218 if (err < 0) 2219 return err; 2220 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 2221 "LFE Playback Switch", 2222 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, 2223 HDA_OUTPUT)); 2224 if (err < 0) 2225 return err; 2226 } else if (i == AUTO_SEQ_FRONT) { 2227 /* add control to mixer index 0 */ 2228 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 2229 "Master Front Playback Volume", 2230 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 2231 HDA_INPUT)); 2232 if (err < 0) 2233 return err; 2234 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 2235 "Master Front Playback Switch", 2236 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 2237 HDA_INPUT)); 2238 if (err < 0) 2239 return err; 2240 2241 /* add control to PW3 */ 2242 sprintf(name, "%s Playback Volume", chname[i]); 2243 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 2244 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 2245 HDA_OUTPUT)); 2246 if (err < 0) 2247 return err; 2248 sprintf(name, "%s Playback Switch", chname[i]); 2249 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 2250 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 2251 HDA_OUTPUT)); 2252 if (err < 0) 2253 return err; 2254 } else { 2255 sprintf(name, "%s Playback Volume", chname[i]); 2256 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 2257 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 2258 HDA_OUTPUT)); 2259 if (err < 0) 2260 return err; 2261 sprintf(name, "%s Playback Switch", chname[i]); 2262 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 2263 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 2264 HDA_OUTPUT)); 2265 if (err < 0) 2266 return err; 2267 } 2268 } 2269 2270 return 0; 2271 } 2272 2273 static int vt1708B_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) 2274 { 2275 int err; 2276 2277 if (!pin) 2278 return 0; 2279 2280 spec->multiout.hp_nid = VT1708B_HP_NID; /* AOW3 */ 2281 2282 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 2283 "Headphone Playback Volume", 2284 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 2285 if (err < 0) 2286 return err; 2287 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 2288 "Headphone Playback Switch", 2289 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 2290 if (err < 0) 2291 return err; 2292 2293 create_hp_imux(spec); 2294 2295 return 0; 2296 } 2297 2298 /* create playback/capture controls for input pins */ 2299 static int vt1708B_auto_create_analog_input_ctls(struct via_spec *spec, 2300 const struct auto_pin_cfg *cfg) 2301 { 2302 static char *labels[] = { 2303 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL 2304 }; 2305 struct hda_input_mux *imux = &spec->private_imux[0]; 2306 int i, err, idx = 0; 2307 2308 /* for internal loopback recording select */ 2309 imux->items[imux->num_items].label = "Stereo Mixer"; 2310 imux->items[imux->num_items].index = idx; 2311 imux->num_items++; 2312 2313 for (i = 0; i < AUTO_PIN_LAST; i++) { 2314 if (!cfg->input_pins[i]) 2315 continue; 2316 2317 switch (cfg->input_pins[i]) { 2318 case 0x1a: /* Mic */ 2319 idx = 2; 2320 break; 2321 2322 case 0x1b: /* Line In */ 2323 idx = 3; 2324 break; 2325 2326 case 0x1e: /* Front Mic */ 2327 idx = 4; 2328 break; 2329 2330 case 0x1f: /* CD */ 2331 idx = 1; 2332 break; 2333 } 2334 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i], 2335 idx, 0x16); 2336 if (err < 0) 2337 return err; 2338 imux->items[imux->num_items].label = labels[i]; 2339 imux->items[imux->num_items].index = idx; 2340 imux->num_items++; 2341 } 2342 return 0; 2343 } 2344 2345 static int vt1708B_parse_auto_config(struct hda_codec *codec) 2346 { 2347 struct via_spec *spec = codec->spec; 2348 int err; 2349 2350 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); 2351 if (err < 0) 2352 return err; 2353 err = vt1708B_auto_fill_dac_nids(spec, &spec->autocfg); 2354 if (err < 0) 2355 return err; 2356 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) 2357 return 0; /* can't find valid BIOS pin config */ 2358 2359 err = vt1708B_auto_create_multi_out_ctls(spec, &spec->autocfg); 2360 if (err < 0) 2361 return err; 2362 err = vt1708B_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); 2363 if (err < 0) 2364 return err; 2365 err = vt1708B_auto_create_analog_input_ctls(spec, &spec->autocfg); 2366 if (err < 0) 2367 return err; 2368 2369 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 2370 2371 if (spec->autocfg.dig_outs) 2372 spec->multiout.dig_out_nid = VT1708B_DIGOUT_NID; 2373 if (spec->autocfg.dig_in_pin) 2374 spec->dig_in_nid = VT1708B_DIGIN_NID; 2375 2376 if (spec->kctls.list) 2377 spec->mixers[spec->num_mixers++] = spec->kctls.list; 2378 2379 spec->input_mux = &spec->private_imux[0]; 2380 2381 if (spec->hp_mux) 2382 spec->mixers[spec->num_mixers++] = via_hp_mixer; 2383 2384 return 1; 2385 } 2386 2387 #ifdef CONFIG_SND_HDA_POWER_SAVE 2388 static struct hda_amp_list vt1708B_loopbacks[] = { 2389 { 0x16, HDA_INPUT, 1 }, 2390 { 0x16, HDA_INPUT, 2 }, 2391 { 0x16, HDA_INPUT, 3 }, 2392 { 0x16, HDA_INPUT, 4 }, 2393 { } /* end */ 2394 }; 2395 #endif 2396 2397 static int patch_vt1708B_8ch(struct hda_codec *codec) 2398 { 2399 struct via_spec *spec; 2400 int err; 2401 2402 /* create a codec specific record */ 2403 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 2404 if (spec == NULL) 2405 return -ENOMEM; 2406 2407 codec->spec = spec; 2408 2409 /* automatic parse from the BIOS config */ 2410 err = vt1708B_parse_auto_config(codec); 2411 if (err < 0) { 2412 via_free(codec); 2413 return err; 2414 } else if (!err) { 2415 printk(KERN_INFO "hda_codec: Cannot set up configuration " 2416 "from BIOS. Using genenic mode...\n"); 2417 } 2418 2419 spec->init_verbs[spec->num_iverbs++] = vt1708B_8ch_volume_init_verbs; 2420 spec->init_verbs[spec->num_iverbs++] = vt1708B_uniwill_init_verbs; 2421 2422 spec->stream_name_analog = "VT1708B Analog"; 2423 spec->stream_analog_playback = &vt1708B_8ch_pcm_analog_playback; 2424 spec->stream_analog_capture = &vt1708B_pcm_analog_capture; 2425 2426 spec->stream_name_digital = "VT1708B Digital"; 2427 spec->stream_digital_playback = &vt1708B_pcm_digital_playback; 2428 spec->stream_digital_capture = &vt1708B_pcm_digital_capture; 2429 2430 if (!spec->adc_nids && spec->input_mux) { 2431 spec->adc_nids = vt1708B_adc_nids; 2432 spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids); 2433 spec->mixers[spec->num_mixers] = vt1708B_capture_mixer; 2434 spec->num_mixers++; 2435 } 2436 2437 codec->patch_ops = via_patch_ops; 2438 2439 codec->patch_ops.init = via_auto_init; 2440 codec->patch_ops.unsol_event = via_unsol_event; 2441 #ifdef CONFIG_SND_HDA_POWER_SAVE 2442 spec->loopback.amplist = vt1708B_loopbacks; 2443 #endif 2444 2445 return 0; 2446 } 2447 2448 static int patch_vt1708B_4ch(struct hda_codec *codec) 2449 { 2450 struct via_spec *spec; 2451 int err; 2452 2453 /* create a codec specific record */ 2454 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 2455 if (spec == NULL) 2456 return -ENOMEM; 2457 2458 codec->spec = spec; 2459 2460 /* automatic parse from the BIOS config */ 2461 err = vt1708B_parse_auto_config(codec); 2462 if (err < 0) { 2463 via_free(codec); 2464 return err; 2465 } else if (!err) { 2466 printk(KERN_INFO "hda_codec: Cannot set up configuration " 2467 "from BIOS. Using genenic mode...\n"); 2468 } 2469 2470 spec->init_verbs[spec->num_iverbs++] = vt1708B_4ch_volume_init_verbs; 2471 spec->init_verbs[spec->num_iverbs++] = vt1708B_uniwill_init_verbs; 2472 2473 spec->stream_name_analog = "VT1708B Analog"; 2474 spec->stream_analog_playback = &vt1708B_4ch_pcm_analog_playback; 2475 spec->stream_analog_capture = &vt1708B_pcm_analog_capture; 2476 2477 spec->stream_name_digital = "VT1708B Digital"; 2478 spec->stream_digital_playback = &vt1708B_pcm_digital_playback; 2479 spec->stream_digital_capture = &vt1708B_pcm_digital_capture; 2480 2481 if (!spec->adc_nids && spec->input_mux) { 2482 spec->adc_nids = vt1708B_adc_nids; 2483 spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids); 2484 spec->mixers[spec->num_mixers] = vt1708B_capture_mixer; 2485 spec->num_mixers++; 2486 } 2487 2488 codec->patch_ops = via_patch_ops; 2489 2490 codec->patch_ops.init = via_auto_init; 2491 codec->patch_ops.unsol_event = via_unsol_event; 2492 #ifdef CONFIG_SND_HDA_POWER_SAVE 2493 spec->loopback.amplist = vt1708B_loopbacks; 2494 #endif 2495 2496 return 0; 2497 } 2498 2499 /* Patch for VT1708S */ 2500 2501 /* VT1708S software backdoor based override for buggy hardware micboost 2502 * setting */ 2503 #define MIC_BOOST_VOLUME(xname, nid) { \ 2504 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 2505 .name = xname, \ 2506 .index = 0, \ 2507 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \ 2508 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \ 2509 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \ 2510 .info = mic_boost_volume_info, \ 2511 .get = snd_hda_mixer_amp_volume_get, \ 2512 .put = snd_hda_mixer_amp_volume_put, \ 2513 .tlv = { .c = mic_boost_tlv }, \ 2514 .private_value = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT) } 2515 2516 /* capture mixer elements */ 2517 static struct snd_kcontrol_new vt1708S_capture_mixer[] = { 2518 HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT), 2519 HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT), 2520 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT), 2521 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT), 2522 MIC_BOOST_VOLUME("Mic Boost Capture Volume", 0x1A), 2523 MIC_BOOST_VOLUME("Front Mic Boost Capture Volume", 0x1E), 2524 { 2525 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2526 /* The multiple "Capture Source" controls confuse alsamixer 2527 * So call somewhat different.. 2528 */ 2529 /* .name = "Capture Source", */ 2530 .name = "Input Source", 2531 .count = 1, 2532 .info = via_mux_enum_info, 2533 .get = via_mux_enum_get, 2534 .put = via_mux_enum_put, 2535 }, 2536 { } /* end */ 2537 }; 2538 2539 static struct hda_verb vt1708S_volume_init_verbs[] = { 2540 /* Unmute ADC0-1 and set the default input to mic-in */ 2541 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2542 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2543 2544 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the 2545 * analog-loopback mixer widget */ 2546 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ 2547 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2548 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2549 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 2550 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 2551 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 2552 2553 /* Setup default input of PW4 to MW0 */ 2554 {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0}, 2555 /* PW9, PW10 Output enable */ 2556 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 2557 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 2558 /* Enable Mic Boost Volume backdoor */ 2559 {0x1, 0xf98, 0x1}, 2560 { } 2561 }; 2562 2563 static struct hda_verb vt1708S_uniwill_init_verbs[] = { 2564 {0x1D, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT}, 2565 { } 2566 }; 2567 2568 static struct hda_pcm_stream vt1708S_pcm_analog_playback = { 2569 .substreams = 2, 2570 .channels_min = 2, 2571 .channels_max = 8, 2572 .nid = 0x10, /* NID to query formats and rates */ 2573 .ops = { 2574 .open = via_playback_pcm_open, 2575 .prepare = via_playback_pcm_prepare, 2576 .cleanup = via_playback_pcm_cleanup 2577 }, 2578 }; 2579 2580 static struct hda_pcm_stream vt1708S_pcm_analog_capture = { 2581 .substreams = 2, 2582 .channels_min = 2, 2583 .channels_max = 2, 2584 .nid = 0x13, /* NID to query formats and rates */ 2585 .ops = { 2586 .prepare = via_capture_pcm_prepare, 2587 .cleanup = via_capture_pcm_cleanup 2588 }, 2589 }; 2590 2591 static struct hda_pcm_stream vt1708S_pcm_digital_playback = { 2592 .substreams = 2, 2593 .channels_min = 2, 2594 .channels_max = 2, 2595 /* NID is set in via_build_pcms */ 2596 .ops = { 2597 .open = via_dig_playback_pcm_open, 2598 .close = via_dig_playback_pcm_close, 2599 .prepare = via_dig_playback_pcm_prepare 2600 }, 2601 }; 2602 2603 /* fill in the dac_nids table from the parsed pin configuration */ 2604 static int vt1708S_auto_fill_dac_nids(struct via_spec *spec, 2605 const struct auto_pin_cfg *cfg) 2606 { 2607 int i; 2608 hda_nid_t nid; 2609 2610 spec->multiout.num_dacs = cfg->line_outs; 2611 2612 spec->multiout.dac_nids = spec->private_dac_nids; 2613 2614 for (i = 0; i < 4; i++) { 2615 nid = cfg->line_out_pins[i]; 2616 if (nid) { 2617 /* config dac list */ 2618 switch (i) { 2619 case AUTO_SEQ_FRONT: 2620 spec->multiout.dac_nids[i] = 0x10; 2621 break; 2622 case AUTO_SEQ_CENLFE: 2623 spec->multiout.dac_nids[i] = 0x24; 2624 break; 2625 case AUTO_SEQ_SURROUND: 2626 spec->multiout.dac_nids[i] = 0x11; 2627 break; 2628 case AUTO_SEQ_SIDE: 2629 spec->multiout.dac_nids[i] = 0x25; 2630 break; 2631 } 2632 } 2633 } 2634 2635 return 0; 2636 } 2637 2638 /* add playback controls from the parsed DAC table */ 2639 static int vt1708S_auto_create_multi_out_ctls(struct via_spec *spec, 2640 const struct auto_pin_cfg *cfg) 2641 { 2642 char name[32]; 2643 static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" }; 2644 hda_nid_t nid_vols[] = {0x10, 0x11, 0x24, 0x25}; 2645 hda_nid_t nid_mutes[] = {0x1C, 0x18, 0x26, 0x27}; 2646 hda_nid_t nid, nid_vol, nid_mute; 2647 int i, err; 2648 2649 for (i = 0; i <= AUTO_SEQ_SIDE; i++) { 2650 nid = cfg->line_out_pins[i]; 2651 2652 if (!nid) 2653 continue; 2654 2655 nid_vol = nid_vols[i]; 2656 nid_mute = nid_mutes[i]; 2657 2658 if (i == AUTO_SEQ_CENLFE) { 2659 /* Center/LFE */ 2660 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 2661 "Center Playback Volume", 2662 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, 2663 HDA_OUTPUT)); 2664 if (err < 0) 2665 return err; 2666 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 2667 "LFE Playback Volume", 2668 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, 2669 HDA_OUTPUT)); 2670 if (err < 0) 2671 return err; 2672 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 2673 "Center Playback Switch", 2674 HDA_COMPOSE_AMP_VAL(nid_mute, 2675 1, 0, 2676 HDA_OUTPUT)); 2677 if (err < 0) 2678 return err; 2679 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 2680 "LFE Playback Switch", 2681 HDA_COMPOSE_AMP_VAL(nid_mute, 2682 2, 0, 2683 HDA_OUTPUT)); 2684 if (err < 0) 2685 return err; 2686 } else if (i == AUTO_SEQ_FRONT) { 2687 /* add control to mixer index 0 */ 2688 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 2689 "Master Front Playback Volume", 2690 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, 2691 HDA_INPUT)); 2692 if (err < 0) 2693 return err; 2694 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 2695 "Master Front Playback Switch", 2696 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, 2697 HDA_INPUT)); 2698 if (err < 0) 2699 return err; 2700 2701 /* Front */ 2702 sprintf(name, "%s Playback Volume", chname[i]); 2703 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 2704 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 2705 HDA_OUTPUT)); 2706 if (err < 0) 2707 return err; 2708 sprintf(name, "%s Playback Switch", chname[i]); 2709 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 2710 HDA_COMPOSE_AMP_VAL(nid_mute, 2711 3, 0, 2712 HDA_OUTPUT)); 2713 if (err < 0) 2714 return err; 2715 } else { 2716 sprintf(name, "%s Playback Volume", chname[i]); 2717 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 2718 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 2719 HDA_OUTPUT)); 2720 if (err < 0) 2721 return err; 2722 sprintf(name, "%s Playback Switch", chname[i]); 2723 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 2724 HDA_COMPOSE_AMP_VAL(nid_mute, 2725 3, 0, 2726 HDA_OUTPUT)); 2727 if (err < 0) 2728 return err; 2729 } 2730 } 2731 2732 return 0; 2733 } 2734 2735 static int vt1708S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) 2736 { 2737 int err; 2738 2739 if (!pin) 2740 return 0; 2741 2742 spec->multiout.hp_nid = VT1708S_HP_NID; /* AOW3 */ 2743 2744 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 2745 "Headphone Playback Volume", 2746 HDA_COMPOSE_AMP_VAL(0x25, 3, 0, HDA_OUTPUT)); 2747 if (err < 0) 2748 return err; 2749 2750 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 2751 "Headphone Playback Switch", 2752 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 2753 if (err < 0) 2754 return err; 2755 2756 create_hp_imux(spec); 2757 2758 return 0; 2759 } 2760 2761 /* create playback/capture controls for input pins */ 2762 static int vt1708S_auto_create_analog_input_ctls(struct via_spec *spec, 2763 const struct auto_pin_cfg *cfg) 2764 { 2765 static char *labels[] = { 2766 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL 2767 }; 2768 struct hda_input_mux *imux = &spec->private_imux[0]; 2769 int i, err, idx = 0; 2770 2771 /* for internal loopback recording select */ 2772 imux->items[imux->num_items].label = "Stereo Mixer"; 2773 imux->items[imux->num_items].index = 5; 2774 imux->num_items++; 2775 2776 for (i = 0; i < AUTO_PIN_LAST; i++) { 2777 if (!cfg->input_pins[i]) 2778 continue; 2779 2780 switch (cfg->input_pins[i]) { 2781 case 0x1a: /* Mic */ 2782 idx = 2; 2783 break; 2784 2785 case 0x1b: /* Line In */ 2786 idx = 3; 2787 break; 2788 2789 case 0x1e: /* Front Mic */ 2790 idx = 4; 2791 break; 2792 2793 case 0x1f: /* CD */ 2794 idx = 1; 2795 break; 2796 } 2797 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i], 2798 idx, 0x16); 2799 if (err < 0) 2800 return err; 2801 imux->items[imux->num_items].label = labels[i]; 2802 imux->items[imux->num_items].index = idx-1; 2803 imux->num_items++; 2804 } 2805 return 0; 2806 } 2807 2808 static int vt1708S_parse_auto_config(struct hda_codec *codec) 2809 { 2810 struct via_spec *spec = codec->spec; 2811 int err; 2812 static hda_nid_t vt1708s_ignore[] = {0x21, 0}; 2813 2814 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 2815 vt1708s_ignore); 2816 if (err < 0) 2817 return err; 2818 err = vt1708S_auto_fill_dac_nids(spec, &spec->autocfg); 2819 if (err < 0) 2820 return err; 2821 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) 2822 return 0; /* can't find valid BIOS pin config */ 2823 2824 err = vt1708S_auto_create_multi_out_ctls(spec, &spec->autocfg); 2825 if (err < 0) 2826 return err; 2827 err = vt1708S_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); 2828 if (err < 0) 2829 return err; 2830 err = vt1708S_auto_create_analog_input_ctls(spec, &spec->autocfg); 2831 if (err < 0) 2832 return err; 2833 2834 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 2835 2836 if (spec->autocfg.dig_outs) 2837 spec->multiout.dig_out_nid = VT1708S_DIGOUT_NID; 2838 2839 spec->extra_dig_out_nid = 0x15; 2840 2841 if (spec->kctls.list) 2842 spec->mixers[spec->num_mixers++] = spec->kctls.list; 2843 2844 spec->input_mux = &spec->private_imux[0]; 2845 2846 if (spec->hp_mux) 2847 spec->mixers[spec->num_mixers++] = via_hp_mixer; 2848 2849 return 1; 2850 } 2851 2852 #ifdef CONFIG_SND_HDA_POWER_SAVE 2853 static struct hda_amp_list vt1708S_loopbacks[] = { 2854 { 0x16, HDA_INPUT, 1 }, 2855 { 0x16, HDA_INPUT, 2 }, 2856 { 0x16, HDA_INPUT, 3 }, 2857 { 0x16, HDA_INPUT, 4 }, 2858 { } /* end */ 2859 }; 2860 #endif 2861 2862 static int patch_vt1708S(struct hda_codec *codec) 2863 { 2864 struct via_spec *spec; 2865 int err; 2866 2867 /* create a codec specific record */ 2868 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 2869 if (spec == NULL) 2870 return -ENOMEM; 2871 2872 codec->spec = spec; 2873 2874 /* automatic parse from the BIOS config */ 2875 err = vt1708S_parse_auto_config(codec); 2876 if (err < 0) { 2877 via_free(codec); 2878 return err; 2879 } else if (!err) { 2880 printk(KERN_INFO "hda_codec: Cannot set up configuration " 2881 "from BIOS. Using genenic mode...\n"); 2882 } 2883 2884 spec->init_verbs[spec->num_iverbs++] = vt1708S_volume_init_verbs; 2885 spec->init_verbs[spec->num_iverbs++] = vt1708S_uniwill_init_verbs; 2886 2887 spec->stream_name_analog = "VT1708S Analog"; 2888 spec->stream_analog_playback = &vt1708S_pcm_analog_playback; 2889 spec->stream_analog_capture = &vt1708S_pcm_analog_capture; 2890 2891 spec->stream_name_digital = "VT1708S Digital"; 2892 spec->stream_digital_playback = &vt1708S_pcm_digital_playback; 2893 2894 if (!spec->adc_nids && spec->input_mux) { 2895 spec->adc_nids = vt1708S_adc_nids; 2896 spec->num_adc_nids = ARRAY_SIZE(vt1708S_adc_nids); 2897 spec->mixers[spec->num_mixers] = vt1708S_capture_mixer; 2898 spec->num_mixers++; 2899 } 2900 2901 codec->patch_ops = via_patch_ops; 2902 2903 codec->patch_ops.init = via_auto_init; 2904 codec->patch_ops.unsol_event = via_unsol_event; 2905 #ifdef CONFIG_SND_HDA_POWER_SAVE 2906 spec->loopback.amplist = vt1708S_loopbacks; 2907 #endif 2908 2909 return 0; 2910 } 2911 2912 /* Patch for VT1702 */ 2913 2914 /* capture mixer elements */ 2915 static struct snd_kcontrol_new vt1702_capture_mixer[] = { 2916 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_INPUT), 2917 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_INPUT), 2918 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x20, 0x0, HDA_INPUT), 2919 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x20, 0x0, HDA_INPUT), 2920 HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x1F, 0x0, HDA_INPUT), 2921 HDA_CODEC_MUTE("Digital Mic Capture Switch", 0x1F, 0x0, HDA_INPUT), 2922 HDA_CODEC_VOLUME("Digital Mic Boost Capture Volume", 0x1E, 0x0, 2923 HDA_INPUT), 2924 { 2925 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2926 /* The multiple "Capture Source" controls confuse alsamixer 2927 * So call somewhat different.. 2928 */ 2929 /* .name = "Capture Source", */ 2930 .name = "Input Source", 2931 .count = 1, 2932 .info = via_mux_enum_info, 2933 .get = via_mux_enum_get, 2934 .put = via_mux_enum_put, 2935 }, 2936 { } /* end */ 2937 }; 2938 2939 static struct hda_verb vt1702_volume_init_verbs[] = { 2940 /* 2941 * Unmute ADC0-1 and set the default input to mic-in 2942 */ 2943 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2944 {0x1F, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2945 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2946 2947 2948 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 2949 * mixer widget 2950 */ 2951 /* Amp Indices: Mic1 = 1, Line = 1, Mic2 = 3 */ 2952 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2953 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2954 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 2955 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 2956 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 2957 2958 /* Setup default input of PW4 to MW0 */ 2959 {0x17, AC_VERB_SET_CONNECT_SEL, 0x1}, 2960 /* PW6 PW7 Output enable */ 2961 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 2962 {0x1C, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 2963 { } 2964 }; 2965 2966 static struct hda_verb vt1702_uniwill_init_verbs[] = { 2967 {0x01, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_GPIO_EVENT}, 2968 {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT}, 2969 { } 2970 }; 2971 2972 static struct hda_pcm_stream vt1702_pcm_analog_playback = { 2973 .substreams = 2, 2974 .channels_min = 2, 2975 .channels_max = 2, 2976 .nid = 0x10, /* NID to query formats and rates */ 2977 .ops = { 2978 .open = via_playback_pcm_open, 2979 .prepare = via_playback_multi_pcm_prepare, 2980 .cleanup = via_playback_multi_pcm_cleanup 2981 }, 2982 }; 2983 2984 static struct hda_pcm_stream vt1702_pcm_analog_capture = { 2985 .substreams = 3, 2986 .channels_min = 2, 2987 .channels_max = 2, 2988 .nid = 0x12, /* NID to query formats and rates */ 2989 .ops = { 2990 .prepare = via_capture_pcm_prepare, 2991 .cleanup = via_capture_pcm_cleanup 2992 }, 2993 }; 2994 2995 static struct hda_pcm_stream vt1702_pcm_digital_playback = { 2996 .substreams = 2, 2997 .channels_min = 2, 2998 .channels_max = 2, 2999 /* NID is set in via_build_pcms */ 3000 .ops = { 3001 .open = via_dig_playback_pcm_open, 3002 .close = via_dig_playback_pcm_close, 3003 .prepare = via_dig_playback_pcm_prepare 3004 }, 3005 }; 3006 3007 /* fill in the dac_nids table from the parsed pin configuration */ 3008 static int vt1702_auto_fill_dac_nids(struct via_spec *spec, 3009 const struct auto_pin_cfg *cfg) 3010 { 3011 spec->multiout.num_dacs = 1; 3012 spec->multiout.dac_nids = spec->private_dac_nids; 3013 3014 if (cfg->line_out_pins[0]) { 3015 /* config dac list */ 3016 spec->multiout.dac_nids[0] = 0x10; 3017 } 3018 3019 return 0; 3020 } 3021 3022 /* add playback controls from the parsed DAC table */ 3023 static int vt1702_auto_create_line_out_ctls(struct via_spec *spec, 3024 const struct auto_pin_cfg *cfg) 3025 { 3026 int err; 3027 3028 if (!cfg->line_out_pins[0]) 3029 return -1; 3030 3031 /* add control to mixer index 0 */ 3032 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 3033 "Master Front Playback Volume", 3034 HDA_COMPOSE_AMP_VAL(0x1A, 3, 0, HDA_INPUT)); 3035 if (err < 0) 3036 return err; 3037 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 3038 "Master Front Playback Switch", 3039 HDA_COMPOSE_AMP_VAL(0x1A, 3, 0, HDA_INPUT)); 3040 if (err < 0) 3041 return err; 3042 3043 /* Front */ 3044 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 3045 "Front Playback Volume", 3046 HDA_COMPOSE_AMP_VAL(0x10, 3, 0, HDA_OUTPUT)); 3047 if (err < 0) 3048 return err; 3049 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 3050 "Front Playback Switch", 3051 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT)); 3052 if (err < 0) 3053 return err; 3054 3055 return 0; 3056 } 3057 3058 static int vt1702_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) 3059 { 3060 int err; 3061 3062 if (!pin) 3063 return 0; 3064 3065 spec->multiout.hp_nid = 0x1D; 3066 3067 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 3068 "Headphone Playback Volume", 3069 HDA_COMPOSE_AMP_VAL(0x1D, 3, 0, HDA_OUTPUT)); 3070 if (err < 0) 3071 return err; 3072 3073 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 3074 "Headphone Playback Switch", 3075 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 3076 if (err < 0) 3077 return err; 3078 3079 create_hp_imux(spec); 3080 3081 return 0; 3082 } 3083 3084 /* create playback/capture controls for input pins */ 3085 static int vt1702_auto_create_analog_input_ctls(struct via_spec *spec, 3086 const struct auto_pin_cfg *cfg) 3087 { 3088 static char *labels[] = { 3089 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL 3090 }; 3091 struct hda_input_mux *imux = &spec->private_imux[0]; 3092 int i, err, idx = 0; 3093 3094 /* for internal loopback recording select */ 3095 imux->items[imux->num_items].label = "Stereo Mixer"; 3096 imux->items[imux->num_items].index = 3; 3097 imux->num_items++; 3098 3099 for (i = 0; i < AUTO_PIN_LAST; i++) { 3100 if (!cfg->input_pins[i]) 3101 continue; 3102 3103 switch (cfg->input_pins[i]) { 3104 case 0x14: /* Mic */ 3105 idx = 1; 3106 break; 3107 3108 case 0x15: /* Line In */ 3109 idx = 2; 3110 break; 3111 3112 case 0x18: /* Front Mic */ 3113 idx = 3; 3114 break; 3115 } 3116 err = via_new_analog_input(spec, cfg->input_pins[i], 3117 labels[i], idx, 0x1A); 3118 if (err < 0) 3119 return err; 3120 imux->items[imux->num_items].label = labels[i]; 3121 imux->items[imux->num_items].index = idx-1; 3122 imux->num_items++; 3123 } 3124 return 0; 3125 } 3126 3127 static int vt1702_parse_auto_config(struct hda_codec *codec) 3128 { 3129 struct via_spec *spec = codec->spec; 3130 int err; 3131 static hda_nid_t vt1702_ignore[] = {0x1C, 0}; 3132 3133 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, 3134 vt1702_ignore); 3135 if (err < 0) 3136 return err; 3137 err = vt1702_auto_fill_dac_nids(spec, &spec->autocfg); 3138 if (err < 0) 3139 return err; 3140 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) 3141 return 0; /* can't find valid BIOS pin config */ 3142 3143 err = vt1702_auto_create_line_out_ctls(spec, &spec->autocfg); 3144 if (err < 0) 3145 return err; 3146 err = vt1702_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); 3147 if (err < 0) 3148 return err; 3149 err = vt1702_auto_create_analog_input_ctls(spec, &spec->autocfg); 3150 if (err < 0) 3151 return err; 3152 3153 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 3154 3155 if (spec->autocfg.dig_outs) 3156 spec->multiout.dig_out_nid = VT1702_DIGOUT_NID; 3157 3158 spec->extra_dig_out_nid = 0x1B; 3159 3160 if (spec->kctls.list) 3161 spec->mixers[spec->num_mixers++] = spec->kctls.list; 3162 3163 spec->input_mux = &spec->private_imux[0]; 3164 3165 if (spec->hp_mux) 3166 spec->mixers[spec->num_mixers++] = via_hp_mixer; 3167 3168 return 1; 3169 } 3170 3171 #ifdef CONFIG_SND_HDA_POWER_SAVE 3172 static struct hda_amp_list vt1702_loopbacks[] = { 3173 { 0x1A, HDA_INPUT, 1 }, 3174 { 0x1A, HDA_INPUT, 2 }, 3175 { 0x1A, HDA_INPUT, 3 }, 3176 { 0x1A, HDA_INPUT, 4 }, 3177 { } /* end */ 3178 }; 3179 #endif 3180 3181 static int patch_vt1702(struct hda_codec *codec) 3182 { 3183 struct via_spec *spec; 3184 int err; 3185 unsigned int response; 3186 unsigned char control; 3187 3188 /* create a codec specific record */ 3189 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 3190 if (spec == NULL) 3191 return -ENOMEM; 3192 3193 codec->spec = spec; 3194 3195 /* automatic parse from the BIOS config */ 3196 err = vt1702_parse_auto_config(codec); 3197 if (err < 0) { 3198 via_free(codec); 3199 return err; 3200 } else if (!err) { 3201 printk(KERN_INFO "hda_codec: Cannot set up configuration " 3202 "from BIOS. Using genenic mode...\n"); 3203 } 3204 3205 spec->init_verbs[spec->num_iverbs++] = vt1702_volume_init_verbs; 3206 spec->init_verbs[spec->num_iverbs++] = vt1702_uniwill_init_verbs; 3207 3208 spec->stream_name_analog = "VT1702 Analog"; 3209 spec->stream_analog_playback = &vt1702_pcm_analog_playback; 3210 spec->stream_analog_capture = &vt1702_pcm_analog_capture; 3211 3212 spec->stream_name_digital = "VT1702 Digital"; 3213 spec->stream_digital_playback = &vt1702_pcm_digital_playback; 3214 3215 if (!spec->adc_nids && spec->input_mux) { 3216 spec->adc_nids = vt1702_adc_nids; 3217 spec->num_adc_nids = ARRAY_SIZE(vt1702_adc_nids); 3218 spec->mixers[spec->num_mixers] = vt1702_capture_mixer; 3219 spec->num_mixers++; 3220 } 3221 3222 codec->patch_ops = via_patch_ops; 3223 3224 codec->patch_ops.init = via_auto_init; 3225 codec->patch_ops.unsol_event = via_unsol_event; 3226 #ifdef CONFIG_SND_HDA_POWER_SAVE 3227 spec->loopback.amplist = vt1702_loopbacks; 3228 #endif 3229 3230 /* Open backdoor */ 3231 response = snd_hda_codec_read(codec, codec->afg, 0, 0xF8C, 0); 3232 control = (unsigned char)(response & 0xff); 3233 control |= 0x3; 3234 snd_hda_codec_write(codec, codec->afg, 0, 0xF88, control); 3235 3236 /* Enable GPIO 0&1 for volume&mute control */ 3237 /* Enable GPIO 2 for DMIC-DATA */ 3238 response = snd_hda_codec_read(codec, codec->afg, 0, 0xF84, 0); 3239 control = (unsigned char)((response >> 16) & 0x3f); 3240 snd_hda_codec_write(codec, codec->afg, 0, 0xF82, control); 3241 3242 return 0; 3243 } 3244 3245 /* 3246 * patch entries 3247 */ 3248 static struct hda_codec_preset snd_hda_preset_via[] = { 3249 { .id = 0x11061708, .name = "VT1708", .patch = patch_vt1708}, 3250 { .id = 0x11061709, .name = "VT1708", .patch = patch_vt1708}, 3251 { .id = 0x1106170a, .name = "VT1708", .patch = patch_vt1708}, 3252 { .id = 0x1106170b, .name = "VT1708", .patch = patch_vt1708}, 3253 { .id = 0x1106e710, .name = "VT1709 10-Ch", 3254 .patch = patch_vt1709_10ch}, 3255 { .id = 0x1106e711, .name = "VT1709 10-Ch", 3256 .patch = patch_vt1709_10ch}, 3257 { .id = 0x1106e712, .name = "VT1709 10-Ch", 3258 .patch = patch_vt1709_10ch}, 3259 { .id = 0x1106e713, .name = "VT1709 10-Ch", 3260 .patch = patch_vt1709_10ch}, 3261 { .id = 0x1106e714, .name = "VT1709 6-Ch", 3262 .patch = patch_vt1709_6ch}, 3263 { .id = 0x1106e715, .name = "VT1709 6-Ch", 3264 .patch = patch_vt1709_6ch}, 3265 { .id = 0x1106e716, .name = "VT1709 6-Ch", 3266 .patch = patch_vt1709_6ch}, 3267 { .id = 0x1106e717, .name = "VT1709 6-Ch", 3268 .patch = patch_vt1709_6ch}, 3269 { .id = 0x1106e720, .name = "VT1708B 8-Ch", 3270 .patch = patch_vt1708B_8ch}, 3271 { .id = 0x1106e721, .name = "VT1708B 8-Ch", 3272 .patch = patch_vt1708B_8ch}, 3273 { .id = 0x1106e722, .name = "VT1708B 8-Ch", 3274 .patch = patch_vt1708B_8ch}, 3275 { .id = 0x1106e723, .name = "VT1708B 8-Ch", 3276 .patch = patch_vt1708B_8ch}, 3277 { .id = 0x1106e724, .name = "VT1708B 4-Ch", 3278 .patch = patch_vt1708B_4ch}, 3279 { .id = 0x1106e725, .name = "VT1708B 4-Ch", 3280 .patch = patch_vt1708B_4ch}, 3281 { .id = 0x1106e726, .name = "VT1708B 4-Ch", 3282 .patch = patch_vt1708B_4ch}, 3283 { .id = 0x1106e727, .name = "VT1708B 4-Ch", 3284 .patch = patch_vt1708B_4ch}, 3285 { .id = 0x11060397, .name = "VT1708S", 3286 .patch = patch_vt1708S}, 3287 { .id = 0x11061397, .name = "VT1708S", 3288 .patch = patch_vt1708S}, 3289 { .id = 0x11062397, .name = "VT1708S", 3290 .patch = patch_vt1708S}, 3291 { .id = 0x11063397, .name = "VT1708S", 3292 .patch = patch_vt1708S}, 3293 { .id = 0x11064397, .name = "VT1708S", 3294 .patch = patch_vt1708S}, 3295 { .id = 0x11065397, .name = "VT1708S", 3296 .patch = patch_vt1708S}, 3297 { .id = 0x11066397, .name = "VT1708S", 3298 .patch = patch_vt1708S}, 3299 { .id = 0x11067397, .name = "VT1708S", 3300 .patch = patch_vt1708S}, 3301 { .id = 0x11060398, .name = "VT1702", 3302 .patch = patch_vt1702}, 3303 { .id = 0x11061398, .name = "VT1702", 3304 .patch = patch_vt1702}, 3305 { .id = 0x11062398, .name = "VT1702", 3306 .patch = patch_vt1702}, 3307 { .id = 0x11063398, .name = "VT1702", 3308 .patch = patch_vt1702}, 3309 { .id = 0x11064398, .name = "VT1702", 3310 .patch = patch_vt1702}, 3311 { .id = 0x11065398, .name = "VT1702", 3312 .patch = patch_vt1702}, 3313 { .id = 0x11066398, .name = "VT1702", 3314 .patch = patch_vt1702}, 3315 { .id = 0x11067398, .name = "VT1702", 3316 .patch = patch_vt1702}, 3317 {} /* terminator */ 3318 }; 3319 3320 MODULE_ALIAS("snd-hda-codec-id:1106*"); 3321 3322 static struct hda_codec_preset_list via_list = { 3323 .preset = snd_hda_preset_via, 3324 .owner = THIS_MODULE, 3325 }; 3326 3327 MODULE_LICENSE("GPL"); 3328 MODULE_DESCRIPTION("VIA HD-audio codec"); 3329 3330 static int __init patch_via_init(void) 3331 { 3332 return snd_hda_add_codec_preset(&via_list); 3333 } 3334 3335 static void __exit patch_via_exit(void) 3336 { 3337 snd_hda_delete_codec_preset(&via_list); 3338 } 3339 3340 module_init(patch_via_init) 3341 module_exit(patch_via_exit) 3342