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