1 /* 2 * Universal Interface for Intel High Definition Audio Codec 3 * 4 * HD audio interface patch for VIA VT17xx/VT18xx/VT20xx codec 5 * 6 * (C) 2006-2009 VIA Technology, Inc. 7 * (C) 2006-2008 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 /* 2009-02-16 Logan Li Add support for VT1718S */ 40 /* 2009-03-13 Logan Li Add support for VT1716S */ 41 /* 2009-04-14 Lydai Wang Add support for VT1828S and VT2020 */ 42 /* 2009-07-08 Lydia Wang Add support for VT2002P */ 43 /* 2009-07-21 Lydia Wang Add support for VT1812 */ 44 /* 2009-09-19 Lydia Wang Add support for VT1818S */ 45 /* */ 46 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 47 48 49 #include <linux/init.h> 50 #include <linux/delay.h> 51 #include <linux/slab.h> 52 #include <sound/core.h> 53 #include <sound/asoundef.h> 54 #include "hda_codec.h" 55 #include "hda_local.h" 56 57 #define NID_MAPPING (-1) 58 59 /* amp values */ 60 #define AMP_VAL_IDX_SHIFT 19 61 #define AMP_VAL_IDX_MASK (0x0f<<19) 62 63 /* Pin Widget NID */ 64 #define VT1708_HP_NID 0x13 65 #define VT1708_DIGOUT_NID 0x14 66 #define VT1708_DIGIN_NID 0x16 67 #define VT1708_DIGIN_PIN 0x26 68 #define VT1708_HP_PIN_NID 0x20 69 #define VT1708_CD_PIN_NID 0x24 70 71 #define VT1709_HP_DAC_NID 0x28 72 #define VT1709_DIGOUT_NID 0x13 73 #define VT1709_DIGIN_NID 0x17 74 #define VT1709_DIGIN_PIN 0x25 75 76 #define VT1708B_HP_NID 0x25 77 #define VT1708B_DIGOUT_NID 0x12 78 #define VT1708B_DIGIN_NID 0x15 79 #define VT1708B_DIGIN_PIN 0x21 80 81 #define VT1708S_HP_NID 0x25 82 #define VT1708S_DIGOUT_NID 0x12 83 84 #define VT1702_HP_NID 0x17 85 #define VT1702_DIGOUT_NID 0x11 86 87 enum VIA_HDA_CODEC { 88 UNKNOWN = -1, 89 VT1708, 90 VT1709_10CH, 91 VT1709_6CH, 92 VT1708B_8CH, 93 VT1708B_4CH, 94 VT1708S, 95 VT1708BCE, 96 VT1702, 97 VT1718S, 98 VT1716S, 99 VT2002P, 100 VT1812, 101 VT1802, 102 CODEC_TYPES, 103 }; 104 105 #define VT2002P_COMPATIBLE(spec) \ 106 ((spec)->codec_type == VT2002P ||\ 107 (spec)->codec_type == VT1812 ||\ 108 (spec)->codec_type == VT1802) 109 110 struct via_spec { 111 /* codec parameterization */ 112 const struct snd_kcontrol_new *mixers[6]; 113 unsigned int num_mixers; 114 115 const struct hda_verb *init_verbs[5]; 116 unsigned int num_iverbs; 117 118 char *stream_name_analog; 119 const struct hda_pcm_stream *stream_analog_playback; 120 const struct hda_pcm_stream *stream_analog_capture; 121 122 char *stream_name_digital; 123 const struct hda_pcm_stream *stream_digital_playback; 124 const struct hda_pcm_stream *stream_digital_capture; 125 126 /* playback */ 127 struct hda_multi_out multiout; 128 hda_nid_t slave_dig_outs[2]; 129 130 /* capture */ 131 unsigned int num_adc_nids; 132 const hda_nid_t *adc_nids; 133 hda_nid_t mux_nids[3]; 134 hda_nid_t dig_in_nid; 135 hda_nid_t dig_in_pin; 136 137 /* capture source */ 138 const struct hda_input_mux *input_mux; 139 unsigned int cur_mux[3]; 140 141 /* PCM information */ 142 struct hda_pcm pcm_rec[3]; 143 144 /* dynamic controls, init_verbs and input_mux */ 145 struct auto_pin_cfg autocfg; 146 struct snd_array kctls; 147 struct hda_input_mux private_imux[2]; 148 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS]; 149 150 /* HP mode source */ 151 const struct hda_input_mux *hp_mux; 152 unsigned int hp_independent_mode; 153 unsigned int hp_independent_mode_index; 154 unsigned int smart51_enabled; 155 unsigned int dmic_enabled; 156 enum VIA_HDA_CODEC codec_type; 157 158 /* work to check hp jack state */ 159 struct hda_codec *codec; 160 struct delayed_work vt1708_hp_work; 161 int vt1708_jack_detectect; 162 int vt1708_hp_present; 163 164 void (*set_widgets_power_state)(struct hda_codec *codec); 165 166 #ifdef CONFIG_SND_HDA_POWER_SAVE 167 struct hda_loopback_check loopback; 168 #endif 169 }; 170 171 static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec); 172 static struct via_spec * via_new_spec(struct hda_codec *codec) 173 { 174 struct via_spec *spec; 175 176 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 177 if (spec == NULL) 178 return NULL; 179 180 codec->spec = spec; 181 spec->codec = codec; 182 spec->codec_type = get_codec_type(codec); 183 /* VT1708BCE & VT1708S are almost same */ 184 if (spec->codec_type == VT1708BCE) 185 spec->codec_type = VT1708S; 186 return spec; 187 } 188 189 static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec) 190 { 191 u32 vendor_id = codec->vendor_id; 192 u16 ven_id = vendor_id >> 16; 193 u16 dev_id = vendor_id & 0xffff; 194 enum VIA_HDA_CODEC codec_type; 195 196 /* get codec type */ 197 if (ven_id != 0x1106) 198 codec_type = UNKNOWN; 199 else if (dev_id >= 0x1708 && dev_id <= 0x170b) 200 codec_type = VT1708; 201 else if (dev_id >= 0xe710 && dev_id <= 0xe713) 202 codec_type = VT1709_10CH; 203 else if (dev_id >= 0xe714 && dev_id <= 0xe717) 204 codec_type = VT1709_6CH; 205 else if (dev_id >= 0xe720 && dev_id <= 0xe723) { 206 codec_type = VT1708B_8CH; 207 if (snd_hda_param_read(codec, 0x16, AC_PAR_CONNLIST_LEN) == 0x7) 208 codec_type = VT1708BCE; 209 } else if (dev_id >= 0xe724 && dev_id <= 0xe727) 210 codec_type = VT1708B_4CH; 211 else if ((dev_id & 0xfff) == 0x397 212 && (dev_id >> 12) < 8) 213 codec_type = VT1708S; 214 else if ((dev_id & 0xfff) == 0x398 215 && (dev_id >> 12) < 8) 216 codec_type = VT1702; 217 else if ((dev_id & 0xfff) == 0x428 218 && (dev_id >> 12) < 8) 219 codec_type = VT1718S; 220 else if (dev_id == 0x0433 || dev_id == 0xa721) 221 codec_type = VT1716S; 222 else if (dev_id == 0x0441 || dev_id == 0x4441) 223 codec_type = VT1718S; 224 else if (dev_id == 0x0438 || dev_id == 0x4438) 225 codec_type = VT2002P; 226 else if (dev_id == 0x0448) 227 codec_type = VT1812; 228 else if (dev_id == 0x0440) 229 codec_type = VT1708S; 230 else if ((dev_id & 0xfff) == 0x446) 231 codec_type = VT1802; 232 else 233 codec_type = UNKNOWN; 234 return codec_type; 235 }; 236 237 #define VIA_JACK_EVENT 0x20 238 #define VIA_HP_EVENT 0x01 239 #define VIA_GPIO_EVENT 0x02 240 #define VIA_MONO_EVENT 0x03 241 #define VIA_SPEAKER_EVENT 0x04 242 #define VIA_BIND_HP_EVENT 0x05 243 244 enum { 245 VIA_CTL_WIDGET_VOL, 246 VIA_CTL_WIDGET_MUTE, 247 VIA_CTL_WIDGET_ANALOG_MUTE, 248 VIA_CTL_WIDGET_BIND_PIN_MUTE, 249 }; 250 251 enum { 252 AUTO_SEQ_FRONT = 0, 253 AUTO_SEQ_SURROUND, 254 AUTO_SEQ_CENLFE, 255 AUTO_SEQ_SIDE 256 }; 257 258 static void analog_low_current_mode(struct hda_codec *codec, int stream_idle); 259 static int is_aa_path_mute(struct hda_codec *codec); 260 261 static void vt1708_start_hp_work(struct via_spec *spec) 262 { 263 if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0) 264 return; 265 snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81, 266 !spec->vt1708_jack_detectect); 267 if (!delayed_work_pending(&spec->vt1708_hp_work)) 268 schedule_delayed_work(&spec->vt1708_hp_work, 269 msecs_to_jiffies(100)); 270 } 271 272 static void vt1708_stop_hp_work(struct via_spec *spec) 273 { 274 if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0) 275 return; 276 if (snd_hda_get_bool_hint(spec->codec, "analog_loopback_hp_detect") == 1 277 && !is_aa_path_mute(spec->codec)) 278 return; 279 snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81, 280 !spec->vt1708_jack_detectect); 281 cancel_delayed_work_sync(&spec->vt1708_hp_work); 282 } 283 284 static void set_widgets_power_state(struct hda_codec *codec) 285 { 286 struct via_spec *spec = codec->spec; 287 if (spec->set_widgets_power_state) 288 spec->set_widgets_power_state(codec); 289 } 290 291 static int analog_input_switch_put(struct snd_kcontrol *kcontrol, 292 struct snd_ctl_elem_value *ucontrol) 293 { 294 int change = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); 295 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 296 297 set_widgets_power_state(codec); 298 analog_low_current_mode(snd_kcontrol_chip(kcontrol), -1); 299 if (snd_hda_get_bool_hint(codec, "analog_loopback_hp_detect") == 1) { 300 if (is_aa_path_mute(codec)) 301 vt1708_start_hp_work(codec->spec); 302 else 303 vt1708_stop_hp_work(codec->spec); 304 } 305 return change; 306 } 307 308 /* modify .put = snd_hda_mixer_amp_switch_put */ 309 #define ANALOG_INPUT_MUTE \ 310 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 311 .name = NULL, \ 312 .index = 0, \ 313 .info = snd_hda_mixer_amp_switch_info, \ 314 .get = snd_hda_mixer_amp_switch_get, \ 315 .put = analog_input_switch_put, \ 316 .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0) } 317 318 static void via_hp_bind_automute(struct hda_codec *codec); 319 320 static int bind_pin_switch_put(struct snd_kcontrol *kcontrol, 321 struct snd_ctl_elem_value *ucontrol) 322 { 323 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 324 struct via_spec *spec = codec->spec; 325 int i; 326 int change = 0; 327 328 long *valp = ucontrol->value.integer.value; 329 int lmute, rmute; 330 if (strstr(kcontrol->id.name, "Switch") == NULL) { 331 snd_printd("Invalid control!\n"); 332 return change; 333 } 334 change = snd_hda_mixer_amp_switch_put(kcontrol, 335 ucontrol); 336 /* Get mute value */ 337 lmute = *valp ? 0 : HDA_AMP_MUTE; 338 valp++; 339 rmute = *valp ? 0 : HDA_AMP_MUTE; 340 341 /* Set hp pins */ 342 if (!spec->hp_independent_mode) { 343 for (i = 0; i < spec->autocfg.hp_outs; i++) { 344 snd_hda_codec_amp_update( 345 codec, spec->autocfg.hp_pins[i], 346 0, HDA_OUTPUT, 0, HDA_AMP_MUTE, 347 lmute); 348 snd_hda_codec_amp_update( 349 codec, spec->autocfg.hp_pins[i], 350 1, HDA_OUTPUT, 0, HDA_AMP_MUTE, 351 rmute); 352 } 353 } 354 355 if (!lmute && !rmute) { 356 /* Line Outs */ 357 for (i = 0; i < spec->autocfg.line_outs; i++) 358 snd_hda_codec_amp_stereo( 359 codec, spec->autocfg.line_out_pins[i], 360 HDA_OUTPUT, 0, HDA_AMP_MUTE, 0); 361 /* Speakers */ 362 for (i = 0; i < spec->autocfg.speaker_outs; i++) 363 snd_hda_codec_amp_stereo( 364 codec, spec->autocfg.speaker_pins[i], 365 HDA_OUTPUT, 0, HDA_AMP_MUTE, 0); 366 /* unmute */ 367 via_hp_bind_automute(codec); 368 369 } else { 370 if (lmute) { 371 /* Mute all left channels */ 372 for (i = 1; i < spec->autocfg.line_outs; i++) 373 snd_hda_codec_amp_update( 374 codec, 375 spec->autocfg.line_out_pins[i], 376 0, HDA_OUTPUT, 0, HDA_AMP_MUTE, 377 lmute); 378 for (i = 0; i < spec->autocfg.speaker_outs; i++) 379 snd_hda_codec_amp_update( 380 codec, 381 spec->autocfg.speaker_pins[i], 382 0, HDA_OUTPUT, 0, HDA_AMP_MUTE, 383 lmute); 384 } 385 if (rmute) { 386 /* mute all right channels */ 387 for (i = 1; i < spec->autocfg.line_outs; i++) 388 snd_hda_codec_amp_update( 389 codec, 390 spec->autocfg.line_out_pins[i], 391 1, HDA_OUTPUT, 0, HDA_AMP_MUTE, 392 rmute); 393 for (i = 0; i < spec->autocfg.speaker_outs; i++) 394 snd_hda_codec_amp_update( 395 codec, 396 spec->autocfg.speaker_pins[i], 397 1, HDA_OUTPUT, 0, HDA_AMP_MUTE, 398 rmute); 399 } 400 } 401 return change; 402 } 403 404 #define BIND_PIN_MUTE \ 405 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 406 .name = NULL, \ 407 .index = 0, \ 408 .info = snd_hda_mixer_amp_switch_info, \ 409 .get = snd_hda_mixer_amp_switch_get, \ 410 .put = bind_pin_switch_put, \ 411 .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0) } 412 413 static const struct snd_kcontrol_new via_control_templates[] = { 414 HDA_CODEC_VOLUME(NULL, 0, 0, 0), 415 HDA_CODEC_MUTE(NULL, 0, 0, 0), 416 ANALOG_INPUT_MUTE, 417 BIND_PIN_MUTE, 418 }; 419 420 static const hda_nid_t vt1708_adc_nids[2] = { 421 /* ADC1-2 */ 422 0x15, 0x27 423 }; 424 425 static const hda_nid_t vt1709_adc_nids[3] = { 426 /* ADC1-2 */ 427 0x14, 0x15, 0x16 428 }; 429 430 static const hda_nid_t vt1708B_adc_nids[2] = { 431 /* ADC1-2 */ 432 0x13, 0x14 433 }; 434 435 static const hda_nid_t vt1708S_adc_nids[2] = { 436 /* ADC1-2 */ 437 0x13, 0x14 438 }; 439 440 static const hda_nid_t vt1702_adc_nids[3] = { 441 /* ADC1-2 */ 442 0x12, 0x20, 0x1F 443 }; 444 445 static const hda_nid_t vt1718S_adc_nids[2] = { 446 /* ADC1-2 */ 447 0x10, 0x11 448 }; 449 450 static const hda_nid_t vt1716S_adc_nids[2] = { 451 /* ADC1-2 */ 452 0x13, 0x14 453 }; 454 455 static const hda_nid_t vt2002P_adc_nids[2] = { 456 /* ADC1-2 */ 457 0x10, 0x11 458 }; 459 460 static const hda_nid_t vt1812_adc_nids[2] = { 461 /* ADC1-2 */ 462 0x10, 0x11 463 }; 464 465 466 /* add dynamic controls */ 467 static int __via_add_control(struct via_spec *spec, int type, const char *name, 468 int idx, unsigned long val) 469 { 470 struct snd_kcontrol_new *knew; 471 472 snd_array_init(&spec->kctls, sizeof(*knew), 32); 473 knew = snd_array_new(&spec->kctls); 474 if (!knew) 475 return -ENOMEM; 476 *knew = via_control_templates[type]; 477 knew->name = kstrdup(name, GFP_KERNEL); 478 if (!knew->name) 479 return -ENOMEM; 480 if (get_amp_nid_(val)) 481 knew->subdevice = HDA_SUBDEV_AMP_FLAG; 482 knew->private_value = val; 483 return 0; 484 } 485 486 #define via_add_control(spec, type, name, val) \ 487 __via_add_control(spec, type, name, 0, val) 488 489 static struct snd_kcontrol_new *via_clone_control(struct via_spec *spec, 490 const struct snd_kcontrol_new *tmpl) 491 { 492 struct snd_kcontrol_new *knew; 493 494 snd_array_init(&spec->kctls, sizeof(*knew), 32); 495 knew = snd_array_new(&spec->kctls); 496 if (!knew) 497 return NULL; 498 *knew = *tmpl; 499 knew->name = kstrdup(tmpl->name, GFP_KERNEL); 500 if (!knew->name) 501 return NULL; 502 return knew; 503 } 504 505 static void via_free_kctls(struct hda_codec *codec) 506 { 507 struct via_spec *spec = codec->spec; 508 509 if (spec->kctls.list) { 510 struct snd_kcontrol_new *kctl = spec->kctls.list; 511 int i; 512 for (i = 0; i < spec->kctls.used; i++) 513 kfree(kctl[i].name); 514 } 515 snd_array_free(&spec->kctls); 516 } 517 518 /* create input playback/capture controls for the given pin */ 519 static int via_new_analog_input(struct via_spec *spec, const char *ctlname, 520 int type_idx, int idx, int mix_nid) 521 { 522 char name[32]; 523 int err; 524 525 sprintf(name, "%s Playback Volume", ctlname); 526 err = __via_add_control(spec, VIA_CTL_WIDGET_VOL, name, type_idx, 527 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); 528 if (err < 0) 529 return err; 530 sprintf(name, "%s Playback Switch", ctlname); 531 err = __via_add_control(spec, VIA_CTL_WIDGET_ANALOG_MUTE, name, type_idx, 532 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); 533 if (err < 0) 534 return err; 535 return 0; 536 } 537 538 static void via_auto_set_output_and_unmute(struct hda_codec *codec, 539 hda_nid_t nid, int pin_type, 540 int dac_idx) 541 { 542 /* set as output */ 543 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 544 pin_type); 545 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, 546 AMP_OUT_UNMUTE); 547 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD) 548 snd_hda_codec_write(codec, nid, 0, 549 AC_VERB_SET_EAPD_BTLENABLE, 0x02); 550 } 551 552 553 static void via_auto_init_multi_out(struct hda_codec *codec) 554 { 555 struct via_spec *spec = codec->spec; 556 int i; 557 558 for (i = 0; i <= AUTO_SEQ_SIDE; i++) { 559 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 560 if (nid) 561 via_auto_set_output_and_unmute(codec, nid, PIN_OUT, i); 562 } 563 } 564 565 static void via_auto_init_hp_out(struct hda_codec *codec) 566 { 567 struct via_spec *spec = codec->spec; 568 hda_nid_t pin; 569 int i; 570 571 for (i = 0; i < spec->autocfg.hp_outs; i++) { 572 pin = spec->autocfg.hp_pins[i]; 573 if (pin) /* connect to front */ 574 via_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 575 } 576 } 577 578 static int is_smart51_pins(struct via_spec *spec, hda_nid_t pin); 579 580 static void via_auto_init_analog_input(struct hda_codec *codec) 581 { 582 struct via_spec *spec = codec->spec; 583 const struct auto_pin_cfg *cfg = &spec->autocfg; 584 unsigned int ctl; 585 int i; 586 587 for (i = 0; i < cfg->num_inputs; i++) { 588 hda_nid_t nid = cfg->inputs[i].pin; 589 if (spec->smart51_enabled && is_smart51_pins(spec, nid)) 590 ctl = PIN_OUT; 591 else if (cfg->inputs[i].type == AUTO_PIN_MIC) 592 ctl = PIN_VREF50; 593 else 594 ctl = PIN_IN; 595 snd_hda_codec_write(codec, nid, 0, 596 AC_VERB_SET_PIN_WIDGET_CONTROL, ctl); 597 } 598 } 599 600 static void set_pin_power_state(struct hda_codec *codec, hda_nid_t nid, 601 unsigned int *affected_parm) 602 { 603 unsigned parm; 604 unsigned def_conf = snd_hda_codec_get_pincfg(codec, nid); 605 unsigned no_presence = (def_conf & AC_DEFCFG_MISC) 606 >> AC_DEFCFG_MISC_SHIFT 607 & AC_DEFCFG_MISC_NO_PRESENCE; /* do not support pin sense */ 608 unsigned present = snd_hda_jack_detect(codec, nid); 609 struct via_spec *spec = codec->spec; 610 if ((spec->smart51_enabled && is_smart51_pins(spec, nid)) 611 || ((no_presence || present) 612 && get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)) { 613 *affected_parm = AC_PWRST_D0; /* if it's connected */ 614 parm = AC_PWRST_D0; 615 } else 616 parm = AC_PWRST_D3; 617 618 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE, parm); 619 } 620 621 /* 622 * input MUX handling 623 */ 624 static int via_mux_enum_info(struct snd_kcontrol *kcontrol, 625 struct snd_ctl_elem_info *uinfo) 626 { 627 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 628 struct via_spec *spec = codec->spec; 629 return snd_hda_input_mux_info(spec->input_mux, uinfo); 630 } 631 632 static int via_mux_enum_get(struct snd_kcontrol *kcontrol, 633 struct snd_ctl_elem_value *ucontrol) 634 { 635 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 636 struct via_spec *spec = codec->spec; 637 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 638 639 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx]; 640 return 0; 641 } 642 643 static int via_mux_enum_put(struct snd_kcontrol *kcontrol, 644 struct snd_ctl_elem_value *ucontrol) 645 { 646 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 647 struct via_spec *spec = codec->spec; 648 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 649 int ret; 650 651 if (!spec->mux_nids[adc_idx]) 652 return -EINVAL; 653 /* switch to D0 beofre change index */ 654 if (snd_hda_codec_read(codec, spec->mux_nids[adc_idx], 0, 655 AC_VERB_GET_POWER_STATE, 0x00) != AC_PWRST_D0) 656 snd_hda_codec_write(codec, spec->mux_nids[adc_idx], 0, 657 AC_VERB_SET_POWER_STATE, AC_PWRST_D0); 658 659 ret = snd_hda_input_mux_put(codec, spec->input_mux, ucontrol, 660 spec->mux_nids[adc_idx], 661 &spec->cur_mux[adc_idx]); 662 /* update jack power state */ 663 set_widgets_power_state(codec); 664 665 return ret; 666 } 667 668 static int via_independent_hp_info(struct snd_kcontrol *kcontrol, 669 struct snd_ctl_elem_info *uinfo) 670 { 671 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 672 struct via_spec *spec = codec->spec; 673 return snd_hda_input_mux_info(spec->hp_mux, uinfo); 674 } 675 676 static int via_independent_hp_get(struct snd_kcontrol *kcontrol, 677 struct snd_ctl_elem_value *ucontrol) 678 { 679 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 680 hda_nid_t nid = kcontrol->private_value; 681 unsigned int pinsel; 682 683 /* use !! to translate conn sel 2 for VT1718S */ 684 pinsel = !!snd_hda_codec_read(codec, nid, 0, 685 AC_VERB_GET_CONNECT_SEL, 686 0x00); 687 ucontrol->value.enumerated.item[0] = pinsel; 688 689 return 0; 690 } 691 692 static void activate_ctl(struct hda_codec *codec, const char *name, int active) 693 { 694 struct snd_kcontrol *ctl = snd_hda_find_mixer_ctl(codec, name); 695 if (ctl) { 696 ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE; 697 ctl->vd[0].access |= active 698 ? 0 : SNDRV_CTL_ELEM_ACCESS_INACTIVE; 699 snd_ctl_notify(codec->bus->card, 700 SNDRV_CTL_EVENT_MASK_VALUE, &ctl->id); 701 } 702 } 703 704 static hda_nid_t side_mute_channel(struct via_spec *spec) 705 { 706 switch (spec->codec_type) { 707 case VT1708: return 0x1b; 708 case VT1709_10CH: return 0x29; 709 case VT1708B_8CH: /* fall thru */ 710 case VT1708S: return 0x27; 711 case VT2002P: return 0x19; 712 case VT1802: return 0x15; 713 case VT1812: return 0x15; 714 default: return 0; 715 } 716 } 717 718 static int update_side_mute_status(struct hda_codec *codec) 719 { 720 /* mute side channel */ 721 struct via_spec *spec = codec->spec; 722 unsigned int parm; 723 hda_nid_t sw3 = side_mute_channel(spec); 724 725 if (sw3) { 726 if (VT2002P_COMPATIBLE(spec)) 727 parm = spec->hp_independent_mode ? 728 AMP_IN_MUTE(1) : AMP_IN_UNMUTE(1); 729 else 730 parm = spec->hp_independent_mode ? 731 AMP_OUT_MUTE : AMP_OUT_UNMUTE; 732 snd_hda_codec_write(codec, sw3, 0, 733 AC_VERB_SET_AMP_GAIN_MUTE, parm); 734 if (spec->codec_type == VT1812) 735 snd_hda_codec_write(codec, 0x1d, 0, 736 AC_VERB_SET_AMP_GAIN_MUTE, parm); 737 } 738 return 0; 739 } 740 741 static int via_independent_hp_put(struct snd_kcontrol *kcontrol, 742 struct snd_ctl_elem_value *ucontrol) 743 { 744 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 745 struct via_spec *spec = codec->spec; 746 hda_nid_t nid = kcontrol->private_value; 747 unsigned int pinsel = ucontrol->value.enumerated.item[0]; 748 unsigned int parm0, parm1; 749 /* Get Independent Mode index of headphone pin widget */ 750 spec->hp_independent_mode = spec->hp_independent_mode_index == pinsel 751 ? 1 : 0; 752 if (spec->codec_type == VT1718S) { 753 snd_hda_codec_write(codec, nid, 0, 754 AC_VERB_SET_CONNECT_SEL, pinsel ? 2 : 0); 755 /* Set correct mute switch for MW3 */ 756 parm0 = spec->hp_independent_mode ? 757 AMP_IN_UNMUTE(0) : AMP_IN_MUTE(0); 758 parm1 = spec->hp_independent_mode ? 759 AMP_IN_MUTE(1) : AMP_IN_UNMUTE(1); 760 snd_hda_codec_write(codec, 0x1b, 0, 761 AC_VERB_SET_AMP_GAIN_MUTE, parm0); 762 snd_hda_codec_write(codec, 0x1b, 0, 763 AC_VERB_SET_AMP_GAIN_MUTE, parm1); 764 } 765 else 766 snd_hda_codec_write(codec, nid, 0, 767 AC_VERB_SET_CONNECT_SEL, pinsel); 768 769 if (spec->codec_type == VT1812) 770 snd_hda_codec_write(codec, 0x35, 0, 771 AC_VERB_SET_CONNECT_SEL, pinsel); 772 if (spec->multiout.hp_nid && spec->multiout.hp_nid 773 != spec->multiout.dac_nids[HDA_FRONT]) 774 snd_hda_codec_setup_stream(codec, spec->multiout.hp_nid, 775 0, 0, 0); 776 777 update_side_mute_status(codec); 778 /* update HP volume/swtich active state */ 779 if (spec->codec_type == VT1708S 780 || spec->codec_type == VT1702 781 || spec->codec_type == VT1718S 782 || spec->codec_type == VT1716S 783 || VT2002P_COMPATIBLE(spec)) { 784 activate_ctl(codec, "Headphone Playback Volume", 785 spec->hp_independent_mode); 786 activate_ctl(codec, "Headphone Playback Switch", 787 spec->hp_independent_mode); 788 } 789 /* update jack power state */ 790 set_widgets_power_state(codec); 791 return 0; 792 } 793 794 static const struct snd_kcontrol_new via_hp_mixer[2] = { 795 { 796 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 797 .name = "Independent HP", 798 .info = via_independent_hp_info, 799 .get = via_independent_hp_get, 800 .put = via_independent_hp_put, 801 }, 802 { 803 .iface = NID_MAPPING, 804 .name = "Independent HP", 805 }, 806 }; 807 808 static int via_hp_build(struct hda_codec *codec) 809 { 810 struct via_spec *spec = codec->spec; 811 struct snd_kcontrol_new *knew; 812 hda_nid_t nid; 813 int nums; 814 hda_nid_t conn[HDA_MAX_CONNECTIONS]; 815 816 switch (spec->codec_type) { 817 case VT1718S: 818 nid = 0x34; 819 break; 820 case VT2002P: 821 case VT1802: 822 nid = 0x35; 823 break; 824 case VT1812: 825 nid = 0x3d; 826 break; 827 default: 828 nid = spec->autocfg.hp_pins[0]; 829 break; 830 } 831 832 if (spec->codec_type != VT1708) { 833 nums = snd_hda_get_connections(codec, nid, 834 conn, HDA_MAX_CONNECTIONS); 835 if (nums <= 1) 836 return 0; 837 } 838 839 knew = via_clone_control(spec, &via_hp_mixer[0]); 840 if (knew == NULL) 841 return -ENOMEM; 842 843 knew->subdevice = HDA_SUBDEV_NID_FLAG | nid; 844 knew->private_value = nid; 845 846 nid = side_mute_channel(spec); 847 if (nid) { 848 knew = via_clone_control(spec, &via_hp_mixer[1]); 849 if (knew == NULL) 850 return -ENOMEM; 851 knew->subdevice = nid; 852 } 853 854 return 0; 855 } 856 857 static void notify_aa_path_ctls(struct hda_codec *codec) 858 { 859 int i; 860 struct snd_ctl_elem_id id; 861 const char *labels[] = {"Mic", "Front Mic", "Line", "Rear Mic"}; 862 struct snd_kcontrol *ctl; 863 864 memset(&id, 0, sizeof(id)); 865 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 866 for (i = 0; i < ARRAY_SIZE(labels); i++) { 867 sprintf(id.name, "%s Playback Volume", labels[i]); 868 ctl = snd_hda_find_mixer_ctl(codec, id.name); 869 if (ctl) 870 snd_ctl_notify(codec->bus->card, 871 SNDRV_CTL_EVENT_MASK_VALUE, 872 &ctl->id); 873 } 874 } 875 876 static void mute_aa_path(struct hda_codec *codec, int mute) 877 { 878 struct via_spec *spec = codec->spec; 879 hda_nid_t nid_mixer; 880 int start_idx; 881 int end_idx; 882 int i; 883 /* get nid of MW0 and start & end index */ 884 switch (spec->codec_type) { 885 case VT1708: 886 nid_mixer = 0x17; 887 start_idx = 2; 888 end_idx = 4; 889 break; 890 case VT1709_10CH: 891 case VT1709_6CH: 892 nid_mixer = 0x18; 893 start_idx = 2; 894 end_idx = 4; 895 break; 896 case VT1708B_8CH: 897 case VT1708B_4CH: 898 case VT1708S: 899 case VT1716S: 900 nid_mixer = 0x16; 901 start_idx = 2; 902 end_idx = 4; 903 break; 904 case VT1718S: 905 nid_mixer = 0x21; 906 start_idx = 1; 907 end_idx = 3; 908 break; 909 default: 910 return; 911 } 912 /* check AA path's mute status */ 913 for (i = start_idx; i <= end_idx; i++) { 914 int val = mute ? HDA_AMP_MUTE : HDA_AMP_UNMUTE; 915 snd_hda_codec_amp_stereo(codec, nid_mixer, HDA_INPUT, i, 916 HDA_AMP_MUTE, val); 917 } 918 } 919 static int is_smart51_pins(struct via_spec *spec, hda_nid_t pin) 920 { 921 const struct auto_pin_cfg *cfg = &spec->autocfg; 922 int i; 923 924 for (i = 0; i < cfg->num_inputs; i++) { 925 if (pin == cfg->inputs[i].pin) 926 return cfg->inputs[i].type <= AUTO_PIN_LINE_IN; 927 } 928 return 0; 929 } 930 931 static int via_smart51_info(struct snd_kcontrol *kcontrol, 932 struct snd_ctl_elem_info *uinfo) 933 { 934 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 935 uinfo->count = 1; 936 uinfo->value.integer.min = 0; 937 uinfo->value.integer.max = 1; 938 return 0; 939 } 940 941 static int via_smart51_get(struct snd_kcontrol *kcontrol, 942 struct snd_ctl_elem_value *ucontrol) 943 { 944 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 945 struct via_spec *spec = codec->spec; 946 const struct auto_pin_cfg *cfg = &spec->autocfg; 947 int on = 1; 948 int i; 949 950 for (i = 0; i < cfg->num_inputs; i++) { 951 hda_nid_t nid = cfg->inputs[i].pin; 952 int ctl = snd_hda_codec_read(codec, nid, 0, 953 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 954 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN) 955 continue; 956 if (cfg->inputs[i].type == AUTO_PIN_MIC && 957 spec->hp_independent_mode && spec->codec_type != VT1718S) 958 continue; /* ignore FMic for independent HP */ 959 if ((ctl & AC_PINCTL_IN_EN) && !(ctl & AC_PINCTL_OUT_EN)) 960 on = 0; 961 } 962 *ucontrol->value.integer.value = on; 963 return 0; 964 } 965 966 static int via_smart51_put(struct snd_kcontrol *kcontrol, 967 struct snd_ctl_elem_value *ucontrol) 968 { 969 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 970 struct via_spec *spec = codec->spec; 971 const struct auto_pin_cfg *cfg = &spec->autocfg; 972 int out_in = *ucontrol->value.integer.value 973 ? AC_PINCTL_OUT_EN : AC_PINCTL_IN_EN; 974 int i; 975 976 for (i = 0; i < cfg->num_inputs; i++) { 977 hda_nid_t nid = cfg->inputs[i].pin; 978 unsigned int parm; 979 980 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN) 981 continue; 982 if (cfg->inputs[i].type == AUTO_PIN_MIC && 983 spec->hp_independent_mode && spec->codec_type != VT1718S) 984 continue; /* don't retask FMic for independent HP */ 985 986 parm = snd_hda_codec_read(codec, nid, 0, 987 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 988 parm &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN); 989 parm |= out_in; 990 snd_hda_codec_write(codec, nid, 0, 991 AC_VERB_SET_PIN_WIDGET_CONTROL, 992 parm); 993 if (out_in == AC_PINCTL_OUT_EN) { 994 mute_aa_path(codec, 1); 995 notify_aa_path_ctls(codec); 996 } 997 if (spec->codec_type == VT1718S) { 998 snd_hda_codec_amp_stereo( 999 codec, nid, HDA_OUTPUT, 0, HDA_AMP_MUTE, 1000 HDA_AMP_UNMUTE); 1001 } 1002 if (cfg->inputs[i].type == AUTO_PIN_MIC) { 1003 if (spec->codec_type == VT1708S 1004 || spec->codec_type == VT1716S) { 1005 /* input = index 1 (AOW3) */ 1006 snd_hda_codec_write( 1007 codec, nid, 0, 1008 AC_VERB_SET_CONNECT_SEL, 1); 1009 snd_hda_codec_amp_stereo( 1010 codec, nid, HDA_OUTPUT, 1011 0, HDA_AMP_MUTE, HDA_AMP_UNMUTE); 1012 } 1013 } 1014 } 1015 spec->smart51_enabled = *ucontrol->value.integer.value; 1016 set_widgets_power_state(codec); 1017 return 1; 1018 } 1019 1020 static const struct snd_kcontrol_new via_smart51_mixer[2] = { 1021 { 1022 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1023 .name = "Smart 5.1", 1024 .count = 1, 1025 .info = via_smart51_info, 1026 .get = via_smart51_get, 1027 .put = via_smart51_put, 1028 }, 1029 { 1030 .iface = NID_MAPPING, 1031 .name = "Smart 5.1", 1032 } 1033 }; 1034 1035 static int via_smart51_build(struct via_spec *spec) 1036 { 1037 struct snd_kcontrol_new *knew; 1038 const struct auto_pin_cfg *cfg = &spec->autocfg; 1039 hda_nid_t nid; 1040 int i; 1041 1042 if (!cfg) 1043 return 0; 1044 if (cfg->line_outs > 2) 1045 return 0; 1046 1047 knew = via_clone_control(spec, &via_smart51_mixer[0]); 1048 if (knew == NULL) 1049 return -ENOMEM; 1050 1051 for (i = 0; i < cfg->num_inputs; i++) { 1052 nid = cfg->inputs[i].pin; 1053 if (cfg->inputs[i].type <= AUTO_PIN_LINE_IN) { 1054 knew = via_clone_control(spec, &via_smart51_mixer[1]); 1055 if (knew == NULL) 1056 return -ENOMEM; 1057 knew->subdevice = nid; 1058 break; 1059 } 1060 } 1061 1062 return 0; 1063 } 1064 1065 /* capture mixer elements */ 1066 static const struct snd_kcontrol_new vt1708_capture_mixer[] = { 1067 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_INPUT), 1068 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_INPUT), 1069 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x27, 0x0, HDA_INPUT), 1070 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x27, 0x0, HDA_INPUT), 1071 { 1072 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1073 /* The multiple "Capture Source" controls confuse alsamixer 1074 * So call somewhat different.. 1075 */ 1076 /* .name = "Capture Source", */ 1077 .name = "Input Source", 1078 .count = 1, 1079 .info = via_mux_enum_info, 1080 .get = via_mux_enum_get, 1081 .put = via_mux_enum_put, 1082 }, 1083 { } /* end */ 1084 }; 1085 1086 /* check AA path's mute statue */ 1087 static int is_aa_path_mute(struct hda_codec *codec) 1088 { 1089 int mute = 1; 1090 hda_nid_t nid_mixer; 1091 int start_idx; 1092 int end_idx; 1093 int i; 1094 struct via_spec *spec = codec->spec; 1095 /* get nid of MW0 and start & end index */ 1096 switch (spec->codec_type) { 1097 case VT1708B_8CH: 1098 case VT1708B_4CH: 1099 case VT1708S: 1100 case VT1716S: 1101 nid_mixer = 0x16; 1102 start_idx = 2; 1103 end_idx = 4; 1104 break; 1105 case VT1702: 1106 nid_mixer = 0x1a; 1107 start_idx = 1; 1108 end_idx = 3; 1109 break; 1110 case VT1718S: 1111 nid_mixer = 0x21; 1112 start_idx = 1; 1113 end_idx = 3; 1114 break; 1115 case VT2002P: 1116 case VT1812: 1117 case VT1802: 1118 nid_mixer = 0x21; 1119 start_idx = 0; 1120 end_idx = 2; 1121 break; 1122 default: 1123 return 0; 1124 } 1125 /* check AA path's mute status */ 1126 for (i = start_idx; i <= end_idx; i++) { 1127 unsigned int con_list = snd_hda_codec_read( 1128 codec, nid_mixer, 0, AC_VERB_GET_CONNECT_LIST, i/4*4); 1129 int shift = 8 * (i % 4); 1130 hda_nid_t nid_pin = (con_list & (0xff << shift)) >> shift; 1131 unsigned int defconf = snd_hda_codec_get_pincfg(codec, nid_pin); 1132 if (get_defcfg_connect(defconf) == AC_JACK_PORT_COMPLEX) { 1133 /* check mute status while the pin is connected */ 1134 int mute_l = snd_hda_codec_amp_read(codec, nid_mixer, 0, 1135 HDA_INPUT, i) >> 7; 1136 int mute_r = snd_hda_codec_amp_read(codec, nid_mixer, 1, 1137 HDA_INPUT, i) >> 7; 1138 if (!mute_l || !mute_r) { 1139 mute = 0; 1140 break; 1141 } 1142 } 1143 } 1144 return mute; 1145 } 1146 1147 /* enter/exit analog low-current mode */ 1148 static void analog_low_current_mode(struct hda_codec *codec, int stream_idle) 1149 { 1150 struct via_spec *spec = codec->spec; 1151 static int saved_stream_idle = 1; /* saved stream idle status */ 1152 int enable = is_aa_path_mute(codec); 1153 unsigned int verb = 0; 1154 unsigned int parm = 0; 1155 1156 if (stream_idle == -1) /* stream status did not change */ 1157 enable = enable && saved_stream_idle; 1158 else { 1159 enable = enable && stream_idle; 1160 saved_stream_idle = stream_idle; 1161 } 1162 1163 /* decide low current mode's verb & parameter */ 1164 switch (spec->codec_type) { 1165 case VT1708B_8CH: 1166 case VT1708B_4CH: 1167 verb = 0xf70; 1168 parm = enable ? 0x02 : 0x00; /* 0x02: 2/3x, 0x00: 1x */ 1169 break; 1170 case VT1708S: 1171 case VT1718S: 1172 case VT1716S: 1173 verb = 0xf73; 1174 parm = enable ? 0x51 : 0xe1; /* 0x51: 4/28x, 0xe1: 1x */ 1175 break; 1176 case VT1702: 1177 verb = 0xf73; 1178 parm = enable ? 0x01 : 0x1d; /* 0x01: 4/40x, 0x1d: 1x */ 1179 break; 1180 case VT2002P: 1181 case VT1812: 1182 case VT1802: 1183 verb = 0xf93; 1184 parm = enable ? 0x00 : 0xe0; /* 0x00: 4/40x, 0xe0: 1x */ 1185 break; 1186 default: 1187 return; /* other codecs are not supported */ 1188 } 1189 /* send verb */ 1190 snd_hda_codec_write(codec, codec->afg, 0, verb, parm); 1191 } 1192 1193 /* 1194 * generic initialization of ADC, input mixers and output mixers 1195 */ 1196 static const struct hda_verb vt1708_volume_init_verbs[] = { 1197 /* 1198 * Unmute ADC0-1 and set the default input to mic-in 1199 */ 1200 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1201 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1202 1203 1204 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 1205 * mixer widget 1206 */ 1207 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ 1208 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1209 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 1210 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 1211 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 1212 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 1213 1214 /* 1215 * Set up output mixers (0x19 - 0x1b) 1216 */ 1217 /* set vol=0 to output mixers */ 1218 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1219 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1220 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 1221 1222 /* Setup default input MW0 to PW4 */ 1223 {0x20, AC_VERB_SET_CONNECT_SEL, 0}, 1224 /* PW9 Output enable */ 1225 {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 1226 /* power down jack detect function */ 1227 {0x1, 0xf81, 0x1}, 1228 { } 1229 }; 1230 1231 static int via_playback_pcm_open(struct hda_pcm_stream *hinfo, 1232 struct hda_codec *codec, 1233 struct snd_pcm_substream *substream) 1234 { 1235 struct via_spec *spec = codec->spec; 1236 int idle = substream->pstr->substream_opened == 1 1237 && substream->ref_count == 0; 1238 analog_low_current_mode(codec, idle); 1239 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, 1240 hinfo); 1241 } 1242 1243 static void playback_multi_pcm_prep_0(struct hda_codec *codec, 1244 unsigned int stream_tag, 1245 unsigned int format, 1246 struct snd_pcm_substream *substream) 1247 { 1248 struct via_spec *spec = codec->spec; 1249 struct hda_multi_out *mout = &spec->multiout; 1250 const hda_nid_t *nids = mout->dac_nids; 1251 int chs = substream->runtime->channels; 1252 int i; 1253 1254 mutex_lock(&codec->spdif_mutex); 1255 if (mout->dig_out_nid && mout->dig_out_used != HDA_DIG_EXCLUSIVE) { 1256 if (chs == 2 && 1257 snd_hda_is_supported_format(codec, mout->dig_out_nid, 1258 format) && 1259 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) { 1260 mout->dig_out_used = HDA_DIG_ANALOG_DUP; 1261 /* turn off SPDIF once; otherwise the IEC958 bits won't 1262 * be updated */ 1263 if (codec->spdif_ctls & AC_DIG1_ENABLE) 1264 snd_hda_codec_write(codec, mout->dig_out_nid, 0, 1265 AC_VERB_SET_DIGI_CONVERT_1, 1266 codec->spdif_ctls & 1267 ~AC_DIG1_ENABLE & 0xff); 1268 snd_hda_codec_setup_stream(codec, mout->dig_out_nid, 1269 stream_tag, 0, format); 1270 /* turn on again (if needed) */ 1271 if (codec->spdif_ctls & AC_DIG1_ENABLE) 1272 snd_hda_codec_write(codec, mout->dig_out_nid, 0, 1273 AC_VERB_SET_DIGI_CONVERT_1, 1274 codec->spdif_ctls & 0xff); 1275 } else { 1276 mout->dig_out_used = 0; 1277 snd_hda_codec_setup_stream(codec, mout->dig_out_nid, 1278 0, 0, 0); 1279 } 1280 } 1281 mutex_unlock(&codec->spdif_mutex); 1282 1283 /* front */ 1284 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag, 1285 0, format); 1286 1287 if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] 1288 && !spec->hp_independent_mode) 1289 /* headphone out will just decode front left/right (stereo) */ 1290 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag, 1291 0, format); 1292 1293 /* extra outputs copied from front */ 1294 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) 1295 if (mout->extra_out_nid[i]) 1296 snd_hda_codec_setup_stream(codec, 1297 mout->extra_out_nid[i], 1298 stream_tag, 0, format); 1299 1300 /* surrounds */ 1301 for (i = 1; i < mout->num_dacs; i++) { 1302 if (chs >= (i + 1) * 2) /* independent out */ 1303 snd_hda_codec_setup_stream(codec, nids[i], stream_tag, 1304 i * 2, format); 1305 else /* copy front */ 1306 snd_hda_codec_setup_stream(codec, nids[i], stream_tag, 1307 0, format); 1308 } 1309 } 1310 1311 static int via_playback_multi_pcm_prepare(struct hda_pcm_stream *hinfo, 1312 struct hda_codec *codec, 1313 unsigned int stream_tag, 1314 unsigned int format, 1315 struct snd_pcm_substream *substream) 1316 { 1317 struct via_spec *spec = codec->spec; 1318 struct hda_multi_out *mout = &spec->multiout; 1319 const hda_nid_t *nids = mout->dac_nids; 1320 1321 if (substream->number == 0) 1322 playback_multi_pcm_prep_0(codec, stream_tag, format, 1323 substream); 1324 else { 1325 if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] && 1326 spec->hp_independent_mode) 1327 snd_hda_codec_setup_stream(codec, mout->hp_nid, 1328 stream_tag, 0, format); 1329 } 1330 vt1708_start_hp_work(spec); 1331 return 0; 1332 } 1333 1334 static int via_playback_multi_pcm_cleanup(struct hda_pcm_stream *hinfo, 1335 struct hda_codec *codec, 1336 struct snd_pcm_substream *substream) 1337 { 1338 struct via_spec *spec = codec->spec; 1339 struct hda_multi_out *mout = &spec->multiout; 1340 const hda_nid_t *nids = mout->dac_nids; 1341 int i; 1342 1343 if (substream->number == 0) { 1344 for (i = 0; i < mout->num_dacs; i++) 1345 snd_hda_codec_setup_stream(codec, nids[i], 0, 0, 0); 1346 1347 if (mout->hp_nid && !spec->hp_independent_mode) 1348 snd_hda_codec_setup_stream(codec, mout->hp_nid, 1349 0, 0, 0); 1350 1351 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) 1352 if (mout->extra_out_nid[i]) 1353 snd_hda_codec_setup_stream(codec, 1354 mout->extra_out_nid[i], 1355 0, 0, 0); 1356 mutex_lock(&codec->spdif_mutex); 1357 if (mout->dig_out_nid && 1358 mout->dig_out_used == HDA_DIG_ANALOG_DUP) { 1359 snd_hda_codec_setup_stream(codec, mout->dig_out_nid, 1360 0, 0, 0); 1361 mout->dig_out_used = 0; 1362 } 1363 mutex_unlock(&codec->spdif_mutex); 1364 } else { 1365 if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] && 1366 spec->hp_independent_mode) 1367 snd_hda_codec_setup_stream(codec, mout->hp_nid, 1368 0, 0, 0); 1369 } 1370 vt1708_stop_hp_work(spec); 1371 return 0; 1372 } 1373 1374 /* 1375 * Digital out 1376 */ 1377 static int via_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, 1378 struct hda_codec *codec, 1379 struct snd_pcm_substream *substream) 1380 { 1381 struct via_spec *spec = codec->spec; 1382 return snd_hda_multi_out_dig_open(codec, &spec->multiout); 1383 } 1384 1385 static int via_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, 1386 struct hda_codec *codec, 1387 struct snd_pcm_substream *substream) 1388 { 1389 struct via_spec *spec = codec->spec; 1390 return snd_hda_multi_out_dig_close(codec, &spec->multiout); 1391 } 1392 1393 static int via_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 1394 struct hda_codec *codec, 1395 unsigned int stream_tag, 1396 unsigned int format, 1397 struct snd_pcm_substream *substream) 1398 { 1399 struct via_spec *spec = codec->spec; 1400 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, 1401 stream_tag, format, substream); 1402 } 1403 1404 static int via_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 1405 struct hda_codec *codec, 1406 struct snd_pcm_substream *substream) 1407 { 1408 struct via_spec *spec = codec->spec; 1409 snd_hda_multi_out_dig_cleanup(codec, &spec->multiout); 1410 return 0; 1411 } 1412 1413 /* 1414 * Analog capture 1415 */ 1416 static int via_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 1417 struct hda_codec *codec, 1418 unsigned int stream_tag, 1419 unsigned int format, 1420 struct snd_pcm_substream *substream) 1421 { 1422 struct via_spec *spec = codec->spec; 1423 1424 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 1425 stream_tag, 0, format); 1426 return 0; 1427 } 1428 1429 static int via_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 1430 struct hda_codec *codec, 1431 struct snd_pcm_substream *substream) 1432 { 1433 struct via_spec *spec = codec->spec; 1434 snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]); 1435 return 0; 1436 } 1437 1438 static const struct hda_pcm_stream vt1708_pcm_analog_playback = { 1439 .substreams = 2, 1440 .channels_min = 2, 1441 .channels_max = 8, 1442 .nid = 0x10, /* NID to query formats and rates */ 1443 .ops = { 1444 .open = via_playback_pcm_open, 1445 .prepare = via_playback_multi_pcm_prepare, 1446 .cleanup = via_playback_multi_pcm_cleanup 1447 }, 1448 }; 1449 1450 static const struct hda_pcm_stream vt1708_pcm_analog_s16_playback = { 1451 .substreams = 2, 1452 .channels_min = 2, 1453 .channels_max = 8, 1454 .nid = 0x10, /* NID to query formats and rates */ 1455 /* We got noisy outputs on the right channel on VT1708 when 1456 * 24bit samples are used. Until any workaround is found, 1457 * disable the 24bit format, so far. 1458 */ 1459 .formats = SNDRV_PCM_FMTBIT_S16_LE, 1460 .ops = { 1461 .open = via_playback_pcm_open, 1462 .prepare = via_playback_multi_pcm_prepare, 1463 .cleanup = via_playback_multi_pcm_cleanup 1464 }, 1465 }; 1466 1467 static const struct hda_pcm_stream vt1708_pcm_analog_capture = { 1468 .substreams = 2, 1469 .channels_min = 2, 1470 .channels_max = 2, 1471 .nid = 0x15, /* NID to query formats and rates */ 1472 .ops = { 1473 .prepare = via_capture_pcm_prepare, 1474 .cleanup = via_capture_pcm_cleanup 1475 }, 1476 }; 1477 1478 static const struct hda_pcm_stream vt1708_pcm_digital_playback = { 1479 .substreams = 1, 1480 .channels_min = 2, 1481 .channels_max = 2, 1482 /* NID is set in via_build_pcms */ 1483 .ops = { 1484 .open = via_dig_playback_pcm_open, 1485 .close = via_dig_playback_pcm_close, 1486 .prepare = via_dig_playback_pcm_prepare, 1487 .cleanup = via_dig_playback_pcm_cleanup 1488 }, 1489 }; 1490 1491 static const struct hda_pcm_stream vt1708_pcm_digital_capture = { 1492 .substreams = 1, 1493 .channels_min = 2, 1494 .channels_max = 2, 1495 }; 1496 1497 static int via_build_controls(struct hda_codec *codec) 1498 { 1499 struct via_spec *spec = codec->spec; 1500 struct snd_kcontrol *kctl; 1501 const struct snd_kcontrol_new *knew; 1502 int err, i; 1503 1504 for (i = 0; i < spec->num_mixers; i++) { 1505 err = snd_hda_add_new_ctls(codec, spec->mixers[i]); 1506 if (err < 0) 1507 return err; 1508 } 1509 1510 if (spec->multiout.dig_out_nid) { 1511 err = snd_hda_create_spdif_out_ctls(codec, 1512 spec->multiout.dig_out_nid); 1513 if (err < 0) 1514 return err; 1515 err = snd_hda_create_spdif_share_sw(codec, 1516 &spec->multiout); 1517 if (err < 0) 1518 return err; 1519 spec->multiout.share_spdif = 1; 1520 } 1521 if (spec->dig_in_nid) { 1522 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid); 1523 if (err < 0) 1524 return err; 1525 } 1526 1527 /* assign Capture Source enums to NID */ 1528 kctl = snd_hda_find_mixer_ctl(codec, "Input Source"); 1529 for (i = 0; kctl && i < kctl->count; i++) { 1530 err = snd_hda_add_nid(codec, kctl, i, spec->mux_nids[i]); 1531 if (err < 0) 1532 return err; 1533 } 1534 1535 /* other nid->control mapping */ 1536 for (i = 0; i < spec->num_mixers; i++) { 1537 for (knew = spec->mixers[i]; knew->name; knew++) { 1538 if (knew->iface != NID_MAPPING) 1539 continue; 1540 kctl = snd_hda_find_mixer_ctl(codec, knew->name); 1541 if (kctl == NULL) 1542 continue; 1543 err = snd_hda_add_nid(codec, kctl, 0, 1544 knew->subdevice); 1545 } 1546 } 1547 1548 /* init power states */ 1549 set_widgets_power_state(codec); 1550 analog_low_current_mode(codec, 1); 1551 1552 via_free_kctls(codec); /* no longer needed */ 1553 return 0; 1554 } 1555 1556 static int via_build_pcms(struct hda_codec *codec) 1557 { 1558 struct via_spec *spec = codec->spec; 1559 struct hda_pcm *info = spec->pcm_rec; 1560 1561 codec->num_pcms = 1; 1562 codec->pcm_info = info; 1563 1564 info->name = spec->stream_name_analog; 1565 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 1566 *(spec->stream_analog_playback); 1567 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 1568 spec->multiout.dac_nids[0]; 1569 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture); 1570 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; 1571 1572 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 1573 spec->multiout.max_channels; 1574 1575 if (spec->multiout.dig_out_nid || spec->dig_in_nid) { 1576 codec->num_pcms++; 1577 info++; 1578 info->name = spec->stream_name_digital; 1579 info->pcm_type = HDA_PCM_TYPE_SPDIF; 1580 if (spec->multiout.dig_out_nid) { 1581 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 1582 *(spec->stream_digital_playback); 1583 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 1584 spec->multiout.dig_out_nid; 1585 } 1586 if (spec->dig_in_nid) { 1587 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 1588 *(spec->stream_digital_capture); 1589 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 1590 spec->dig_in_nid; 1591 } 1592 } 1593 1594 return 0; 1595 } 1596 1597 static void via_free(struct hda_codec *codec) 1598 { 1599 struct via_spec *spec = codec->spec; 1600 1601 if (!spec) 1602 return; 1603 1604 via_free_kctls(codec); 1605 vt1708_stop_hp_work(spec); 1606 kfree(codec->spec); 1607 } 1608 1609 /* mute internal speaker if HP is plugged */ 1610 static void via_hp_automute(struct hda_codec *codec) 1611 { 1612 unsigned int present = 0; 1613 struct via_spec *spec = codec->spec; 1614 1615 present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]); 1616 1617 if (!spec->hp_independent_mode) { 1618 struct snd_ctl_elem_id id; 1619 /* auto mute */ 1620 snd_hda_codec_amp_stereo( 1621 codec, spec->autocfg.line_out_pins[0], HDA_OUTPUT, 0, 1622 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 1623 /* notify change */ 1624 memset(&id, 0, sizeof(id)); 1625 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1626 strcpy(id.name, "Front Playback Switch"); 1627 snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE, 1628 &id); 1629 } 1630 } 1631 1632 /* mute mono out if HP or Line out is plugged */ 1633 static void via_mono_automute(struct hda_codec *codec) 1634 { 1635 unsigned int hp_present, lineout_present; 1636 struct via_spec *spec = codec->spec; 1637 1638 if (spec->codec_type != VT1716S) 1639 return; 1640 1641 lineout_present = snd_hda_jack_detect(codec, 1642 spec->autocfg.line_out_pins[0]); 1643 1644 /* Mute Mono Out if Line Out is plugged */ 1645 if (lineout_present) { 1646 snd_hda_codec_amp_stereo( 1647 codec, 0x2A, HDA_OUTPUT, 0, HDA_AMP_MUTE, HDA_AMP_MUTE); 1648 return; 1649 } 1650 1651 hp_present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]); 1652 1653 if (!spec->hp_independent_mode) 1654 snd_hda_codec_amp_stereo( 1655 codec, 0x2A, HDA_OUTPUT, 0, HDA_AMP_MUTE, 1656 hp_present ? HDA_AMP_MUTE : 0); 1657 } 1658 1659 static void via_gpio_control(struct hda_codec *codec) 1660 { 1661 unsigned int gpio_data; 1662 unsigned int vol_counter; 1663 unsigned int vol; 1664 unsigned int master_vol; 1665 1666 struct via_spec *spec = codec->spec; 1667 1668 gpio_data = snd_hda_codec_read(codec, codec->afg, 0, 1669 AC_VERB_GET_GPIO_DATA, 0) & 0x03; 1670 1671 vol_counter = (snd_hda_codec_read(codec, codec->afg, 0, 1672 0xF84, 0) & 0x3F0000) >> 16; 1673 1674 vol = vol_counter & 0x1F; 1675 master_vol = snd_hda_codec_read(codec, 0x1A, 0, 1676 AC_VERB_GET_AMP_GAIN_MUTE, 1677 AC_AMP_GET_INPUT); 1678 1679 if (gpio_data == 0x02) { 1680 /* unmute line out */ 1681 snd_hda_codec_amp_stereo(codec, spec->autocfg.line_out_pins[0], 1682 HDA_OUTPUT, 0, HDA_AMP_MUTE, 0); 1683 1684 if (vol_counter & 0x20) { 1685 /* decrease volume */ 1686 if (vol > master_vol) 1687 vol = master_vol; 1688 snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT, 1689 0, HDA_AMP_VOLMASK, 1690 master_vol-vol); 1691 } else { 1692 /* increase volume */ 1693 snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT, 0, 1694 HDA_AMP_VOLMASK, 1695 ((master_vol+vol) > 0x2A) ? 0x2A : 1696 (master_vol+vol)); 1697 } 1698 } else if (!(gpio_data & 0x02)) { 1699 /* mute line out */ 1700 snd_hda_codec_amp_stereo(codec, 1701 spec->autocfg.line_out_pins[0], 1702 HDA_OUTPUT, 0, HDA_AMP_MUTE, 1703 HDA_AMP_MUTE); 1704 } 1705 } 1706 1707 /* mute Internal-Speaker if HP is plugged */ 1708 static void via_speaker_automute(struct hda_codec *codec) 1709 { 1710 unsigned int hp_present; 1711 struct via_spec *spec = codec->spec; 1712 1713 if (!VT2002P_COMPATIBLE(spec)) 1714 return; 1715 1716 hp_present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]); 1717 1718 if (!spec->hp_independent_mode) { 1719 struct snd_ctl_elem_id id; 1720 snd_hda_codec_amp_stereo( 1721 codec, spec->autocfg.speaker_pins[0], HDA_OUTPUT, 0, 1722 HDA_AMP_MUTE, hp_present ? HDA_AMP_MUTE : 0); 1723 /* notify change */ 1724 memset(&id, 0, sizeof(id)); 1725 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 1726 strcpy(id.name, "Speaker Playback Switch"); 1727 snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE, 1728 &id); 1729 } 1730 } 1731 1732 /* mute line-out and internal speaker if HP is plugged */ 1733 static void via_hp_bind_automute(struct hda_codec *codec) 1734 { 1735 /* use long instead of int below just to avoid an internal compiler 1736 * error with gcc 4.0.x 1737 */ 1738 unsigned long hp_present, present = 0; 1739 struct via_spec *spec = codec->spec; 1740 int i; 1741 1742 if (!spec->autocfg.hp_pins[0] || !spec->autocfg.line_out_pins[0]) 1743 return; 1744 1745 hp_present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]); 1746 1747 present = snd_hda_jack_detect(codec, spec->autocfg.line_out_pins[0]); 1748 1749 if (!spec->hp_independent_mode) { 1750 /* Mute Line-Outs */ 1751 for (i = 0; i < spec->autocfg.line_outs; i++) 1752 snd_hda_codec_amp_stereo( 1753 codec, spec->autocfg.line_out_pins[i], 1754 HDA_OUTPUT, 0, 1755 HDA_AMP_MUTE, hp_present ? HDA_AMP_MUTE : 0); 1756 if (hp_present) 1757 present = hp_present; 1758 } 1759 /* Speakers */ 1760 for (i = 0; i < spec->autocfg.speaker_outs; i++) 1761 snd_hda_codec_amp_stereo( 1762 codec, spec->autocfg.speaker_pins[i], HDA_OUTPUT, 0, 1763 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 1764 } 1765 1766 1767 /* unsolicited event for jack sensing */ 1768 static void via_unsol_event(struct hda_codec *codec, 1769 unsigned int res) 1770 { 1771 res >>= 26; 1772 1773 if (res & VIA_JACK_EVENT) 1774 set_widgets_power_state(codec); 1775 1776 res &= ~VIA_JACK_EVENT; 1777 1778 if (res == VIA_HP_EVENT) 1779 via_hp_automute(codec); 1780 else if (res == VIA_GPIO_EVENT) 1781 via_gpio_control(codec); 1782 else if (res == VIA_MONO_EVENT) 1783 via_mono_automute(codec); 1784 else if (res == VIA_SPEAKER_EVENT) 1785 via_speaker_automute(codec); 1786 else if (res == VIA_BIND_HP_EVENT) 1787 via_hp_bind_automute(codec); 1788 } 1789 1790 static int via_init(struct hda_codec *codec) 1791 { 1792 struct via_spec *spec = codec->spec; 1793 int i; 1794 for (i = 0; i < spec->num_iverbs; i++) 1795 snd_hda_sequence_write(codec, spec->init_verbs[i]); 1796 1797 /* Lydia Add for EAPD enable */ 1798 if (!spec->dig_in_nid) { /* No Digital In connection */ 1799 if (spec->dig_in_pin) { 1800 snd_hda_codec_write(codec, spec->dig_in_pin, 0, 1801 AC_VERB_SET_PIN_WIDGET_CONTROL, 1802 PIN_OUT); 1803 snd_hda_codec_write(codec, spec->dig_in_pin, 0, 1804 AC_VERB_SET_EAPD_BTLENABLE, 0x02); 1805 } 1806 } else /* enable SPDIF-input pin */ 1807 snd_hda_codec_write(codec, spec->autocfg.dig_in_pin, 0, 1808 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN); 1809 1810 /* assign slave outs */ 1811 if (spec->slave_dig_outs[0]) 1812 codec->slave_dig_outs = spec->slave_dig_outs; 1813 1814 return 0; 1815 } 1816 1817 #ifdef SND_HDA_NEEDS_RESUME 1818 static int via_suspend(struct hda_codec *codec, pm_message_t state) 1819 { 1820 struct via_spec *spec = codec->spec; 1821 vt1708_stop_hp_work(spec); 1822 return 0; 1823 } 1824 #endif 1825 1826 #ifdef CONFIG_SND_HDA_POWER_SAVE 1827 static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid) 1828 { 1829 struct via_spec *spec = codec->spec; 1830 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid); 1831 } 1832 #endif 1833 1834 /* 1835 */ 1836 static const struct hda_codec_ops via_patch_ops = { 1837 .build_controls = via_build_controls, 1838 .build_pcms = via_build_pcms, 1839 .init = via_init, 1840 .free = via_free, 1841 #ifdef SND_HDA_NEEDS_RESUME 1842 .suspend = via_suspend, 1843 #endif 1844 #ifdef CONFIG_SND_HDA_POWER_SAVE 1845 .check_power_status = via_check_power_status, 1846 #endif 1847 }; 1848 1849 /* fill in the dac_nids table from the parsed pin configuration */ 1850 static int vt1708_auto_fill_dac_nids(struct via_spec *spec, 1851 const struct auto_pin_cfg *cfg) 1852 { 1853 int i; 1854 hda_nid_t nid; 1855 1856 spec->multiout.num_dacs = cfg->line_outs; 1857 1858 spec->multiout.dac_nids = spec->private_dac_nids; 1859 1860 for (i = 0; i < 4; i++) { 1861 nid = cfg->line_out_pins[i]; 1862 if (nid) { 1863 /* config dac list */ 1864 switch (i) { 1865 case AUTO_SEQ_FRONT: 1866 spec->private_dac_nids[i] = 0x10; 1867 break; 1868 case AUTO_SEQ_CENLFE: 1869 spec->private_dac_nids[i] = 0x12; 1870 break; 1871 case AUTO_SEQ_SURROUND: 1872 spec->private_dac_nids[i] = 0x11; 1873 break; 1874 case AUTO_SEQ_SIDE: 1875 spec->private_dac_nids[i] = 0x13; 1876 break; 1877 } 1878 } 1879 } 1880 1881 return 0; 1882 } 1883 1884 /* add playback controls from the parsed DAC table */ 1885 static int vt1708_auto_create_multi_out_ctls(struct via_spec *spec, 1886 const struct auto_pin_cfg *cfg) 1887 { 1888 char name[32]; 1889 static const char * const chname[4] = { 1890 "Front", "Surround", "C/LFE", "Side" 1891 }; 1892 hda_nid_t nid, nid_vol, nid_vols[] = {0x17, 0x19, 0x1a, 0x1b}; 1893 int i, err; 1894 1895 for (i = 0; i <= AUTO_SEQ_SIDE; i++) { 1896 nid = cfg->line_out_pins[i]; 1897 1898 if (!nid) 1899 continue; 1900 1901 nid_vol = nid_vols[i]; 1902 1903 if (i == AUTO_SEQ_CENLFE) { 1904 /* Center/LFE */ 1905 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 1906 "Center Playback Volume", 1907 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, 1908 HDA_OUTPUT)); 1909 if (err < 0) 1910 return err; 1911 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 1912 "LFE Playback Volume", 1913 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, 1914 HDA_OUTPUT)); 1915 if (err < 0) 1916 return err; 1917 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 1918 "Center Playback Switch", 1919 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, 1920 HDA_OUTPUT)); 1921 if (err < 0) 1922 return err; 1923 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 1924 "LFE Playback Switch", 1925 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, 1926 HDA_OUTPUT)); 1927 if (err < 0) 1928 return err; 1929 } else if (i == AUTO_SEQ_FRONT) { 1930 /* add control to mixer index 0 */ 1931 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 1932 "Master Front Playback Volume", 1933 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 1934 HDA_INPUT)); 1935 if (err < 0) 1936 return err; 1937 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 1938 "Master Front Playback Switch", 1939 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 1940 HDA_INPUT)); 1941 if (err < 0) 1942 return err; 1943 1944 /* add control to PW3 */ 1945 sprintf(name, "%s Playback Volume", chname[i]); 1946 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 1947 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 1948 HDA_OUTPUT)); 1949 if (err < 0) 1950 return err; 1951 sprintf(name, "%s Playback Switch", chname[i]); 1952 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 1953 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 1954 HDA_OUTPUT)); 1955 if (err < 0) 1956 return err; 1957 } else { 1958 sprintf(name, "%s Playback Volume", chname[i]); 1959 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 1960 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 1961 HDA_OUTPUT)); 1962 if (err < 0) 1963 return err; 1964 sprintf(name, "%s Playback Switch", chname[i]); 1965 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 1966 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 1967 HDA_OUTPUT)); 1968 if (err < 0) 1969 return err; 1970 } 1971 } 1972 1973 return 0; 1974 } 1975 1976 static void create_hp_imux(struct via_spec *spec) 1977 { 1978 int i; 1979 struct hda_input_mux *imux = &spec->private_imux[1]; 1980 static const char * const texts[] = { "OFF", "ON", NULL}; 1981 1982 /* for hp mode select */ 1983 for (i = 0; texts[i]; i++) 1984 snd_hda_add_imux_item(imux, texts[i], i, NULL); 1985 1986 spec->hp_mux = &spec->private_imux[1]; 1987 } 1988 1989 static int vt1708_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) 1990 { 1991 int err; 1992 1993 if (!pin) 1994 return 0; 1995 1996 spec->multiout.hp_nid = VT1708_HP_NID; /* AOW3 */ 1997 spec->hp_independent_mode_index = 1; 1998 1999 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 2000 "Headphone Playback Volume", 2001 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 2002 if (err < 0) 2003 return err; 2004 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 2005 "Headphone Playback Switch", 2006 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 2007 if (err < 0) 2008 return err; 2009 2010 create_hp_imux(spec); 2011 2012 return 0; 2013 } 2014 2015 /* create playback/capture controls for input pins */ 2016 static int vt_auto_create_analog_input_ctls(struct hda_codec *codec, 2017 const struct auto_pin_cfg *cfg, 2018 hda_nid_t cap_nid, 2019 const hda_nid_t pin_idxs[], 2020 int num_idxs) 2021 { 2022 struct via_spec *spec = codec->spec; 2023 struct hda_input_mux *imux = &spec->private_imux[0]; 2024 int i, err, idx, type, type_idx = 0; 2025 2026 /* for internal loopback recording select */ 2027 for (idx = 0; idx < num_idxs; idx++) { 2028 if (pin_idxs[idx] == 0xff) { 2029 snd_hda_add_imux_item(imux, "Stereo Mixer", idx, NULL); 2030 break; 2031 } 2032 } 2033 2034 for (i = 0; i < cfg->num_inputs; i++) { 2035 const char *label; 2036 type = cfg->inputs[i].type; 2037 for (idx = 0; idx < num_idxs; idx++) 2038 if (pin_idxs[idx] == cfg->inputs[i].pin) 2039 break; 2040 if (idx >= num_idxs) 2041 continue; 2042 if (i > 0 && type == cfg->inputs[i - 1].type) 2043 type_idx++; 2044 else 2045 type_idx = 0; 2046 label = hda_get_autocfg_input_label(codec, cfg, i); 2047 if (spec->codec_type == VT1708S || 2048 spec->codec_type == VT1702 || 2049 spec->codec_type == VT1716S) 2050 err = via_new_analog_input(spec, label, type_idx, 2051 idx+1, cap_nid); 2052 else 2053 err = via_new_analog_input(spec, label, type_idx, 2054 idx, cap_nid); 2055 if (err < 0) 2056 return err; 2057 snd_hda_add_imux_item(imux, label, idx, NULL); 2058 } 2059 return 0; 2060 } 2061 2062 /* create playback/capture controls for input pins */ 2063 static int vt1708_auto_create_analog_input_ctls(struct hda_codec *codec, 2064 const struct auto_pin_cfg *cfg) 2065 { 2066 static const hda_nid_t pin_idxs[] = { 0xff, 0x24, 0x1d, 0x1e, 0x21 }; 2067 return vt_auto_create_analog_input_ctls(codec, cfg, 0x17, pin_idxs, 2068 ARRAY_SIZE(pin_idxs)); 2069 } 2070 2071 #ifdef CONFIG_SND_HDA_POWER_SAVE 2072 static const struct hda_amp_list vt1708_loopbacks[] = { 2073 { 0x17, HDA_INPUT, 1 }, 2074 { 0x17, HDA_INPUT, 2 }, 2075 { 0x17, HDA_INPUT, 3 }, 2076 { 0x17, HDA_INPUT, 4 }, 2077 { } /* end */ 2078 }; 2079 #endif 2080 2081 static void vt1708_set_pinconfig_connect(struct hda_codec *codec, hda_nid_t nid) 2082 { 2083 unsigned int def_conf; 2084 unsigned char seqassoc; 2085 2086 def_conf = snd_hda_codec_get_pincfg(codec, nid); 2087 seqassoc = (unsigned char) get_defcfg_association(def_conf); 2088 seqassoc = (seqassoc << 4) | get_defcfg_sequence(def_conf); 2089 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE 2090 && (seqassoc == 0xf0 || seqassoc == 0xff)) { 2091 def_conf = def_conf & (~(AC_JACK_PORT_BOTH << 30)); 2092 snd_hda_codec_set_pincfg(codec, nid, def_conf); 2093 } 2094 2095 return; 2096 } 2097 2098 static int vt1708_jack_detectect_get(struct snd_kcontrol *kcontrol, 2099 struct snd_ctl_elem_value *ucontrol) 2100 { 2101 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2102 struct via_spec *spec = codec->spec; 2103 2104 if (spec->codec_type != VT1708) 2105 return 0; 2106 spec->vt1708_jack_detectect = 2107 !((snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8) & 0x1); 2108 ucontrol->value.integer.value[0] = spec->vt1708_jack_detectect; 2109 return 0; 2110 } 2111 2112 static int vt1708_jack_detectect_put(struct snd_kcontrol *kcontrol, 2113 struct snd_ctl_elem_value *ucontrol) 2114 { 2115 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2116 struct via_spec *spec = codec->spec; 2117 int change; 2118 2119 if (spec->codec_type != VT1708) 2120 return 0; 2121 spec->vt1708_jack_detectect = ucontrol->value.integer.value[0]; 2122 change = (0x1 & (snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8)) 2123 == !spec->vt1708_jack_detectect; 2124 if (spec->vt1708_jack_detectect) { 2125 mute_aa_path(codec, 1); 2126 notify_aa_path_ctls(codec); 2127 } 2128 return change; 2129 } 2130 2131 static const struct snd_kcontrol_new vt1708_jack_detectect[] = { 2132 { 2133 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2134 .name = "Jack Detect", 2135 .count = 1, 2136 .info = snd_ctl_boolean_mono_info, 2137 .get = vt1708_jack_detectect_get, 2138 .put = vt1708_jack_detectect_put, 2139 }, 2140 {} /* end */ 2141 }; 2142 2143 static int vt1708_parse_auto_config(struct hda_codec *codec) 2144 { 2145 struct via_spec *spec = codec->spec; 2146 int err; 2147 2148 /* Add HP and CD pin config connect bit re-config action */ 2149 vt1708_set_pinconfig_connect(codec, VT1708_HP_PIN_NID); 2150 vt1708_set_pinconfig_connect(codec, VT1708_CD_PIN_NID); 2151 2152 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); 2153 if (err < 0) 2154 return err; 2155 err = vt1708_auto_fill_dac_nids(spec, &spec->autocfg); 2156 if (err < 0) 2157 return err; 2158 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) 2159 return 0; /* can't find valid BIOS pin config */ 2160 2161 err = vt1708_auto_create_multi_out_ctls(spec, &spec->autocfg); 2162 if (err < 0) 2163 return err; 2164 err = vt1708_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); 2165 if (err < 0) 2166 return err; 2167 err = vt1708_auto_create_analog_input_ctls(codec, &spec->autocfg); 2168 if (err < 0) 2169 return err; 2170 /* add jack detect on/off control */ 2171 err = snd_hda_add_new_ctls(codec, vt1708_jack_detectect); 2172 if (err < 0) 2173 return err; 2174 2175 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 2176 2177 if (spec->autocfg.dig_outs) 2178 spec->multiout.dig_out_nid = VT1708_DIGOUT_NID; 2179 spec->dig_in_pin = VT1708_DIGIN_PIN; 2180 if (spec->autocfg.dig_in_pin) 2181 spec->dig_in_nid = VT1708_DIGIN_NID; 2182 2183 if (spec->kctls.list) 2184 spec->mixers[spec->num_mixers++] = spec->kctls.list; 2185 2186 spec->init_verbs[spec->num_iverbs++] = vt1708_volume_init_verbs; 2187 2188 spec->input_mux = &spec->private_imux[0]; 2189 2190 if (spec->hp_mux) 2191 via_hp_build(codec); 2192 2193 via_smart51_build(spec); 2194 return 1; 2195 } 2196 2197 /* init callback for auto-configuration model -- overriding the default init */ 2198 static int via_auto_init(struct hda_codec *codec) 2199 { 2200 struct via_spec *spec = codec->spec; 2201 2202 via_init(codec); 2203 via_auto_init_multi_out(codec); 2204 via_auto_init_hp_out(codec); 2205 via_auto_init_analog_input(codec); 2206 2207 if (VT2002P_COMPATIBLE(spec)) { 2208 via_hp_bind_automute(codec); 2209 } else { 2210 via_hp_automute(codec); 2211 via_speaker_automute(codec); 2212 } 2213 2214 return 0; 2215 } 2216 2217 static void vt1708_update_hp_jack_state(struct work_struct *work) 2218 { 2219 struct via_spec *spec = container_of(work, struct via_spec, 2220 vt1708_hp_work.work); 2221 if (spec->codec_type != VT1708) 2222 return; 2223 /* if jack state toggled */ 2224 if (spec->vt1708_hp_present 2225 != snd_hda_jack_detect(spec->codec, spec->autocfg.hp_pins[0])) { 2226 spec->vt1708_hp_present ^= 1; 2227 via_hp_automute(spec->codec); 2228 } 2229 vt1708_start_hp_work(spec); 2230 } 2231 2232 static int get_mux_nids(struct hda_codec *codec) 2233 { 2234 struct via_spec *spec = codec->spec; 2235 hda_nid_t nid, conn[8]; 2236 unsigned int type; 2237 int i, n; 2238 2239 for (i = 0; i < spec->num_adc_nids; i++) { 2240 nid = spec->adc_nids[i]; 2241 while (nid) { 2242 type = get_wcaps_type(get_wcaps(codec, nid)); 2243 if (type == AC_WID_PIN) 2244 break; 2245 n = snd_hda_get_connections(codec, nid, conn, 2246 ARRAY_SIZE(conn)); 2247 if (n <= 0) 2248 break; 2249 if (n > 1) { 2250 spec->mux_nids[i] = nid; 2251 break; 2252 } 2253 nid = conn[0]; 2254 } 2255 } 2256 return 0; 2257 } 2258 2259 static int patch_vt1708(struct hda_codec *codec) 2260 { 2261 struct via_spec *spec; 2262 int err; 2263 2264 /* create a codec specific record */ 2265 spec = via_new_spec(codec); 2266 if (spec == NULL) 2267 return -ENOMEM; 2268 2269 /* automatic parse from the BIOS config */ 2270 err = vt1708_parse_auto_config(codec); 2271 if (err < 0) { 2272 via_free(codec); 2273 return err; 2274 } else if (!err) { 2275 printk(KERN_INFO "hda_codec: Cannot set up configuration " 2276 "from BIOS. Using genenic mode...\n"); 2277 } 2278 2279 2280 spec->stream_name_analog = "VT1708 Analog"; 2281 spec->stream_analog_playback = &vt1708_pcm_analog_playback; 2282 /* disable 32bit format on VT1708 */ 2283 if (codec->vendor_id == 0x11061708) 2284 spec->stream_analog_playback = &vt1708_pcm_analog_s16_playback; 2285 spec->stream_analog_capture = &vt1708_pcm_analog_capture; 2286 2287 spec->stream_name_digital = "VT1708 Digital"; 2288 spec->stream_digital_playback = &vt1708_pcm_digital_playback; 2289 spec->stream_digital_capture = &vt1708_pcm_digital_capture; 2290 2291 2292 if (!spec->adc_nids && spec->input_mux) { 2293 spec->adc_nids = vt1708_adc_nids; 2294 spec->num_adc_nids = ARRAY_SIZE(vt1708_adc_nids); 2295 get_mux_nids(codec); 2296 spec->mixers[spec->num_mixers] = vt1708_capture_mixer; 2297 spec->num_mixers++; 2298 } 2299 2300 codec->patch_ops = via_patch_ops; 2301 2302 codec->patch_ops.init = via_auto_init; 2303 #ifdef CONFIG_SND_HDA_POWER_SAVE 2304 spec->loopback.amplist = vt1708_loopbacks; 2305 #endif 2306 INIT_DELAYED_WORK(&spec->vt1708_hp_work, vt1708_update_hp_jack_state); 2307 return 0; 2308 } 2309 2310 /* capture mixer elements */ 2311 static const struct snd_kcontrol_new vt1709_capture_mixer[] = { 2312 HDA_CODEC_VOLUME("Capture Volume", 0x14, 0x0, HDA_INPUT), 2313 HDA_CODEC_MUTE("Capture Switch", 0x14, 0x0, HDA_INPUT), 2314 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x15, 0x0, HDA_INPUT), 2315 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x15, 0x0, HDA_INPUT), 2316 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x16, 0x0, HDA_INPUT), 2317 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x16, 0x0, HDA_INPUT), 2318 { 2319 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2320 /* The multiple "Capture Source" controls confuse alsamixer 2321 * So call somewhat different.. 2322 */ 2323 /* .name = "Capture Source", */ 2324 .name = "Input Source", 2325 .count = 1, 2326 .info = via_mux_enum_info, 2327 .get = via_mux_enum_get, 2328 .put = via_mux_enum_put, 2329 }, 2330 { } /* end */ 2331 }; 2332 2333 static const struct hda_verb vt1709_uniwill_init_verbs[] = { 2334 {0x20, AC_VERB_SET_UNSOLICITED_ENABLE, 2335 AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT}, 2336 { } 2337 }; 2338 2339 /* 2340 * generic initialization of ADC, input mixers and output mixers 2341 */ 2342 static const struct hda_verb vt1709_10ch_volume_init_verbs[] = { 2343 /* 2344 * Unmute ADC0-2 and set the default input to mic-in 2345 */ 2346 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2347 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2348 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2349 2350 2351 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 2352 * mixer widget 2353 */ 2354 /* Amp Indices: AOW0=0, CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ 2355 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2356 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2357 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 2358 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 2359 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 2360 2361 /* 2362 * Set up output selector (0x1a, 0x1b, 0x29) 2363 */ 2364 /* set vol=0 to output mixers */ 2365 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2366 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2367 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2368 2369 /* 2370 * Unmute PW3 and PW4 2371 */ 2372 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2373 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2374 2375 /* Set input of PW4 as MW0 */ 2376 {0x20, AC_VERB_SET_CONNECT_SEL, 0}, 2377 /* PW9 Output enable */ 2378 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 2379 { } 2380 }; 2381 2382 static const struct hda_pcm_stream vt1709_10ch_pcm_analog_playback = { 2383 .substreams = 1, 2384 .channels_min = 2, 2385 .channels_max = 10, 2386 .nid = 0x10, /* NID to query formats and rates */ 2387 .ops = { 2388 .open = via_playback_pcm_open, 2389 .prepare = via_playback_multi_pcm_prepare, 2390 .cleanup = via_playback_multi_pcm_cleanup, 2391 }, 2392 }; 2393 2394 static const struct hda_pcm_stream vt1709_6ch_pcm_analog_playback = { 2395 .substreams = 1, 2396 .channels_min = 2, 2397 .channels_max = 6, 2398 .nid = 0x10, /* NID to query formats and rates */ 2399 .ops = { 2400 .open = via_playback_pcm_open, 2401 .prepare = via_playback_multi_pcm_prepare, 2402 .cleanup = via_playback_multi_pcm_cleanup, 2403 }, 2404 }; 2405 2406 static const struct hda_pcm_stream vt1709_pcm_analog_capture = { 2407 .substreams = 2, 2408 .channels_min = 2, 2409 .channels_max = 2, 2410 .nid = 0x14, /* NID to query formats and rates */ 2411 .ops = { 2412 .prepare = via_capture_pcm_prepare, 2413 .cleanup = via_capture_pcm_cleanup 2414 }, 2415 }; 2416 2417 static const struct hda_pcm_stream vt1709_pcm_digital_playback = { 2418 .substreams = 1, 2419 .channels_min = 2, 2420 .channels_max = 2, 2421 /* NID is set in via_build_pcms */ 2422 .ops = { 2423 .open = via_dig_playback_pcm_open, 2424 .close = via_dig_playback_pcm_close 2425 }, 2426 }; 2427 2428 static const struct hda_pcm_stream vt1709_pcm_digital_capture = { 2429 .substreams = 1, 2430 .channels_min = 2, 2431 .channels_max = 2, 2432 }; 2433 2434 static int vt1709_auto_fill_dac_nids(struct via_spec *spec, 2435 const struct auto_pin_cfg *cfg) 2436 { 2437 int i; 2438 hda_nid_t nid; 2439 2440 if (cfg->line_outs == 4) /* 10 channels */ 2441 spec->multiout.num_dacs = cfg->line_outs+1; /* AOW0~AOW4 */ 2442 else if (cfg->line_outs == 3) /* 6 channels */ 2443 spec->multiout.num_dacs = cfg->line_outs; /* AOW0~AOW2 */ 2444 2445 spec->multiout.dac_nids = spec->private_dac_nids; 2446 2447 if (cfg->line_outs == 4) { /* 10 channels */ 2448 for (i = 0; i < cfg->line_outs; i++) { 2449 nid = cfg->line_out_pins[i]; 2450 if (nid) { 2451 /* config dac list */ 2452 switch (i) { 2453 case AUTO_SEQ_FRONT: 2454 /* AOW0 */ 2455 spec->private_dac_nids[i] = 0x10; 2456 break; 2457 case AUTO_SEQ_CENLFE: 2458 /* AOW2 */ 2459 spec->private_dac_nids[i] = 0x12; 2460 break; 2461 case AUTO_SEQ_SURROUND: 2462 /* AOW3 */ 2463 spec->private_dac_nids[i] = 0x11; 2464 break; 2465 case AUTO_SEQ_SIDE: 2466 /* AOW1 */ 2467 spec->private_dac_nids[i] = 0x27; 2468 break; 2469 default: 2470 break; 2471 } 2472 } 2473 } 2474 spec->private_dac_nids[cfg->line_outs] = 0x28; /* AOW4 */ 2475 2476 } else if (cfg->line_outs == 3) { /* 6 channels */ 2477 for (i = 0; i < cfg->line_outs; i++) { 2478 nid = cfg->line_out_pins[i]; 2479 if (nid) { 2480 /* config dac list */ 2481 switch (i) { 2482 case AUTO_SEQ_FRONT: 2483 /* AOW0 */ 2484 spec->private_dac_nids[i] = 0x10; 2485 break; 2486 case AUTO_SEQ_CENLFE: 2487 /* AOW2 */ 2488 spec->private_dac_nids[i] = 0x12; 2489 break; 2490 case AUTO_SEQ_SURROUND: 2491 /* AOW1 */ 2492 spec->private_dac_nids[i] = 0x11; 2493 break; 2494 default: 2495 break; 2496 } 2497 } 2498 } 2499 } 2500 2501 return 0; 2502 } 2503 2504 /* add playback controls from the parsed DAC table */ 2505 static int vt1709_auto_create_multi_out_ctls(struct via_spec *spec, 2506 const struct auto_pin_cfg *cfg) 2507 { 2508 char name[32]; 2509 static const char * const chname[4] = { 2510 "Front", "Surround", "C/LFE", "Side" 2511 }; 2512 hda_nid_t nid, nid_vol, nid_vols[] = {0x18, 0x1a, 0x1b, 0x29}; 2513 int i, err; 2514 2515 for (i = 0; i <= AUTO_SEQ_SIDE; i++) { 2516 nid = cfg->line_out_pins[i]; 2517 2518 if (!nid) 2519 continue; 2520 2521 nid_vol = nid_vols[i]; 2522 2523 if (i == AUTO_SEQ_CENLFE) { 2524 /* Center/LFE */ 2525 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 2526 "Center Playback Volume", 2527 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, 2528 HDA_OUTPUT)); 2529 if (err < 0) 2530 return err; 2531 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 2532 "LFE Playback Volume", 2533 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, 2534 HDA_OUTPUT)); 2535 if (err < 0) 2536 return err; 2537 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 2538 "Center Playback Switch", 2539 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, 2540 HDA_OUTPUT)); 2541 if (err < 0) 2542 return err; 2543 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 2544 "LFE Playback Switch", 2545 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, 2546 HDA_OUTPUT)); 2547 if (err < 0) 2548 return err; 2549 } else if (i == AUTO_SEQ_FRONT) { 2550 /* ADD control to mixer index 0 */ 2551 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 2552 "Master Front Playback Volume", 2553 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 2554 HDA_INPUT)); 2555 if (err < 0) 2556 return err; 2557 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 2558 "Master Front Playback Switch", 2559 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 2560 HDA_INPUT)); 2561 if (err < 0) 2562 return err; 2563 2564 /* add control to PW3 */ 2565 sprintf(name, "%s Playback Volume", chname[i]); 2566 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 2567 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 2568 HDA_OUTPUT)); 2569 if (err < 0) 2570 return err; 2571 sprintf(name, "%s Playback Switch", chname[i]); 2572 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 2573 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 2574 HDA_OUTPUT)); 2575 if (err < 0) 2576 return err; 2577 } else if (i == AUTO_SEQ_SURROUND) { 2578 sprintf(name, "%s Playback Volume", chname[i]); 2579 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 2580 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 2581 HDA_OUTPUT)); 2582 if (err < 0) 2583 return err; 2584 sprintf(name, "%s Playback Switch", chname[i]); 2585 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 2586 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 2587 HDA_OUTPUT)); 2588 if (err < 0) 2589 return err; 2590 } else if (i == AUTO_SEQ_SIDE) { 2591 sprintf(name, "%s Playback Volume", chname[i]); 2592 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 2593 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 2594 HDA_OUTPUT)); 2595 if (err < 0) 2596 return err; 2597 sprintf(name, "%s Playback Switch", chname[i]); 2598 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 2599 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 2600 HDA_OUTPUT)); 2601 if (err < 0) 2602 return err; 2603 } 2604 } 2605 2606 return 0; 2607 } 2608 2609 static int vt1709_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) 2610 { 2611 int err; 2612 2613 if (!pin) 2614 return 0; 2615 2616 if (spec->multiout.num_dacs == 5) /* 10 channels */ 2617 spec->multiout.hp_nid = VT1709_HP_DAC_NID; 2618 else if (spec->multiout.num_dacs == 3) /* 6 channels */ 2619 spec->multiout.hp_nid = 0; 2620 spec->hp_independent_mode_index = 1; 2621 2622 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 2623 "Headphone Playback Volume", 2624 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 2625 if (err < 0) 2626 return err; 2627 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 2628 "Headphone Playback Switch", 2629 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 2630 if (err < 0) 2631 return err; 2632 2633 return 0; 2634 } 2635 2636 /* create playback/capture controls for input pins */ 2637 static int vt1709_auto_create_analog_input_ctls(struct hda_codec *codec, 2638 const struct auto_pin_cfg *cfg) 2639 { 2640 static const hda_nid_t pin_idxs[] = { 0xff, 0x23, 0x1d, 0x1e, 0x21 }; 2641 return vt_auto_create_analog_input_ctls(codec, cfg, 0x18, pin_idxs, 2642 ARRAY_SIZE(pin_idxs)); 2643 } 2644 2645 static int vt1709_parse_auto_config(struct hda_codec *codec) 2646 { 2647 struct via_spec *spec = codec->spec; 2648 int err; 2649 2650 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); 2651 if (err < 0) 2652 return err; 2653 err = vt1709_auto_fill_dac_nids(spec, &spec->autocfg); 2654 if (err < 0) 2655 return err; 2656 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) 2657 return 0; /* can't find valid BIOS pin config */ 2658 2659 err = vt1709_auto_create_multi_out_ctls(spec, &spec->autocfg); 2660 if (err < 0) 2661 return err; 2662 err = vt1709_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); 2663 if (err < 0) 2664 return err; 2665 err = vt1709_auto_create_analog_input_ctls(codec, &spec->autocfg); 2666 if (err < 0) 2667 return err; 2668 2669 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 2670 2671 if (spec->autocfg.dig_outs) 2672 spec->multiout.dig_out_nid = VT1709_DIGOUT_NID; 2673 spec->dig_in_pin = VT1709_DIGIN_PIN; 2674 if (spec->autocfg.dig_in_pin) 2675 spec->dig_in_nid = VT1709_DIGIN_NID; 2676 2677 if (spec->kctls.list) 2678 spec->mixers[spec->num_mixers++] = spec->kctls.list; 2679 2680 spec->input_mux = &spec->private_imux[0]; 2681 2682 if (spec->hp_mux) 2683 via_hp_build(codec); 2684 2685 via_smart51_build(spec); 2686 return 1; 2687 } 2688 2689 #ifdef CONFIG_SND_HDA_POWER_SAVE 2690 static const struct hda_amp_list vt1709_loopbacks[] = { 2691 { 0x18, HDA_INPUT, 1 }, 2692 { 0x18, HDA_INPUT, 2 }, 2693 { 0x18, HDA_INPUT, 3 }, 2694 { 0x18, HDA_INPUT, 4 }, 2695 { } /* end */ 2696 }; 2697 #endif 2698 2699 static int patch_vt1709_10ch(struct hda_codec *codec) 2700 { 2701 struct via_spec *spec; 2702 int err; 2703 2704 /* create a codec specific record */ 2705 spec = via_new_spec(codec); 2706 if (spec == NULL) 2707 return -ENOMEM; 2708 2709 err = vt1709_parse_auto_config(codec); 2710 if (err < 0) { 2711 via_free(codec); 2712 return err; 2713 } else if (!err) { 2714 printk(KERN_INFO "hda_codec: Cannot set up configuration. " 2715 "Using genenic mode...\n"); 2716 } 2717 2718 spec->init_verbs[spec->num_iverbs++] = vt1709_10ch_volume_init_verbs; 2719 spec->init_verbs[spec->num_iverbs++] = vt1709_uniwill_init_verbs; 2720 2721 spec->stream_name_analog = "VT1709 Analog"; 2722 spec->stream_analog_playback = &vt1709_10ch_pcm_analog_playback; 2723 spec->stream_analog_capture = &vt1709_pcm_analog_capture; 2724 2725 spec->stream_name_digital = "VT1709 Digital"; 2726 spec->stream_digital_playback = &vt1709_pcm_digital_playback; 2727 spec->stream_digital_capture = &vt1709_pcm_digital_capture; 2728 2729 2730 if (!spec->adc_nids && spec->input_mux) { 2731 spec->adc_nids = vt1709_adc_nids; 2732 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids); 2733 get_mux_nids(codec); 2734 spec->mixers[spec->num_mixers] = vt1709_capture_mixer; 2735 spec->num_mixers++; 2736 } 2737 2738 codec->patch_ops = via_patch_ops; 2739 2740 codec->patch_ops.init = via_auto_init; 2741 codec->patch_ops.unsol_event = via_unsol_event; 2742 #ifdef CONFIG_SND_HDA_POWER_SAVE 2743 spec->loopback.amplist = vt1709_loopbacks; 2744 #endif 2745 2746 return 0; 2747 } 2748 /* 2749 * generic initialization of ADC, input mixers and output mixers 2750 */ 2751 static const struct hda_verb vt1709_6ch_volume_init_verbs[] = { 2752 /* 2753 * Unmute ADC0-2 and set the default input to mic-in 2754 */ 2755 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2756 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2757 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2758 2759 2760 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 2761 * mixer widget 2762 */ 2763 /* Amp Indices: AOW0=0, CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ 2764 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2765 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2766 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 2767 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 2768 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 2769 2770 /* 2771 * Set up output selector (0x1a, 0x1b, 0x29) 2772 */ 2773 /* set vol=0 to output mixers */ 2774 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2775 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2776 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2777 2778 /* 2779 * Unmute PW3 and PW4 2780 */ 2781 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2782 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2783 2784 /* Set input of PW4 as MW0 */ 2785 {0x20, AC_VERB_SET_CONNECT_SEL, 0}, 2786 /* PW9 Output enable */ 2787 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 2788 { } 2789 }; 2790 2791 static int patch_vt1709_6ch(struct hda_codec *codec) 2792 { 2793 struct via_spec *spec; 2794 int err; 2795 2796 /* create a codec specific record */ 2797 spec = via_new_spec(codec); 2798 if (spec == NULL) 2799 return -ENOMEM; 2800 2801 err = vt1709_parse_auto_config(codec); 2802 if (err < 0) { 2803 via_free(codec); 2804 return err; 2805 } else if (!err) { 2806 printk(KERN_INFO "hda_codec: Cannot set up configuration. " 2807 "Using genenic mode...\n"); 2808 } 2809 2810 spec->init_verbs[spec->num_iverbs++] = vt1709_6ch_volume_init_verbs; 2811 spec->init_verbs[spec->num_iverbs++] = vt1709_uniwill_init_verbs; 2812 2813 spec->stream_name_analog = "VT1709 Analog"; 2814 spec->stream_analog_playback = &vt1709_6ch_pcm_analog_playback; 2815 spec->stream_analog_capture = &vt1709_pcm_analog_capture; 2816 2817 spec->stream_name_digital = "VT1709 Digital"; 2818 spec->stream_digital_playback = &vt1709_pcm_digital_playback; 2819 spec->stream_digital_capture = &vt1709_pcm_digital_capture; 2820 2821 2822 if (!spec->adc_nids && spec->input_mux) { 2823 spec->adc_nids = vt1709_adc_nids; 2824 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids); 2825 get_mux_nids(codec); 2826 spec->mixers[spec->num_mixers] = vt1709_capture_mixer; 2827 spec->num_mixers++; 2828 } 2829 2830 codec->patch_ops = via_patch_ops; 2831 2832 codec->patch_ops.init = via_auto_init; 2833 codec->patch_ops.unsol_event = via_unsol_event; 2834 #ifdef CONFIG_SND_HDA_POWER_SAVE 2835 spec->loopback.amplist = vt1709_loopbacks; 2836 #endif 2837 return 0; 2838 } 2839 2840 /* capture mixer elements */ 2841 static const struct snd_kcontrol_new vt1708B_capture_mixer[] = { 2842 HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT), 2843 HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT), 2844 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT), 2845 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT), 2846 { 2847 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2848 /* The multiple "Capture Source" controls confuse alsamixer 2849 * So call somewhat different.. 2850 */ 2851 /* .name = "Capture Source", */ 2852 .name = "Input Source", 2853 .count = 1, 2854 .info = via_mux_enum_info, 2855 .get = via_mux_enum_get, 2856 .put = via_mux_enum_put, 2857 }, 2858 { } /* end */ 2859 }; 2860 /* 2861 * generic initialization of ADC, input mixers and output mixers 2862 */ 2863 static const struct hda_verb vt1708B_8ch_volume_init_verbs[] = { 2864 /* 2865 * Unmute ADC0-1 and set the default input to mic-in 2866 */ 2867 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2868 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2869 2870 2871 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 2872 * mixer widget 2873 */ 2874 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ 2875 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2876 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2877 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 2878 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 2879 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 2880 2881 /* 2882 * Set up output mixers 2883 */ 2884 /* set vol=0 to output mixers */ 2885 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2886 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2887 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2888 2889 /* Setup default input to PW4 */ 2890 {0x1d, AC_VERB_SET_CONNECT_SEL, 0}, 2891 /* PW9 Output enable */ 2892 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 2893 /* PW10 Input enable */ 2894 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 2895 { } 2896 }; 2897 2898 static const struct hda_verb vt1708B_4ch_volume_init_verbs[] = { 2899 /* 2900 * Unmute ADC0-1 and set the default input to mic-in 2901 */ 2902 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2903 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2904 2905 2906 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 2907 * mixer widget 2908 */ 2909 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ 2910 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2911 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 2912 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 2913 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 2914 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 2915 2916 /* 2917 * Set up output mixers 2918 */ 2919 /* set vol=0 to output mixers */ 2920 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2921 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2922 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2923 2924 /* Setup default input of PW4 to MW0 */ 2925 {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0}, 2926 /* PW9 Output enable */ 2927 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 2928 /* PW10 Input enable */ 2929 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, 2930 { } 2931 }; 2932 2933 static const struct hda_verb vt1708B_uniwill_init_verbs[] = { 2934 {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE, 2935 AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT}, 2936 {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 2937 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 2938 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 2939 {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 2940 {0x1e, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 2941 {0x22, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 2942 {0x23, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 2943 { } 2944 }; 2945 2946 static int via_pcm_open_close(struct hda_pcm_stream *hinfo, 2947 struct hda_codec *codec, 2948 struct snd_pcm_substream *substream) 2949 { 2950 int idle = substream->pstr->substream_opened == 1 2951 && substream->ref_count == 0; 2952 2953 analog_low_current_mode(codec, idle); 2954 return 0; 2955 } 2956 2957 static const struct hda_pcm_stream vt1708B_8ch_pcm_analog_playback = { 2958 .substreams = 2, 2959 .channels_min = 2, 2960 .channels_max = 8, 2961 .nid = 0x10, /* NID to query formats and rates */ 2962 .ops = { 2963 .open = via_playback_pcm_open, 2964 .prepare = via_playback_multi_pcm_prepare, 2965 .cleanup = via_playback_multi_pcm_cleanup, 2966 .close = via_pcm_open_close 2967 }, 2968 }; 2969 2970 static const struct hda_pcm_stream vt1708B_4ch_pcm_analog_playback = { 2971 .substreams = 2, 2972 .channels_min = 2, 2973 .channels_max = 4, 2974 .nid = 0x10, /* NID to query formats and rates */ 2975 .ops = { 2976 .open = via_playback_pcm_open, 2977 .prepare = via_playback_multi_pcm_prepare, 2978 .cleanup = via_playback_multi_pcm_cleanup 2979 }, 2980 }; 2981 2982 static const struct hda_pcm_stream vt1708B_pcm_analog_capture = { 2983 .substreams = 2, 2984 .channels_min = 2, 2985 .channels_max = 2, 2986 .nid = 0x13, /* NID to query formats and rates */ 2987 .ops = { 2988 .open = via_pcm_open_close, 2989 .prepare = via_capture_pcm_prepare, 2990 .cleanup = via_capture_pcm_cleanup, 2991 .close = via_pcm_open_close 2992 }, 2993 }; 2994 2995 static const struct hda_pcm_stream vt1708B_pcm_digital_playback = { 2996 .substreams = 1, 2997 .channels_min = 2, 2998 .channels_max = 2, 2999 /* NID is set in via_build_pcms */ 3000 .ops = { 3001 .open = via_dig_playback_pcm_open, 3002 .close = via_dig_playback_pcm_close, 3003 .prepare = via_dig_playback_pcm_prepare, 3004 .cleanup = via_dig_playback_pcm_cleanup 3005 }, 3006 }; 3007 3008 static const struct hda_pcm_stream vt1708B_pcm_digital_capture = { 3009 .substreams = 1, 3010 .channels_min = 2, 3011 .channels_max = 2, 3012 }; 3013 3014 /* fill in the dac_nids table from the parsed pin configuration */ 3015 static int vt1708B_auto_fill_dac_nids(struct via_spec *spec, 3016 const struct auto_pin_cfg *cfg) 3017 { 3018 int i; 3019 hda_nid_t nid; 3020 3021 spec->multiout.num_dacs = cfg->line_outs; 3022 3023 spec->multiout.dac_nids = spec->private_dac_nids; 3024 3025 for (i = 0; i < 4; i++) { 3026 nid = cfg->line_out_pins[i]; 3027 if (nid) { 3028 /* config dac list */ 3029 switch (i) { 3030 case AUTO_SEQ_FRONT: 3031 spec->private_dac_nids[i] = 0x10; 3032 break; 3033 case AUTO_SEQ_CENLFE: 3034 spec->private_dac_nids[i] = 0x24; 3035 break; 3036 case AUTO_SEQ_SURROUND: 3037 spec->private_dac_nids[i] = 0x11; 3038 break; 3039 case AUTO_SEQ_SIDE: 3040 spec->private_dac_nids[i] = 0x25; 3041 break; 3042 } 3043 } 3044 } 3045 3046 return 0; 3047 } 3048 3049 /* add playback controls from the parsed DAC table */ 3050 static int vt1708B_auto_create_multi_out_ctls(struct via_spec *spec, 3051 const struct auto_pin_cfg *cfg) 3052 { 3053 char name[32]; 3054 static const char * const chname[4] = { 3055 "Front", "Surround", "C/LFE", "Side" 3056 }; 3057 hda_nid_t nid_vols[] = {0x16, 0x18, 0x26, 0x27}; 3058 hda_nid_t nid, nid_vol = 0; 3059 int i, err; 3060 3061 for (i = 0; i <= AUTO_SEQ_SIDE; i++) { 3062 nid = cfg->line_out_pins[i]; 3063 3064 if (!nid) 3065 continue; 3066 3067 nid_vol = nid_vols[i]; 3068 3069 if (i == AUTO_SEQ_CENLFE) { 3070 /* Center/LFE */ 3071 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 3072 "Center Playback Volume", 3073 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, 3074 HDA_OUTPUT)); 3075 if (err < 0) 3076 return err; 3077 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 3078 "LFE Playback Volume", 3079 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, 3080 HDA_OUTPUT)); 3081 if (err < 0) 3082 return err; 3083 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 3084 "Center Playback Switch", 3085 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, 3086 HDA_OUTPUT)); 3087 if (err < 0) 3088 return err; 3089 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 3090 "LFE Playback Switch", 3091 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, 3092 HDA_OUTPUT)); 3093 if (err < 0) 3094 return err; 3095 } else if (i == AUTO_SEQ_FRONT) { 3096 /* add control to mixer index 0 */ 3097 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 3098 "Master Front Playback Volume", 3099 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 3100 HDA_INPUT)); 3101 if (err < 0) 3102 return err; 3103 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 3104 "Master Front Playback Switch", 3105 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 3106 HDA_INPUT)); 3107 if (err < 0) 3108 return err; 3109 3110 /* add control to PW3 */ 3111 sprintf(name, "%s Playback Volume", chname[i]); 3112 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 3113 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 3114 HDA_OUTPUT)); 3115 if (err < 0) 3116 return err; 3117 sprintf(name, "%s Playback Switch", chname[i]); 3118 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 3119 HDA_COMPOSE_AMP_VAL(nid, 3, 0, 3120 HDA_OUTPUT)); 3121 if (err < 0) 3122 return err; 3123 } else { 3124 sprintf(name, "%s Playback Volume", chname[i]); 3125 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 3126 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 3127 HDA_OUTPUT)); 3128 if (err < 0) 3129 return err; 3130 sprintf(name, "%s Playback Switch", chname[i]); 3131 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 3132 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 3133 HDA_OUTPUT)); 3134 if (err < 0) 3135 return err; 3136 } 3137 } 3138 3139 return 0; 3140 } 3141 3142 static int vt1708B_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) 3143 { 3144 int err; 3145 3146 if (!pin) 3147 return 0; 3148 3149 spec->multiout.hp_nid = VT1708B_HP_NID; /* AOW3 */ 3150 spec->hp_independent_mode_index = 1; 3151 3152 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 3153 "Headphone Playback Volume", 3154 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 3155 if (err < 0) 3156 return err; 3157 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 3158 "Headphone Playback Switch", 3159 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 3160 if (err < 0) 3161 return err; 3162 3163 create_hp_imux(spec); 3164 3165 return 0; 3166 } 3167 3168 /* create playback/capture controls for input pins */ 3169 static int vt1708B_auto_create_analog_input_ctls(struct hda_codec *codec, 3170 const struct auto_pin_cfg *cfg) 3171 { 3172 static const hda_nid_t pin_idxs[] = { 0xff, 0x1f, 0x1a, 0x1b, 0x1e }; 3173 return vt_auto_create_analog_input_ctls(codec, cfg, 0x16, pin_idxs, 3174 ARRAY_SIZE(pin_idxs)); 3175 } 3176 3177 static int vt1708B_parse_auto_config(struct hda_codec *codec) 3178 { 3179 struct via_spec *spec = codec->spec; 3180 int err; 3181 3182 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); 3183 if (err < 0) 3184 return err; 3185 err = vt1708B_auto_fill_dac_nids(spec, &spec->autocfg); 3186 if (err < 0) 3187 return err; 3188 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) 3189 return 0; /* can't find valid BIOS pin config */ 3190 3191 err = vt1708B_auto_create_multi_out_ctls(spec, &spec->autocfg); 3192 if (err < 0) 3193 return err; 3194 err = vt1708B_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); 3195 if (err < 0) 3196 return err; 3197 err = vt1708B_auto_create_analog_input_ctls(codec, &spec->autocfg); 3198 if (err < 0) 3199 return err; 3200 3201 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 3202 3203 if (spec->autocfg.dig_outs) 3204 spec->multiout.dig_out_nid = VT1708B_DIGOUT_NID; 3205 spec->dig_in_pin = VT1708B_DIGIN_PIN; 3206 if (spec->autocfg.dig_in_pin) 3207 spec->dig_in_nid = VT1708B_DIGIN_NID; 3208 3209 if (spec->kctls.list) 3210 spec->mixers[spec->num_mixers++] = spec->kctls.list; 3211 3212 spec->input_mux = &spec->private_imux[0]; 3213 3214 if (spec->hp_mux) 3215 via_hp_build(codec); 3216 3217 via_smart51_build(spec); 3218 return 1; 3219 } 3220 3221 #ifdef CONFIG_SND_HDA_POWER_SAVE 3222 static const struct hda_amp_list vt1708B_loopbacks[] = { 3223 { 0x16, HDA_INPUT, 1 }, 3224 { 0x16, HDA_INPUT, 2 }, 3225 { 0x16, HDA_INPUT, 3 }, 3226 { 0x16, HDA_INPUT, 4 }, 3227 { } /* end */ 3228 }; 3229 #endif 3230 3231 static void set_widgets_power_state_vt1708B(struct hda_codec *codec) 3232 { 3233 struct via_spec *spec = codec->spec; 3234 int imux_is_smixer; 3235 unsigned int parm; 3236 int is_8ch = 0; 3237 if ((spec->codec_type != VT1708B_4CH) && 3238 (codec->vendor_id != 0x11064397)) 3239 is_8ch = 1; 3240 3241 /* SW0 (17h) = stereo mixer */ 3242 imux_is_smixer = 3243 (snd_hda_codec_read(codec, 0x17, 0, AC_VERB_GET_CONNECT_SEL, 0x00) 3244 == ((spec->codec_type == VT1708S) ? 5 : 0)); 3245 /* inputs */ 3246 /* PW 1/2/5 (1ah/1bh/1eh) */ 3247 parm = AC_PWRST_D3; 3248 set_pin_power_state(codec, 0x1a, &parm); 3249 set_pin_power_state(codec, 0x1b, &parm); 3250 set_pin_power_state(codec, 0x1e, &parm); 3251 if (imux_is_smixer) 3252 parm = AC_PWRST_D0; 3253 /* SW0 (17h), AIW 0/1 (13h/14h) */ 3254 snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_POWER_STATE, parm); 3255 snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, parm); 3256 snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_POWER_STATE, parm); 3257 3258 /* outputs */ 3259 /* PW0 (19h), SW1 (18h), AOW1 (11h) */ 3260 parm = AC_PWRST_D3; 3261 set_pin_power_state(codec, 0x19, &parm); 3262 if (spec->smart51_enabled) 3263 set_pin_power_state(codec, 0x1b, &parm); 3264 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, parm); 3265 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm); 3266 3267 /* PW6 (22h), SW2 (26h), AOW2 (24h) */ 3268 if (is_8ch) { 3269 parm = AC_PWRST_D3; 3270 set_pin_power_state(codec, 0x22, &parm); 3271 if (spec->smart51_enabled) 3272 set_pin_power_state(codec, 0x1a, &parm); 3273 snd_hda_codec_write(codec, 0x26, 0, 3274 AC_VERB_SET_POWER_STATE, parm); 3275 snd_hda_codec_write(codec, 0x24, 0, 3276 AC_VERB_SET_POWER_STATE, parm); 3277 } else if (codec->vendor_id == 0x11064397) { 3278 /* PW7(23h), SW2(27h), AOW2(25h) */ 3279 parm = AC_PWRST_D3; 3280 set_pin_power_state(codec, 0x23, &parm); 3281 if (spec->smart51_enabled) 3282 set_pin_power_state(codec, 0x1a, &parm); 3283 snd_hda_codec_write(codec, 0x27, 0, 3284 AC_VERB_SET_POWER_STATE, parm); 3285 snd_hda_codec_write(codec, 0x25, 0, 3286 AC_VERB_SET_POWER_STATE, parm); 3287 } 3288 3289 /* PW 3/4/7 (1ch/1dh/23h) */ 3290 parm = AC_PWRST_D3; 3291 /* force to D0 for internal Speaker */ 3292 set_pin_power_state(codec, 0x1c, &parm); 3293 set_pin_power_state(codec, 0x1d, &parm); 3294 if (is_8ch) 3295 set_pin_power_state(codec, 0x23, &parm); 3296 3297 /* MW0 (16h), Sw3 (27h), AOW 0/3 (10h/25h) */ 3298 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_POWER_STATE, 3299 imux_is_smixer ? AC_PWRST_D0 : parm); 3300 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm); 3301 if (is_8ch) { 3302 snd_hda_codec_write(codec, 0x25, 0, 3303 AC_VERB_SET_POWER_STATE, parm); 3304 snd_hda_codec_write(codec, 0x27, 0, 3305 AC_VERB_SET_POWER_STATE, parm); 3306 } else if (codec->vendor_id == 0x11064397 && spec->hp_independent_mode) 3307 snd_hda_codec_write(codec, 0x25, 0, 3308 AC_VERB_SET_POWER_STATE, parm); 3309 } 3310 3311 static int patch_vt1708S(struct hda_codec *codec); 3312 static int patch_vt1708B_8ch(struct hda_codec *codec) 3313 { 3314 struct via_spec *spec; 3315 int err; 3316 3317 if (get_codec_type(codec) == VT1708BCE) 3318 return patch_vt1708S(codec); 3319 /* create a codec specific record */ 3320 spec = via_new_spec(codec); 3321 if (spec == NULL) 3322 return -ENOMEM; 3323 3324 /* automatic parse from the BIOS config */ 3325 err = vt1708B_parse_auto_config(codec); 3326 if (err < 0) { 3327 via_free(codec); 3328 return err; 3329 } else if (!err) { 3330 printk(KERN_INFO "hda_codec: Cannot set up configuration " 3331 "from BIOS. Using genenic mode...\n"); 3332 } 3333 3334 spec->init_verbs[spec->num_iverbs++] = vt1708B_8ch_volume_init_verbs; 3335 spec->init_verbs[spec->num_iverbs++] = vt1708B_uniwill_init_verbs; 3336 3337 spec->stream_name_analog = "VT1708B Analog"; 3338 spec->stream_analog_playback = &vt1708B_8ch_pcm_analog_playback; 3339 spec->stream_analog_capture = &vt1708B_pcm_analog_capture; 3340 3341 spec->stream_name_digital = "VT1708B Digital"; 3342 spec->stream_digital_playback = &vt1708B_pcm_digital_playback; 3343 spec->stream_digital_capture = &vt1708B_pcm_digital_capture; 3344 3345 if (!spec->adc_nids && spec->input_mux) { 3346 spec->adc_nids = vt1708B_adc_nids; 3347 spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids); 3348 get_mux_nids(codec); 3349 spec->mixers[spec->num_mixers] = vt1708B_capture_mixer; 3350 spec->num_mixers++; 3351 } 3352 3353 codec->patch_ops = via_patch_ops; 3354 3355 codec->patch_ops.init = via_auto_init; 3356 codec->patch_ops.unsol_event = via_unsol_event; 3357 #ifdef CONFIG_SND_HDA_POWER_SAVE 3358 spec->loopback.amplist = vt1708B_loopbacks; 3359 #endif 3360 3361 spec->set_widgets_power_state = set_widgets_power_state_vt1708B; 3362 3363 return 0; 3364 } 3365 3366 static int patch_vt1708B_4ch(struct hda_codec *codec) 3367 { 3368 struct via_spec *spec; 3369 int err; 3370 3371 /* create a codec specific record */ 3372 spec = via_new_spec(codec); 3373 if (spec == NULL) 3374 return -ENOMEM; 3375 3376 /* automatic parse from the BIOS config */ 3377 err = vt1708B_parse_auto_config(codec); 3378 if (err < 0) { 3379 via_free(codec); 3380 return err; 3381 } else if (!err) { 3382 printk(KERN_INFO "hda_codec: Cannot set up configuration " 3383 "from BIOS. Using genenic mode...\n"); 3384 } 3385 3386 spec->init_verbs[spec->num_iverbs++] = vt1708B_4ch_volume_init_verbs; 3387 spec->init_verbs[spec->num_iverbs++] = vt1708B_uniwill_init_verbs; 3388 3389 spec->stream_name_analog = "VT1708B Analog"; 3390 spec->stream_analog_playback = &vt1708B_4ch_pcm_analog_playback; 3391 spec->stream_analog_capture = &vt1708B_pcm_analog_capture; 3392 3393 spec->stream_name_digital = "VT1708B Digital"; 3394 spec->stream_digital_playback = &vt1708B_pcm_digital_playback; 3395 spec->stream_digital_capture = &vt1708B_pcm_digital_capture; 3396 3397 if (!spec->adc_nids && spec->input_mux) { 3398 spec->adc_nids = vt1708B_adc_nids; 3399 spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids); 3400 get_mux_nids(codec); 3401 spec->mixers[spec->num_mixers] = vt1708B_capture_mixer; 3402 spec->num_mixers++; 3403 } 3404 3405 codec->patch_ops = via_patch_ops; 3406 3407 codec->patch_ops.init = via_auto_init; 3408 codec->patch_ops.unsol_event = via_unsol_event; 3409 #ifdef CONFIG_SND_HDA_POWER_SAVE 3410 spec->loopback.amplist = vt1708B_loopbacks; 3411 #endif 3412 3413 spec->set_widgets_power_state = set_widgets_power_state_vt1708B; 3414 3415 return 0; 3416 } 3417 3418 /* Patch for VT1708S */ 3419 3420 /* capture mixer elements */ 3421 static const struct snd_kcontrol_new vt1708S_capture_mixer[] = { 3422 HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT), 3423 HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT), 3424 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT), 3425 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT), 3426 HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x1A, 0x0, HDA_INPUT), 3427 HDA_CODEC_VOLUME("Front Mic Boost Capture Volume", 0x1E, 0x0, 3428 HDA_INPUT), 3429 { 3430 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3431 /* The multiple "Capture Source" controls confuse alsamixer 3432 * So call somewhat different.. 3433 */ 3434 /* .name = "Capture Source", */ 3435 .name = "Input Source", 3436 .count = 1, 3437 .info = via_mux_enum_info, 3438 .get = via_mux_enum_get, 3439 .put = via_mux_enum_put, 3440 }, 3441 { } /* end */ 3442 }; 3443 3444 static const struct hda_verb vt1708S_volume_init_verbs[] = { 3445 /* Unmute ADC0-1 and set the default input to mic-in */ 3446 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3447 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3448 3449 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the 3450 * analog-loopback mixer widget */ 3451 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ 3452 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3453 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3454 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 3455 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 3456 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, 3457 3458 /* Setup default input of PW4 to MW0 */ 3459 {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0}, 3460 /* PW9, PW10 Output enable */ 3461 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 3462 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 3463 /* Enable Mic Boost Volume backdoor */ 3464 {0x1, 0xf98, 0x1}, 3465 /* don't bybass mixer */ 3466 {0x1, 0xf88, 0xc0}, 3467 { } 3468 }; 3469 3470 static const struct hda_verb vt1708S_uniwill_init_verbs[] = { 3471 {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE, 3472 AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT}, 3473 {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 3474 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 3475 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 3476 {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 3477 {0x1e, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 3478 {0x22, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 3479 {0x23, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 3480 { } 3481 }; 3482 3483 static const struct hda_verb vt1705_uniwill_init_verbs[] = { 3484 {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE, 3485 AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT}, 3486 {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 3487 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 3488 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 3489 {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 3490 {0x1e, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 3491 {0x23, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 3492 { } 3493 }; 3494 3495 static const struct hda_pcm_stream vt1708S_pcm_analog_playback = { 3496 .substreams = 2, 3497 .channels_min = 2, 3498 .channels_max = 8, 3499 .nid = 0x10, /* NID to query formats and rates */ 3500 .ops = { 3501 .open = via_playback_pcm_open, 3502 .prepare = via_playback_multi_pcm_prepare, 3503 .cleanup = via_playback_multi_pcm_cleanup, 3504 .close = via_pcm_open_close 3505 }, 3506 }; 3507 3508 static const struct hda_pcm_stream vt1705_pcm_analog_playback = { 3509 .substreams = 2, 3510 .channels_min = 2, 3511 .channels_max = 6, 3512 .nid = 0x10, /* NID to query formats and rates */ 3513 .ops = { 3514 .open = via_playback_pcm_open, 3515 .prepare = via_playback_multi_pcm_prepare, 3516 .cleanup = via_playback_multi_pcm_cleanup, 3517 .close = via_pcm_open_close 3518 }, 3519 }; 3520 3521 static const struct hda_pcm_stream vt1708S_pcm_analog_capture = { 3522 .substreams = 2, 3523 .channels_min = 2, 3524 .channels_max = 2, 3525 .nid = 0x13, /* NID to query formats and rates */ 3526 .ops = { 3527 .open = via_pcm_open_close, 3528 .prepare = via_capture_pcm_prepare, 3529 .cleanup = via_capture_pcm_cleanup, 3530 .close = via_pcm_open_close 3531 }, 3532 }; 3533 3534 static const struct hda_pcm_stream vt1708S_pcm_digital_playback = { 3535 .substreams = 1, 3536 .channels_min = 2, 3537 .channels_max = 2, 3538 /* NID is set in via_build_pcms */ 3539 .ops = { 3540 .open = via_dig_playback_pcm_open, 3541 .close = via_dig_playback_pcm_close, 3542 .prepare = via_dig_playback_pcm_prepare, 3543 .cleanup = via_dig_playback_pcm_cleanup 3544 }, 3545 }; 3546 3547 /* fill in the dac_nids table from the parsed pin configuration */ 3548 static int vt1708S_auto_fill_dac_nids(struct via_spec *spec, 3549 const struct auto_pin_cfg *cfg) 3550 { 3551 int i; 3552 hda_nid_t nid; 3553 3554 spec->multiout.num_dacs = cfg->line_outs; 3555 3556 spec->multiout.dac_nids = spec->private_dac_nids; 3557 3558 for (i = 0; i < 4; i++) { 3559 nid = cfg->line_out_pins[i]; 3560 if (nid) { 3561 /* config dac list */ 3562 switch (i) { 3563 case AUTO_SEQ_FRONT: 3564 spec->private_dac_nids[i] = 0x10; 3565 break; 3566 case AUTO_SEQ_CENLFE: 3567 if (spec->codec->vendor_id == 0x11064397) 3568 spec->private_dac_nids[i] = 0x25; 3569 else 3570 spec->private_dac_nids[i] = 0x24; 3571 break; 3572 case AUTO_SEQ_SURROUND: 3573 spec->private_dac_nids[i] = 0x11; 3574 break; 3575 case AUTO_SEQ_SIDE: 3576 spec->private_dac_nids[i] = 0x25; 3577 break; 3578 } 3579 } 3580 } 3581 3582 /* for Smart 5.1, line/mic inputs double as output pins */ 3583 if (cfg->line_outs == 1) { 3584 spec->multiout.num_dacs = 3; 3585 spec->private_dac_nids[AUTO_SEQ_SURROUND] = 0x11; 3586 if (spec->codec->vendor_id == 0x11064397) 3587 spec->private_dac_nids[AUTO_SEQ_CENLFE] = 0x25; 3588 else 3589 spec->private_dac_nids[AUTO_SEQ_CENLFE] = 0x24; 3590 } 3591 3592 return 0; 3593 } 3594 3595 /* add playback controls from the parsed DAC table */ 3596 static int vt1708S_auto_create_multi_out_ctls(struct hda_codec *codec, 3597 const struct auto_pin_cfg *cfg) 3598 { 3599 struct via_spec *spec = codec->spec; 3600 char name[32]; 3601 static const char * const chname[4] = { 3602 "Front", "Surround", "C/LFE", "Side" 3603 }; 3604 hda_nid_t nid_vols[2][4] = { {0x10, 0x11, 0x24, 0x25}, 3605 {0x10, 0x11, 0x25, 0} }; 3606 hda_nid_t nid_mutes[2][4] = { {0x1C, 0x18, 0x26, 0x27}, 3607 {0x1C, 0x18, 0x27, 0} }; 3608 hda_nid_t nid, nid_vol, nid_mute; 3609 int i, err; 3610 3611 for (i = 0; i <= AUTO_SEQ_SIDE; i++) { 3612 nid = cfg->line_out_pins[i]; 3613 3614 /* for Smart 5.1, there are always at least six channels */ 3615 if (!nid && i > AUTO_SEQ_CENLFE) 3616 continue; 3617 3618 if (codec->vendor_id == 0x11064397) { 3619 nid_vol = nid_vols[1][i]; 3620 nid_mute = nid_mutes[1][i]; 3621 } else { 3622 nid_vol = nid_vols[0][i]; 3623 nid_mute = nid_mutes[0][i]; 3624 } 3625 if (!nid_vol && !nid_mute) 3626 continue; 3627 3628 if (i == AUTO_SEQ_CENLFE) { 3629 /* Center/LFE */ 3630 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 3631 "Center Playback Volume", 3632 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, 3633 HDA_OUTPUT)); 3634 if (err < 0) 3635 return err; 3636 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 3637 "LFE Playback Volume", 3638 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, 3639 HDA_OUTPUT)); 3640 if (err < 0) 3641 return err; 3642 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 3643 "Center Playback Switch", 3644 HDA_COMPOSE_AMP_VAL(nid_mute, 3645 1, 0, 3646 HDA_OUTPUT)); 3647 if (err < 0) 3648 return err; 3649 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 3650 "LFE Playback Switch", 3651 HDA_COMPOSE_AMP_VAL(nid_mute, 3652 2, 0, 3653 HDA_OUTPUT)); 3654 if (err < 0) 3655 return err; 3656 } else if (i == AUTO_SEQ_FRONT) { 3657 /* add control to mixer index 0 */ 3658 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 3659 "Master Front Playback Volume", 3660 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, 3661 HDA_INPUT)); 3662 if (err < 0) 3663 return err; 3664 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 3665 "Master Front Playback Switch", 3666 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, 3667 HDA_INPUT)); 3668 if (err < 0) 3669 return err; 3670 3671 /* Front */ 3672 sprintf(name, "%s Playback Volume", chname[i]); 3673 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 3674 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 3675 HDA_OUTPUT)); 3676 if (err < 0) 3677 return err; 3678 sprintf(name, "%s Playback Switch", chname[i]); 3679 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 3680 HDA_COMPOSE_AMP_VAL(nid_mute, 3681 3, 0, 3682 HDA_OUTPUT)); 3683 if (err < 0) 3684 return err; 3685 } else { 3686 sprintf(name, "%s Playback Volume", chname[i]); 3687 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 3688 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, 3689 HDA_OUTPUT)); 3690 if (err < 0) 3691 return err; 3692 sprintf(name, "%s Playback Switch", chname[i]); 3693 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 3694 HDA_COMPOSE_AMP_VAL(nid_mute, 3695 3, 0, 3696 HDA_OUTPUT)); 3697 if (err < 0) 3698 return err; 3699 } 3700 } 3701 3702 return 0; 3703 } 3704 3705 static int vt1708S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) 3706 { 3707 int err; 3708 3709 if (!pin) 3710 return 0; 3711 3712 spec->multiout.hp_nid = VT1708S_HP_NID; /* AOW3 */ 3713 spec->hp_independent_mode_index = 1; 3714 3715 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 3716 "Headphone Playback Volume", 3717 HDA_COMPOSE_AMP_VAL(0x25, 3, 0, HDA_OUTPUT)); 3718 if (err < 0) 3719 return err; 3720 3721 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 3722 "Headphone Playback Switch", 3723 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 3724 if (err < 0) 3725 return err; 3726 3727 create_hp_imux(spec); 3728 3729 return 0; 3730 } 3731 3732 /* create playback/capture controls for input pins */ 3733 static int vt1708S_auto_create_analog_input_ctls(struct hda_codec *codec, 3734 const struct auto_pin_cfg *cfg) 3735 { 3736 static const hda_nid_t pin_idxs[] = { 0x1f, 0x1a, 0x1b, 0x1e, 0, 0xff }; 3737 return vt_auto_create_analog_input_ctls(codec, cfg, 0x16, pin_idxs, 3738 ARRAY_SIZE(pin_idxs)); 3739 } 3740 3741 /* fill out digital output widgets; one for master and one for slave outputs */ 3742 static void fill_dig_outs(struct hda_codec *codec) 3743 { 3744 struct via_spec *spec = codec->spec; 3745 int i; 3746 3747 for (i = 0; i < spec->autocfg.dig_outs; i++) { 3748 hda_nid_t nid; 3749 int conn; 3750 3751 nid = spec->autocfg.dig_out_pins[i]; 3752 if (!nid) 3753 continue; 3754 conn = snd_hda_get_connections(codec, nid, &nid, 1); 3755 if (conn < 1) 3756 continue; 3757 if (!spec->multiout.dig_out_nid) 3758 spec->multiout.dig_out_nid = nid; 3759 else { 3760 spec->slave_dig_outs[0] = nid; 3761 break; /* at most two dig outs */ 3762 } 3763 } 3764 } 3765 3766 static int vt1708S_parse_auto_config(struct hda_codec *codec) 3767 { 3768 struct via_spec *spec = codec->spec; 3769 int err; 3770 3771 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); 3772 if (err < 0) 3773 return err; 3774 err = vt1708S_auto_fill_dac_nids(spec, &spec->autocfg); 3775 if (err < 0) 3776 return err; 3777 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) 3778 return 0; /* can't find valid BIOS pin config */ 3779 3780 err = vt1708S_auto_create_multi_out_ctls(codec, &spec->autocfg); 3781 if (err < 0) 3782 return err; 3783 err = vt1708S_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); 3784 if (err < 0) 3785 return err; 3786 err = vt1708S_auto_create_analog_input_ctls(codec, &spec->autocfg); 3787 if (err < 0) 3788 return err; 3789 3790 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 3791 3792 fill_dig_outs(codec); 3793 3794 if (spec->kctls.list) 3795 spec->mixers[spec->num_mixers++] = spec->kctls.list; 3796 3797 spec->input_mux = &spec->private_imux[0]; 3798 3799 if (spec->hp_mux) 3800 via_hp_build(codec); 3801 3802 via_smart51_build(spec); 3803 return 1; 3804 } 3805 3806 #ifdef CONFIG_SND_HDA_POWER_SAVE 3807 static const struct hda_amp_list vt1708S_loopbacks[] = { 3808 { 0x16, HDA_INPUT, 1 }, 3809 { 0x16, HDA_INPUT, 2 }, 3810 { 0x16, HDA_INPUT, 3 }, 3811 { 0x16, HDA_INPUT, 4 }, 3812 { } /* end */ 3813 }; 3814 #endif 3815 3816 static void override_mic_boost(struct hda_codec *codec, hda_nid_t pin, 3817 int offset, int num_steps, int step_size) 3818 { 3819 snd_hda_override_amp_caps(codec, pin, HDA_INPUT, 3820 (offset << AC_AMPCAP_OFFSET_SHIFT) | 3821 (num_steps << AC_AMPCAP_NUM_STEPS_SHIFT) | 3822 (step_size << AC_AMPCAP_STEP_SIZE_SHIFT) | 3823 (0 << AC_AMPCAP_MUTE_SHIFT)); 3824 } 3825 3826 static int patch_vt1708S(struct hda_codec *codec) 3827 { 3828 struct via_spec *spec; 3829 int err; 3830 3831 /* create a codec specific record */ 3832 spec = via_new_spec(codec); 3833 if (spec == NULL) 3834 return -ENOMEM; 3835 3836 /* automatic parse from the BIOS config */ 3837 err = vt1708S_parse_auto_config(codec); 3838 if (err < 0) { 3839 via_free(codec); 3840 return err; 3841 } else if (!err) { 3842 printk(KERN_INFO "hda_codec: Cannot set up configuration " 3843 "from BIOS. Using genenic mode...\n"); 3844 } 3845 3846 spec->init_verbs[spec->num_iverbs++] = vt1708S_volume_init_verbs; 3847 if (codec->vendor_id == 0x11064397) 3848 spec->init_verbs[spec->num_iverbs++] = 3849 vt1705_uniwill_init_verbs; 3850 else 3851 spec->init_verbs[spec->num_iverbs++] = 3852 vt1708S_uniwill_init_verbs; 3853 3854 if (codec->vendor_id == 0x11060440) 3855 spec->stream_name_analog = "VT1818S Analog"; 3856 else if (codec->vendor_id == 0x11064397) 3857 spec->stream_name_analog = "VT1705 Analog"; 3858 else 3859 spec->stream_name_analog = "VT1708S Analog"; 3860 if (codec->vendor_id == 0x11064397) 3861 spec->stream_analog_playback = &vt1705_pcm_analog_playback; 3862 else 3863 spec->stream_analog_playback = &vt1708S_pcm_analog_playback; 3864 spec->stream_analog_capture = &vt1708S_pcm_analog_capture; 3865 3866 if (codec->vendor_id == 0x11060440) 3867 spec->stream_name_digital = "VT1818S Digital"; 3868 else if (codec->vendor_id == 0x11064397) 3869 spec->stream_name_digital = "VT1705 Digital"; 3870 else 3871 spec->stream_name_digital = "VT1708S Digital"; 3872 spec->stream_digital_playback = &vt1708S_pcm_digital_playback; 3873 3874 if (!spec->adc_nids && spec->input_mux) { 3875 spec->adc_nids = vt1708S_adc_nids; 3876 spec->num_adc_nids = ARRAY_SIZE(vt1708S_adc_nids); 3877 get_mux_nids(codec); 3878 override_mic_boost(codec, 0x1a, 0, 3, 40); 3879 override_mic_boost(codec, 0x1e, 0, 3, 40); 3880 spec->mixers[spec->num_mixers] = vt1708S_capture_mixer; 3881 spec->num_mixers++; 3882 } 3883 3884 codec->patch_ops = via_patch_ops; 3885 3886 codec->patch_ops.init = via_auto_init; 3887 codec->patch_ops.unsol_event = via_unsol_event; 3888 #ifdef CONFIG_SND_HDA_POWER_SAVE 3889 spec->loopback.amplist = vt1708S_loopbacks; 3890 #endif 3891 3892 /* correct names for VT1708BCE */ 3893 if (get_codec_type(codec) == VT1708BCE) { 3894 kfree(codec->chip_name); 3895 codec->chip_name = kstrdup("VT1708BCE", GFP_KERNEL); 3896 snprintf(codec->bus->card->mixername, 3897 sizeof(codec->bus->card->mixername), 3898 "%s %s", codec->vendor_name, codec->chip_name); 3899 spec->stream_name_analog = "VT1708BCE Analog"; 3900 spec->stream_name_digital = "VT1708BCE Digital"; 3901 } 3902 /* correct names for VT1818S */ 3903 if (codec->vendor_id == 0x11060440) { 3904 spec->stream_name_analog = "VT1818S Analog"; 3905 spec->stream_name_digital = "VT1818S Digital"; 3906 } 3907 /* correct names for VT1705 */ 3908 if (codec->vendor_id == 0x11064397) { 3909 kfree(codec->chip_name); 3910 codec->chip_name = kstrdup("VT1705", GFP_KERNEL); 3911 snprintf(codec->bus->card->mixername, 3912 sizeof(codec->bus->card->mixername), 3913 "%s %s", codec->vendor_name, codec->chip_name); 3914 } 3915 spec->set_widgets_power_state = set_widgets_power_state_vt1708B; 3916 return 0; 3917 } 3918 3919 /* Patch for VT1702 */ 3920 3921 /* capture mixer elements */ 3922 static const struct snd_kcontrol_new vt1702_capture_mixer[] = { 3923 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_INPUT), 3924 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_INPUT), 3925 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x20, 0x0, HDA_INPUT), 3926 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x20, 0x0, HDA_INPUT), 3927 HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x1F, 0x0, HDA_INPUT), 3928 HDA_CODEC_MUTE("Digital Mic Capture Switch", 0x1F, 0x0, HDA_INPUT), 3929 HDA_CODEC_VOLUME("Digital Mic Boost Capture Volume", 0x1E, 0x0, 3930 HDA_INPUT), 3931 { 3932 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3933 /* The multiple "Capture Source" controls confuse alsamixer 3934 * So call somewhat different.. 3935 */ 3936 /* .name = "Capture Source", */ 3937 .name = "Input Source", 3938 .count = 1, 3939 .info = via_mux_enum_info, 3940 .get = via_mux_enum_get, 3941 .put = via_mux_enum_put, 3942 }, 3943 { } /* end */ 3944 }; 3945 3946 static const struct hda_verb vt1702_volume_init_verbs[] = { 3947 /* 3948 * Unmute ADC0-1 and set the default input to mic-in 3949 */ 3950 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3951 {0x1F, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3952 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3953 3954 3955 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 3956 * mixer widget 3957 */ 3958 /* Amp Indices: Mic1 = 1, Line = 1, Mic2 = 3 */ 3959 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3960 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3961 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, 3962 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, 3963 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 3964 3965 /* Setup default input of PW4 to MW0 */ 3966 {0x17, AC_VERB_SET_CONNECT_SEL, 0x1}, 3967 /* PW6 PW7 Output enable */ 3968 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 3969 {0x1C, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 3970 /* mixer enable */ 3971 {0x1, 0xF88, 0x3}, 3972 /* GPIO 0~2 */ 3973 {0x1, 0xF82, 0x3F}, 3974 { } 3975 }; 3976 3977 static const struct hda_verb vt1702_uniwill_init_verbs[] = { 3978 {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, 3979 AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT}, 3980 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 3981 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 3982 {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 3983 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 3984 { } 3985 }; 3986 3987 static const struct hda_pcm_stream vt1702_pcm_analog_playback = { 3988 .substreams = 2, 3989 .channels_min = 2, 3990 .channels_max = 2, 3991 .nid = 0x10, /* NID to query formats and rates */ 3992 .ops = { 3993 .open = via_playback_pcm_open, 3994 .prepare = via_playback_multi_pcm_prepare, 3995 .cleanup = via_playback_multi_pcm_cleanup, 3996 .close = via_pcm_open_close 3997 }, 3998 }; 3999 4000 static const struct hda_pcm_stream vt1702_pcm_analog_capture = { 4001 .substreams = 3, 4002 .channels_min = 2, 4003 .channels_max = 2, 4004 .nid = 0x12, /* NID to query formats and rates */ 4005 .ops = { 4006 .open = via_pcm_open_close, 4007 .prepare = via_capture_pcm_prepare, 4008 .cleanup = via_capture_pcm_cleanup, 4009 .close = via_pcm_open_close 4010 }, 4011 }; 4012 4013 static const struct hda_pcm_stream vt1702_pcm_digital_playback = { 4014 .substreams = 2, 4015 .channels_min = 2, 4016 .channels_max = 2, 4017 /* NID is set in via_build_pcms */ 4018 .ops = { 4019 .open = via_dig_playback_pcm_open, 4020 .close = via_dig_playback_pcm_close, 4021 .prepare = via_dig_playback_pcm_prepare, 4022 .cleanup = via_dig_playback_pcm_cleanup 4023 }, 4024 }; 4025 4026 /* fill in the dac_nids table from the parsed pin configuration */ 4027 static int vt1702_auto_fill_dac_nids(struct via_spec *spec, 4028 const struct auto_pin_cfg *cfg) 4029 { 4030 spec->multiout.num_dacs = 1; 4031 spec->multiout.dac_nids = spec->private_dac_nids; 4032 4033 if (cfg->line_out_pins[0]) { 4034 /* config dac list */ 4035 spec->private_dac_nids[0] = 0x10; 4036 } 4037 4038 return 0; 4039 } 4040 4041 /* add playback controls from the parsed DAC table */ 4042 static int vt1702_auto_create_line_out_ctls(struct via_spec *spec, 4043 const struct auto_pin_cfg *cfg) 4044 { 4045 int err; 4046 4047 if (!cfg->line_out_pins[0]) 4048 return -1; 4049 4050 /* add control to mixer index 0 */ 4051 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 4052 "Master Front Playback Volume", 4053 HDA_COMPOSE_AMP_VAL(0x1A, 3, 0, HDA_INPUT)); 4054 if (err < 0) 4055 return err; 4056 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 4057 "Master Front Playback Switch", 4058 HDA_COMPOSE_AMP_VAL(0x1A, 3, 0, HDA_INPUT)); 4059 if (err < 0) 4060 return err; 4061 4062 /* Front */ 4063 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 4064 "Front Playback Volume", 4065 HDA_COMPOSE_AMP_VAL(0x10, 3, 0, HDA_OUTPUT)); 4066 if (err < 0) 4067 return err; 4068 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 4069 "Front Playback Switch", 4070 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT)); 4071 if (err < 0) 4072 return err; 4073 4074 return 0; 4075 } 4076 4077 static int vt1702_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) 4078 { 4079 int err, i; 4080 struct hda_input_mux *imux; 4081 static const char * const texts[] = { "ON", "OFF", NULL}; 4082 if (!pin) 4083 return 0; 4084 spec->multiout.hp_nid = 0x1D; 4085 spec->hp_independent_mode_index = 0; 4086 4087 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 4088 "Headphone Playback Volume", 4089 HDA_COMPOSE_AMP_VAL(0x1D, 3, 0, HDA_OUTPUT)); 4090 if (err < 0) 4091 return err; 4092 4093 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 4094 "Headphone Playback Switch", 4095 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 4096 if (err < 0) 4097 return err; 4098 4099 imux = &spec->private_imux[1]; 4100 4101 /* for hp mode select */ 4102 for (i = 0; texts[i]; i++) 4103 snd_hda_add_imux_item(imux, texts[i], i, NULL); 4104 4105 spec->hp_mux = &spec->private_imux[1]; 4106 return 0; 4107 } 4108 4109 /* create playback/capture controls for input pins */ 4110 static int vt1702_auto_create_analog_input_ctls(struct hda_codec *codec, 4111 const struct auto_pin_cfg *cfg) 4112 { 4113 static const hda_nid_t pin_idxs[] = { 0x14, 0x15, 0x18, 0xff }; 4114 return vt_auto_create_analog_input_ctls(codec, cfg, 0x1a, pin_idxs, 4115 ARRAY_SIZE(pin_idxs)); 4116 } 4117 4118 static int vt1702_parse_auto_config(struct hda_codec *codec) 4119 { 4120 struct via_spec *spec = codec->spec; 4121 int err; 4122 4123 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); 4124 if (err < 0) 4125 return err; 4126 err = vt1702_auto_fill_dac_nids(spec, &spec->autocfg); 4127 if (err < 0) 4128 return err; 4129 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) 4130 return 0; /* can't find valid BIOS pin config */ 4131 4132 err = vt1702_auto_create_line_out_ctls(spec, &spec->autocfg); 4133 if (err < 0) 4134 return err; 4135 err = vt1702_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); 4136 if (err < 0) 4137 return err; 4138 /* limit AA path volume to 0 dB */ 4139 snd_hda_override_amp_caps(codec, 0x1A, HDA_INPUT, 4140 (0x17 << AC_AMPCAP_OFFSET_SHIFT) | 4141 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) | 4142 (0x5 << AC_AMPCAP_STEP_SIZE_SHIFT) | 4143 (1 << AC_AMPCAP_MUTE_SHIFT)); 4144 err = vt1702_auto_create_analog_input_ctls(codec, &spec->autocfg); 4145 if (err < 0) 4146 return err; 4147 4148 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 4149 4150 fill_dig_outs(codec); 4151 4152 if (spec->kctls.list) 4153 spec->mixers[spec->num_mixers++] = spec->kctls.list; 4154 4155 spec->input_mux = &spec->private_imux[0]; 4156 4157 if (spec->hp_mux) 4158 via_hp_build(codec); 4159 4160 return 1; 4161 } 4162 4163 #ifdef CONFIG_SND_HDA_POWER_SAVE 4164 static const struct hda_amp_list vt1702_loopbacks[] = { 4165 { 0x1A, HDA_INPUT, 1 }, 4166 { 0x1A, HDA_INPUT, 2 }, 4167 { 0x1A, HDA_INPUT, 3 }, 4168 { 0x1A, HDA_INPUT, 4 }, 4169 { } /* end */ 4170 }; 4171 #endif 4172 4173 static void set_widgets_power_state_vt1702(struct hda_codec *codec) 4174 { 4175 int imux_is_smixer = 4176 snd_hda_codec_read(codec, 0x13, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3; 4177 unsigned int parm; 4178 /* inputs */ 4179 /* PW 1/2/5 (14h/15h/18h) */ 4180 parm = AC_PWRST_D3; 4181 set_pin_power_state(codec, 0x14, &parm); 4182 set_pin_power_state(codec, 0x15, &parm); 4183 set_pin_power_state(codec, 0x18, &parm); 4184 if (imux_is_smixer) 4185 parm = AC_PWRST_D0; /* SW0 (13h) = stereo mixer (idx 3) */ 4186 /* SW0 (13h), AIW 0/1/2 (12h/1fh/20h) */ 4187 snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, parm); 4188 snd_hda_codec_write(codec, 0x12, 0, AC_VERB_SET_POWER_STATE, parm); 4189 snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm); 4190 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_POWER_STATE, parm); 4191 4192 /* outputs */ 4193 /* PW 3/4 (16h/17h) */ 4194 parm = AC_PWRST_D3; 4195 set_pin_power_state(codec, 0x17, &parm); 4196 set_pin_power_state(codec, 0x16, &parm); 4197 /* MW0 (1ah), AOW 0/1 (10h/1dh) */ 4198 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_POWER_STATE, 4199 imux_is_smixer ? AC_PWRST_D0 : parm); 4200 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm); 4201 snd_hda_codec_write(codec, 0x1d, 0, AC_VERB_SET_POWER_STATE, parm); 4202 } 4203 4204 static int patch_vt1702(struct hda_codec *codec) 4205 { 4206 struct via_spec *spec; 4207 int err; 4208 4209 /* create a codec specific record */ 4210 spec = via_new_spec(codec); 4211 if (spec == NULL) 4212 return -ENOMEM; 4213 4214 /* automatic parse from the BIOS config */ 4215 err = vt1702_parse_auto_config(codec); 4216 if (err < 0) { 4217 via_free(codec); 4218 return err; 4219 } else if (!err) { 4220 printk(KERN_INFO "hda_codec: Cannot set up configuration " 4221 "from BIOS. Using genenic mode...\n"); 4222 } 4223 4224 spec->init_verbs[spec->num_iverbs++] = vt1702_volume_init_verbs; 4225 spec->init_verbs[spec->num_iverbs++] = vt1702_uniwill_init_verbs; 4226 4227 spec->stream_name_analog = "VT1702 Analog"; 4228 spec->stream_analog_playback = &vt1702_pcm_analog_playback; 4229 spec->stream_analog_capture = &vt1702_pcm_analog_capture; 4230 4231 spec->stream_name_digital = "VT1702 Digital"; 4232 spec->stream_digital_playback = &vt1702_pcm_digital_playback; 4233 4234 if (!spec->adc_nids && spec->input_mux) { 4235 spec->adc_nids = vt1702_adc_nids; 4236 spec->num_adc_nids = ARRAY_SIZE(vt1702_adc_nids); 4237 get_mux_nids(codec); 4238 spec->mixers[spec->num_mixers] = vt1702_capture_mixer; 4239 spec->num_mixers++; 4240 } 4241 4242 codec->patch_ops = via_patch_ops; 4243 4244 codec->patch_ops.init = via_auto_init; 4245 codec->patch_ops.unsol_event = via_unsol_event; 4246 #ifdef CONFIG_SND_HDA_POWER_SAVE 4247 spec->loopback.amplist = vt1702_loopbacks; 4248 #endif 4249 4250 spec->set_widgets_power_state = set_widgets_power_state_vt1702; 4251 return 0; 4252 } 4253 4254 /* Patch for VT1718S */ 4255 4256 /* capture mixer elements */ 4257 static const struct snd_kcontrol_new vt1718S_capture_mixer[] = { 4258 HDA_CODEC_VOLUME("Capture Volume", 0x10, 0x0, HDA_INPUT), 4259 HDA_CODEC_MUTE("Capture Switch", 0x10, 0x0, HDA_INPUT), 4260 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x11, 0x0, HDA_INPUT), 4261 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x11, 0x0, HDA_INPUT), 4262 HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x2b, 0x0, HDA_INPUT), 4263 HDA_CODEC_VOLUME("Front Mic Boost Capture Volume", 0x29, 0x0, 4264 HDA_INPUT), 4265 { 4266 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4267 /* The multiple "Capture Source" controls confuse alsamixer 4268 * So call somewhat different.. 4269 */ 4270 .name = "Input Source", 4271 .count = 2, 4272 .info = via_mux_enum_info, 4273 .get = via_mux_enum_get, 4274 .put = via_mux_enum_put, 4275 }, 4276 { } /* end */ 4277 }; 4278 4279 static const struct hda_verb vt1718S_volume_init_verbs[] = { 4280 /* 4281 * Unmute ADC0-1 and set the default input to mic-in 4282 */ 4283 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4284 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4285 4286 /* Enable MW0 adjust Gain 5 */ 4287 {0x1, 0xfb2, 0x10}, 4288 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 4289 * mixer widget 4290 */ 4291 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ 4292 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4293 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4294 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 4295 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 4296 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)}, 4297 /* PW9 PW10 Output enable */ 4298 {0x2d, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN}, 4299 {0x2e, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN}, 4300 /* PW11 Input enable */ 4301 {0x2f, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_IN_EN}, 4302 /* Enable Boost Volume backdoor */ 4303 {0x1, 0xf88, 0x8}, 4304 /* MW0/1/2/3/4: un-mute index 0 (AOWx), mute index 1 (MW9) */ 4305 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4306 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4307 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4308 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4309 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4310 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 4311 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4312 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4313 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 4314 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4315 /* set MUX1 = 2 (AOW4), MUX2 = 1 (AOW3) */ 4316 {0x34, AC_VERB_SET_CONNECT_SEL, 0x2}, 4317 {0x35, AC_VERB_SET_CONNECT_SEL, 0x1}, 4318 { } 4319 }; 4320 4321 4322 static const struct hda_verb vt1718S_uniwill_init_verbs[] = { 4323 {0x28, AC_VERB_SET_UNSOLICITED_ENABLE, 4324 AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT}, 4325 {0x24, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 4326 {0x25, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 4327 {0x26, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 4328 {0x27, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 4329 {0x29, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 4330 {0x2a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 4331 {0x2b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 4332 { } 4333 }; 4334 4335 static const struct hda_pcm_stream vt1718S_pcm_analog_playback = { 4336 .substreams = 2, 4337 .channels_min = 2, 4338 .channels_max = 10, 4339 .nid = 0x8, /* NID to query formats and rates */ 4340 .ops = { 4341 .open = via_playback_pcm_open, 4342 .prepare = via_playback_multi_pcm_prepare, 4343 .cleanup = via_playback_multi_pcm_cleanup, 4344 .close = via_pcm_open_close, 4345 }, 4346 }; 4347 4348 static const struct hda_pcm_stream vt1718S_pcm_analog_capture = { 4349 .substreams = 2, 4350 .channels_min = 2, 4351 .channels_max = 2, 4352 .nid = 0x10, /* NID to query formats and rates */ 4353 .ops = { 4354 .open = via_pcm_open_close, 4355 .prepare = via_capture_pcm_prepare, 4356 .cleanup = via_capture_pcm_cleanup, 4357 .close = via_pcm_open_close, 4358 }, 4359 }; 4360 4361 static const struct hda_pcm_stream vt1718S_pcm_digital_playback = { 4362 .substreams = 2, 4363 .channels_min = 2, 4364 .channels_max = 2, 4365 /* NID is set in via_build_pcms */ 4366 .ops = { 4367 .open = via_dig_playback_pcm_open, 4368 .close = via_dig_playback_pcm_close, 4369 .prepare = via_dig_playback_pcm_prepare, 4370 .cleanup = via_dig_playback_pcm_cleanup 4371 }, 4372 }; 4373 4374 static const struct hda_pcm_stream vt1718S_pcm_digital_capture = { 4375 .substreams = 1, 4376 .channels_min = 2, 4377 .channels_max = 2, 4378 }; 4379 4380 /* fill in the dac_nids table from the parsed pin configuration */ 4381 static int vt1718S_auto_fill_dac_nids(struct via_spec *spec, 4382 const struct auto_pin_cfg *cfg) 4383 { 4384 int i; 4385 hda_nid_t nid; 4386 4387 spec->multiout.num_dacs = cfg->line_outs; 4388 4389 spec->multiout.dac_nids = spec->private_dac_nids; 4390 4391 for (i = 0; i < 4; i++) { 4392 nid = cfg->line_out_pins[i]; 4393 if (nid) { 4394 /* config dac list */ 4395 switch (i) { 4396 case AUTO_SEQ_FRONT: 4397 spec->private_dac_nids[i] = 0x8; 4398 break; 4399 case AUTO_SEQ_CENLFE: 4400 spec->private_dac_nids[i] = 0xa; 4401 break; 4402 case AUTO_SEQ_SURROUND: 4403 spec->private_dac_nids[i] = 0x9; 4404 break; 4405 case AUTO_SEQ_SIDE: 4406 spec->private_dac_nids[i] = 0xb; 4407 break; 4408 } 4409 } 4410 } 4411 4412 return 0; 4413 } 4414 4415 /* add playback controls from the parsed DAC table */ 4416 static int vt1718S_auto_create_multi_out_ctls(struct via_spec *spec, 4417 const struct auto_pin_cfg *cfg) 4418 { 4419 char name[32]; 4420 static const char * const chname[4] = { 4421 "Front", "Surround", "C/LFE", "Side" 4422 }; 4423 hda_nid_t nid_vols[] = {0x8, 0x9, 0xa, 0xb}; 4424 hda_nid_t nid_mutes[] = {0x24, 0x25, 0x26, 0x27}; 4425 hda_nid_t nid, nid_vol, nid_mute = 0; 4426 int i, err; 4427 4428 for (i = 0; i <= AUTO_SEQ_SIDE; i++) { 4429 nid = cfg->line_out_pins[i]; 4430 4431 if (!nid) 4432 continue; 4433 nid_vol = nid_vols[i]; 4434 nid_mute = nid_mutes[i]; 4435 4436 if (i == AUTO_SEQ_CENLFE) { 4437 /* Center/LFE */ 4438 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 4439 "Center Playback Volume", 4440 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, 4441 HDA_OUTPUT)); 4442 if (err < 0) 4443 return err; 4444 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 4445 "LFE Playback Volume", 4446 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, 4447 HDA_OUTPUT)); 4448 if (err < 0) 4449 return err; 4450 err = via_add_control( 4451 spec, VIA_CTL_WIDGET_MUTE, 4452 "Center Playback Switch", 4453 HDA_COMPOSE_AMP_VAL(nid_mute, 1, 0, 4454 HDA_OUTPUT)); 4455 if (err < 0) 4456 return err; 4457 err = via_add_control( 4458 spec, VIA_CTL_WIDGET_MUTE, 4459 "LFE Playback Switch", 4460 HDA_COMPOSE_AMP_VAL(nid_mute, 2, 0, 4461 HDA_OUTPUT)); 4462 if (err < 0) 4463 return err; 4464 } else if (i == AUTO_SEQ_FRONT) { 4465 /* add control to mixer index 0 */ 4466 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 4467 "Master Front Playback Volume", 4468 HDA_COMPOSE_AMP_VAL(0x21, 3, 5, 4469 HDA_INPUT)); 4470 if (err < 0) 4471 return err; 4472 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 4473 "Master Front Playback Switch", 4474 HDA_COMPOSE_AMP_VAL(0x21, 3, 5, 4475 HDA_INPUT)); 4476 if (err < 0) 4477 return err; 4478 /* Front */ 4479 sprintf(name, "%s Playback Volume", chname[i]); 4480 err = via_add_control( 4481 spec, VIA_CTL_WIDGET_VOL, name, 4482 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT)); 4483 if (err < 0) 4484 return err; 4485 sprintf(name, "%s Playback Switch", chname[i]); 4486 err = via_add_control( 4487 spec, VIA_CTL_WIDGET_MUTE, name, 4488 HDA_COMPOSE_AMP_VAL(nid_mute, 3, 0, 4489 HDA_OUTPUT)); 4490 if (err < 0) 4491 return err; 4492 } else { 4493 sprintf(name, "%s Playback Volume", chname[i]); 4494 err = via_add_control( 4495 spec, VIA_CTL_WIDGET_VOL, name, 4496 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT)); 4497 if (err < 0) 4498 return err; 4499 sprintf(name, "%s Playback Switch", chname[i]); 4500 err = via_add_control( 4501 spec, VIA_CTL_WIDGET_MUTE, name, 4502 HDA_COMPOSE_AMP_VAL(nid_mute, 3, 0, 4503 HDA_OUTPUT)); 4504 if (err < 0) 4505 return err; 4506 } 4507 } 4508 return 0; 4509 } 4510 4511 static int vt1718S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) 4512 { 4513 int err; 4514 4515 if (!pin) 4516 return 0; 4517 4518 spec->multiout.hp_nid = 0xc; /* AOW4 */ 4519 spec->hp_independent_mode_index = 1; 4520 4521 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 4522 "Headphone Playback Volume", 4523 HDA_COMPOSE_AMP_VAL(0xc, 3, 0, HDA_OUTPUT)); 4524 if (err < 0) 4525 return err; 4526 4527 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 4528 "Headphone Playback Switch", 4529 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 4530 if (err < 0) 4531 return err; 4532 4533 create_hp_imux(spec); 4534 return 0; 4535 } 4536 4537 /* create playback/capture controls for input pins */ 4538 static int vt1718S_auto_create_analog_input_ctls(struct hda_codec *codec, 4539 const struct auto_pin_cfg *cfg) 4540 { 4541 static const hda_nid_t pin_idxs[] = { 0x2c, 0x2b, 0x2a, 0x29, 0, 0xff }; 4542 return vt_auto_create_analog_input_ctls(codec, cfg, 0x21, pin_idxs, 4543 ARRAY_SIZE(pin_idxs)); 4544 } 4545 4546 static int vt1718S_parse_auto_config(struct hda_codec *codec) 4547 { 4548 struct via_spec *spec = codec->spec; 4549 int err; 4550 4551 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); 4552 4553 if (err < 0) 4554 return err; 4555 err = vt1718S_auto_fill_dac_nids(spec, &spec->autocfg); 4556 if (err < 0) 4557 return err; 4558 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) 4559 return 0; /* can't find valid BIOS pin config */ 4560 4561 err = vt1718S_auto_create_multi_out_ctls(spec, &spec->autocfg); 4562 if (err < 0) 4563 return err; 4564 err = vt1718S_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); 4565 if (err < 0) 4566 return err; 4567 err = vt1718S_auto_create_analog_input_ctls(codec, &spec->autocfg); 4568 if (err < 0) 4569 return err; 4570 4571 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 4572 4573 fill_dig_outs(codec); 4574 4575 if (spec->autocfg.dig_in_pin && codec->vendor_id == 0x11060428) 4576 spec->dig_in_nid = 0x13; 4577 4578 if (spec->kctls.list) 4579 spec->mixers[spec->num_mixers++] = spec->kctls.list; 4580 4581 spec->input_mux = &spec->private_imux[0]; 4582 4583 if (spec->hp_mux) 4584 via_hp_build(codec); 4585 4586 via_smart51_build(spec); 4587 4588 return 1; 4589 } 4590 4591 #ifdef CONFIG_SND_HDA_POWER_SAVE 4592 static const struct hda_amp_list vt1718S_loopbacks[] = { 4593 { 0x21, HDA_INPUT, 1 }, 4594 { 0x21, HDA_INPUT, 2 }, 4595 { 0x21, HDA_INPUT, 3 }, 4596 { 0x21, HDA_INPUT, 4 }, 4597 { } /* end */ 4598 }; 4599 #endif 4600 4601 static void set_widgets_power_state_vt1718S(struct hda_codec *codec) 4602 { 4603 struct via_spec *spec = codec->spec; 4604 int imux_is_smixer; 4605 unsigned int parm; 4606 /* MUX6 (1eh) = stereo mixer */ 4607 imux_is_smixer = 4608 snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 5; 4609 /* inputs */ 4610 /* PW 5/6/7 (29h/2ah/2bh) */ 4611 parm = AC_PWRST_D3; 4612 set_pin_power_state(codec, 0x29, &parm); 4613 set_pin_power_state(codec, 0x2a, &parm); 4614 set_pin_power_state(codec, 0x2b, &parm); 4615 if (imux_is_smixer) 4616 parm = AC_PWRST_D0; 4617 /* MUX6/7 (1eh/1fh), AIW 0/1 (10h/11h) */ 4618 snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE, parm); 4619 snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm); 4620 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm); 4621 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm); 4622 4623 /* outputs */ 4624 /* PW3 (27h), MW2 (1ah), AOW3 (bh) */ 4625 parm = AC_PWRST_D3; 4626 set_pin_power_state(codec, 0x27, &parm); 4627 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_POWER_STATE, parm); 4628 snd_hda_codec_write(codec, 0xb, 0, AC_VERB_SET_POWER_STATE, parm); 4629 4630 /* PW2 (26h), AOW2 (ah) */ 4631 parm = AC_PWRST_D3; 4632 set_pin_power_state(codec, 0x26, &parm); 4633 if (spec->smart51_enabled) 4634 set_pin_power_state(codec, 0x2b, &parm); 4635 snd_hda_codec_write(codec, 0xa, 0, AC_VERB_SET_POWER_STATE, parm); 4636 4637 /* PW0 (24h), AOW0 (8h) */ 4638 parm = AC_PWRST_D3; 4639 set_pin_power_state(codec, 0x24, &parm); 4640 if (!spec->hp_independent_mode) /* check for redirected HP */ 4641 set_pin_power_state(codec, 0x28, &parm); 4642 snd_hda_codec_write(codec, 0x8, 0, AC_VERB_SET_POWER_STATE, parm); 4643 /* MW9 (21h), Mw2 (1ah), AOW0 (8h) */ 4644 snd_hda_codec_write(codec, 0x21, 0, AC_VERB_SET_POWER_STATE, 4645 imux_is_smixer ? AC_PWRST_D0 : parm); 4646 4647 /* PW1 (25h), AOW1 (9h) */ 4648 parm = AC_PWRST_D3; 4649 set_pin_power_state(codec, 0x25, &parm); 4650 if (spec->smart51_enabled) 4651 set_pin_power_state(codec, 0x2a, &parm); 4652 snd_hda_codec_write(codec, 0x9, 0, AC_VERB_SET_POWER_STATE, parm); 4653 4654 if (spec->hp_independent_mode) { 4655 /* PW4 (28h), MW3 (1bh), MUX1(34h), AOW4 (ch) */ 4656 parm = AC_PWRST_D3; 4657 set_pin_power_state(codec, 0x28, &parm); 4658 snd_hda_codec_write(codec, 0x1b, 0, 4659 AC_VERB_SET_POWER_STATE, parm); 4660 snd_hda_codec_write(codec, 0x34, 0, 4661 AC_VERB_SET_POWER_STATE, parm); 4662 snd_hda_codec_write(codec, 0xc, 0, 4663 AC_VERB_SET_POWER_STATE, parm); 4664 } 4665 } 4666 4667 static int patch_vt1718S(struct hda_codec *codec) 4668 { 4669 struct via_spec *spec; 4670 int err; 4671 4672 /* create a codec specific record */ 4673 spec = via_new_spec(codec); 4674 if (spec == NULL) 4675 return -ENOMEM; 4676 4677 /* automatic parse from the BIOS config */ 4678 err = vt1718S_parse_auto_config(codec); 4679 if (err < 0) { 4680 via_free(codec); 4681 return err; 4682 } else if (!err) { 4683 printk(KERN_INFO "hda_codec: Cannot set up configuration " 4684 "from BIOS. Using genenic mode...\n"); 4685 } 4686 4687 spec->init_verbs[spec->num_iverbs++] = vt1718S_volume_init_verbs; 4688 spec->init_verbs[spec->num_iverbs++] = vt1718S_uniwill_init_verbs; 4689 4690 if (codec->vendor_id == 0x11060441) 4691 spec->stream_name_analog = "VT2020 Analog"; 4692 else if (codec->vendor_id == 0x11064441) 4693 spec->stream_name_analog = "VT1828S Analog"; 4694 else 4695 spec->stream_name_analog = "VT1718S Analog"; 4696 spec->stream_analog_playback = &vt1718S_pcm_analog_playback; 4697 spec->stream_analog_capture = &vt1718S_pcm_analog_capture; 4698 4699 if (codec->vendor_id == 0x11060441) 4700 spec->stream_name_digital = "VT2020 Digital"; 4701 else if (codec->vendor_id == 0x11064441) 4702 spec->stream_name_digital = "VT1828S Digital"; 4703 else 4704 spec->stream_name_digital = "VT1718S Digital"; 4705 spec->stream_digital_playback = &vt1718S_pcm_digital_playback; 4706 if (codec->vendor_id == 0x11060428 || codec->vendor_id == 0x11060441) 4707 spec->stream_digital_capture = &vt1718S_pcm_digital_capture; 4708 4709 if (!spec->adc_nids && spec->input_mux) { 4710 spec->adc_nids = vt1718S_adc_nids; 4711 spec->num_adc_nids = ARRAY_SIZE(vt1718S_adc_nids); 4712 get_mux_nids(codec); 4713 override_mic_boost(codec, 0x2b, 0, 3, 40); 4714 override_mic_boost(codec, 0x29, 0, 3, 40); 4715 spec->mixers[spec->num_mixers] = vt1718S_capture_mixer; 4716 spec->num_mixers++; 4717 } 4718 4719 codec->patch_ops = via_patch_ops; 4720 4721 codec->patch_ops.init = via_auto_init; 4722 codec->patch_ops.unsol_event = via_unsol_event; 4723 4724 #ifdef CONFIG_SND_HDA_POWER_SAVE 4725 spec->loopback.amplist = vt1718S_loopbacks; 4726 #endif 4727 4728 spec->set_widgets_power_state = set_widgets_power_state_vt1718S; 4729 4730 return 0; 4731 } 4732 4733 /* Patch for VT1716S */ 4734 4735 static int vt1716s_dmic_info(struct snd_kcontrol *kcontrol, 4736 struct snd_ctl_elem_info *uinfo) 4737 { 4738 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 4739 uinfo->count = 1; 4740 uinfo->value.integer.min = 0; 4741 uinfo->value.integer.max = 1; 4742 return 0; 4743 } 4744 4745 static int vt1716s_dmic_get(struct snd_kcontrol *kcontrol, 4746 struct snd_ctl_elem_value *ucontrol) 4747 { 4748 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 4749 int index = 0; 4750 4751 index = snd_hda_codec_read(codec, 0x26, 0, 4752 AC_VERB_GET_CONNECT_SEL, 0); 4753 if (index != -1) 4754 *ucontrol->value.integer.value = index; 4755 4756 return 0; 4757 } 4758 4759 static int vt1716s_dmic_put(struct snd_kcontrol *kcontrol, 4760 struct snd_ctl_elem_value *ucontrol) 4761 { 4762 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 4763 struct via_spec *spec = codec->spec; 4764 int index = *ucontrol->value.integer.value; 4765 4766 snd_hda_codec_write(codec, 0x26, 0, 4767 AC_VERB_SET_CONNECT_SEL, index); 4768 spec->dmic_enabled = index; 4769 set_widgets_power_state(codec); 4770 return 1; 4771 } 4772 4773 /* capture mixer elements */ 4774 static const struct snd_kcontrol_new vt1716S_capture_mixer[] = { 4775 HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT), 4776 HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT), 4777 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT), 4778 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT), 4779 HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x1A, 0x0, HDA_INPUT), 4780 HDA_CODEC_VOLUME("Front Mic Boost Capture Volume", 0x1E, 0x0, 4781 HDA_INPUT), 4782 { 4783 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4784 .name = "Input Source", 4785 .count = 1, 4786 .info = via_mux_enum_info, 4787 .get = via_mux_enum_get, 4788 .put = via_mux_enum_put, 4789 }, 4790 { } /* end */ 4791 }; 4792 4793 static const struct snd_kcontrol_new vt1716s_dmic_mixer[] = { 4794 HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x22, 0x0, HDA_INPUT), 4795 { 4796 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4797 .name = "Digital Mic Capture Switch", 4798 .subdevice = HDA_SUBDEV_NID_FLAG | 0x26, 4799 .count = 1, 4800 .info = vt1716s_dmic_info, 4801 .get = vt1716s_dmic_get, 4802 .put = vt1716s_dmic_put, 4803 }, 4804 {} /* end */ 4805 }; 4806 4807 4808 /* mono-out mixer elements */ 4809 static const struct snd_kcontrol_new vt1716S_mono_out_mixer[] = { 4810 HDA_CODEC_MUTE("Mono Playback Switch", 0x2a, 0x0, HDA_OUTPUT), 4811 { } /* end */ 4812 }; 4813 4814 static const struct hda_verb vt1716S_volume_init_verbs[] = { 4815 /* 4816 * Unmute ADC0-1 and set the default input to mic-in 4817 */ 4818 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4819 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4820 4821 4822 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 4823 * mixer widget 4824 */ 4825 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ 4826 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4827 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4828 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 4829 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 4830 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 4831 4832 /* MUX Indices: Stereo Mixer = 5 */ 4833 {0x17, AC_VERB_SET_CONNECT_SEL, 0x5}, 4834 4835 /* Setup default input of PW4 to MW0 */ 4836 {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0}, 4837 4838 /* Setup default input of SW1 as MW0 */ 4839 {0x18, AC_VERB_SET_CONNECT_SEL, 0x1}, 4840 4841 /* Setup default input of SW4 as AOW0 */ 4842 {0x28, AC_VERB_SET_CONNECT_SEL, 0x1}, 4843 4844 /* PW9 PW10 Output enable */ 4845 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 4846 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 4847 4848 /* Unmute SW1, PW12 */ 4849 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4850 {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4851 /* PW12 Output enable */ 4852 {0x2a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, 4853 /* Enable Boost Volume backdoor */ 4854 {0x1, 0xf8a, 0x80}, 4855 /* don't bybass mixer */ 4856 {0x1, 0xf88, 0xc0}, 4857 /* Enable mono output */ 4858 {0x1, 0xf90, 0x08}, 4859 { } 4860 }; 4861 4862 4863 static const struct hda_verb vt1716S_uniwill_init_verbs[] = { 4864 {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE, 4865 AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT}, 4866 {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 4867 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 4868 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 4869 {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, 4870 AC_USRSP_EN | VIA_MONO_EVENT | VIA_JACK_EVENT}, 4871 {0x1e, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 4872 {0x23, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 4873 { } 4874 }; 4875 4876 static const struct hda_pcm_stream vt1716S_pcm_analog_playback = { 4877 .substreams = 2, 4878 .channels_min = 2, 4879 .channels_max = 6, 4880 .nid = 0x10, /* NID to query formats and rates */ 4881 .ops = { 4882 .open = via_playback_pcm_open, 4883 .prepare = via_playback_multi_pcm_prepare, 4884 .cleanup = via_playback_multi_pcm_cleanup, 4885 .close = via_pcm_open_close, 4886 }, 4887 }; 4888 4889 static const struct hda_pcm_stream vt1716S_pcm_analog_capture = { 4890 .substreams = 2, 4891 .channels_min = 2, 4892 .channels_max = 2, 4893 .nid = 0x13, /* NID to query formats and rates */ 4894 .ops = { 4895 .open = via_pcm_open_close, 4896 .prepare = via_capture_pcm_prepare, 4897 .cleanup = via_capture_pcm_cleanup, 4898 .close = via_pcm_open_close, 4899 }, 4900 }; 4901 4902 static const struct hda_pcm_stream vt1716S_pcm_digital_playback = { 4903 .substreams = 2, 4904 .channels_min = 2, 4905 .channels_max = 2, 4906 /* NID is set in via_build_pcms */ 4907 .ops = { 4908 .open = via_dig_playback_pcm_open, 4909 .close = via_dig_playback_pcm_close, 4910 .prepare = via_dig_playback_pcm_prepare, 4911 .cleanup = via_dig_playback_pcm_cleanup 4912 }, 4913 }; 4914 4915 /* fill in the dac_nids table from the parsed pin configuration */ 4916 static int vt1716S_auto_fill_dac_nids(struct via_spec *spec, 4917 const struct auto_pin_cfg *cfg) 4918 { int i; 4919 hda_nid_t nid; 4920 4921 spec->multiout.num_dacs = cfg->line_outs; 4922 4923 spec->multiout.dac_nids = spec->private_dac_nids; 4924 4925 for (i = 0; i < 3; i++) { 4926 nid = cfg->line_out_pins[i]; 4927 if (nid) { 4928 /* config dac list */ 4929 switch (i) { 4930 case AUTO_SEQ_FRONT: 4931 spec->private_dac_nids[i] = 0x10; 4932 break; 4933 case AUTO_SEQ_CENLFE: 4934 spec->private_dac_nids[i] = 0x25; 4935 break; 4936 case AUTO_SEQ_SURROUND: 4937 spec->private_dac_nids[i] = 0x11; 4938 break; 4939 } 4940 } 4941 } 4942 4943 return 0; 4944 } 4945 4946 /* add playback controls from the parsed DAC table */ 4947 static int vt1716S_auto_create_multi_out_ctls(struct via_spec *spec, 4948 const struct auto_pin_cfg *cfg) 4949 { 4950 char name[32]; 4951 static const char * const chname[3] = { 4952 "Front", "Surround", "C/LFE" 4953 }; 4954 hda_nid_t nid_vols[] = {0x10, 0x11, 0x25}; 4955 hda_nid_t nid_mutes[] = {0x1C, 0x18, 0x27}; 4956 hda_nid_t nid, nid_vol, nid_mute; 4957 int i, err; 4958 4959 for (i = 0; i <= AUTO_SEQ_CENLFE; i++) { 4960 nid = cfg->line_out_pins[i]; 4961 4962 if (!nid) 4963 continue; 4964 4965 nid_vol = nid_vols[i]; 4966 nid_mute = nid_mutes[i]; 4967 4968 if (i == AUTO_SEQ_CENLFE) { 4969 err = via_add_control( 4970 spec, VIA_CTL_WIDGET_VOL, 4971 "Center Playback Volume", 4972 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, HDA_OUTPUT)); 4973 if (err < 0) 4974 return err; 4975 err = via_add_control( 4976 spec, VIA_CTL_WIDGET_VOL, 4977 "LFE Playback Volume", 4978 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT)); 4979 if (err < 0) 4980 return err; 4981 err = via_add_control( 4982 spec, VIA_CTL_WIDGET_MUTE, 4983 "Center Playback Switch", 4984 HDA_COMPOSE_AMP_VAL(nid_mute, 1, 0, 4985 HDA_OUTPUT)); 4986 if (err < 0) 4987 return err; 4988 err = via_add_control( 4989 spec, VIA_CTL_WIDGET_MUTE, 4990 "LFE Playback Switch", 4991 HDA_COMPOSE_AMP_VAL(nid_mute, 2, 0, 4992 HDA_OUTPUT)); 4993 if (err < 0) 4994 return err; 4995 } else if (i == AUTO_SEQ_FRONT) { 4996 4997 err = via_add_control( 4998 spec, VIA_CTL_WIDGET_VOL, 4999 "Master Front Playback Volume", 5000 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_INPUT)); 5001 if (err < 0) 5002 return err; 5003 err = via_add_control( 5004 spec, VIA_CTL_WIDGET_MUTE, 5005 "Master Front Playback Switch", 5006 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_INPUT)); 5007 if (err < 0) 5008 return err; 5009 5010 sprintf(name, "%s Playback Volume", chname[i]); 5011 err = via_add_control( 5012 spec, VIA_CTL_WIDGET_VOL, name, 5013 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT)); 5014 if (err < 0) 5015 return err; 5016 sprintf(name, "%s Playback Switch", chname[i]); 5017 err = via_add_control( 5018 spec, VIA_CTL_WIDGET_MUTE, name, 5019 HDA_COMPOSE_AMP_VAL(nid_mute, 3, 0, 5020 HDA_OUTPUT)); 5021 if (err < 0) 5022 return err; 5023 } else { 5024 sprintf(name, "%s Playback Volume", chname[i]); 5025 err = via_add_control( 5026 spec, VIA_CTL_WIDGET_VOL, name, 5027 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT)); 5028 if (err < 0) 5029 return err; 5030 sprintf(name, "%s Playback Switch", chname[i]); 5031 err = via_add_control( 5032 spec, VIA_CTL_WIDGET_MUTE, name, 5033 HDA_COMPOSE_AMP_VAL(nid_mute, 3, 0, 5034 HDA_OUTPUT)); 5035 if (err < 0) 5036 return err; 5037 } 5038 } 5039 return 0; 5040 } 5041 5042 static int vt1716S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) 5043 { 5044 int err; 5045 5046 if (!pin) 5047 return 0; 5048 5049 spec->multiout.hp_nid = 0x25; /* AOW3 */ 5050 spec->hp_independent_mode_index = 1; 5051 5052 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 5053 "Headphone Playback Volume", 5054 HDA_COMPOSE_AMP_VAL(0x25, 3, 0, HDA_OUTPUT)); 5055 if (err < 0) 5056 return err; 5057 5058 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 5059 "Headphone Playback Switch", 5060 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 5061 if (err < 0) 5062 return err; 5063 5064 create_hp_imux(spec); 5065 return 0; 5066 } 5067 5068 /* create playback/capture controls for input pins */ 5069 static int vt1716S_auto_create_analog_input_ctls(struct hda_codec *codec, 5070 const struct auto_pin_cfg *cfg) 5071 { 5072 static const hda_nid_t pin_idxs[] = { 0x1f, 0x1a, 0x1b, 0x1e, 0, 0xff }; 5073 return vt_auto_create_analog_input_ctls(codec, cfg, 0x16, pin_idxs, 5074 ARRAY_SIZE(pin_idxs)); 5075 } 5076 5077 static int vt1716S_parse_auto_config(struct hda_codec *codec) 5078 { 5079 struct via_spec *spec = codec->spec; 5080 int err; 5081 5082 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); 5083 if (err < 0) 5084 return err; 5085 err = vt1716S_auto_fill_dac_nids(spec, &spec->autocfg); 5086 if (err < 0) 5087 return err; 5088 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) 5089 return 0; /* can't find valid BIOS pin config */ 5090 5091 err = vt1716S_auto_create_multi_out_ctls(spec, &spec->autocfg); 5092 if (err < 0) 5093 return err; 5094 err = vt1716S_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); 5095 if (err < 0) 5096 return err; 5097 err = vt1716S_auto_create_analog_input_ctls(codec, &spec->autocfg); 5098 if (err < 0) 5099 return err; 5100 5101 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 5102 5103 fill_dig_outs(codec); 5104 5105 if (spec->kctls.list) 5106 spec->mixers[spec->num_mixers++] = spec->kctls.list; 5107 5108 spec->input_mux = &spec->private_imux[0]; 5109 5110 if (spec->hp_mux) 5111 via_hp_build(codec); 5112 5113 via_smart51_build(spec); 5114 5115 return 1; 5116 } 5117 5118 #ifdef CONFIG_SND_HDA_POWER_SAVE 5119 static const struct hda_amp_list vt1716S_loopbacks[] = { 5120 { 0x16, HDA_INPUT, 1 }, 5121 { 0x16, HDA_INPUT, 2 }, 5122 { 0x16, HDA_INPUT, 3 }, 5123 { 0x16, HDA_INPUT, 4 }, 5124 { } /* end */ 5125 }; 5126 #endif 5127 5128 static void set_widgets_power_state_vt1716S(struct hda_codec *codec) 5129 { 5130 struct via_spec *spec = codec->spec; 5131 int imux_is_smixer; 5132 unsigned int parm; 5133 unsigned int mono_out, present; 5134 /* SW0 (17h) = stereo mixer */ 5135 imux_is_smixer = 5136 (snd_hda_codec_read(codec, 0x17, 0, 5137 AC_VERB_GET_CONNECT_SEL, 0x00) == 5); 5138 /* inputs */ 5139 /* PW 1/2/5 (1ah/1bh/1eh) */ 5140 parm = AC_PWRST_D3; 5141 set_pin_power_state(codec, 0x1a, &parm); 5142 set_pin_power_state(codec, 0x1b, &parm); 5143 set_pin_power_state(codec, 0x1e, &parm); 5144 if (imux_is_smixer) 5145 parm = AC_PWRST_D0; 5146 /* SW0 (17h), AIW0(13h) */ 5147 snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_POWER_STATE, parm); 5148 snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, parm); 5149 5150 parm = AC_PWRST_D3; 5151 set_pin_power_state(codec, 0x1e, &parm); 5152 /* PW11 (22h) */ 5153 if (spec->dmic_enabled) 5154 set_pin_power_state(codec, 0x22, &parm); 5155 else 5156 snd_hda_codec_write(codec, 0x22, 0, 5157 AC_VERB_SET_POWER_STATE, AC_PWRST_D3); 5158 5159 /* SW2(26h), AIW1(14h) */ 5160 snd_hda_codec_write(codec, 0x26, 0, AC_VERB_SET_POWER_STATE, parm); 5161 snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_POWER_STATE, parm); 5162 5163 /* outputs */ 5164 /* PW0 (19h), SW1 (18h), AOW1 (11h) */ 5165 parm = AC_PWRST_D3; 5166 set_pin_power_state(codec, 0x19, &parm); 5167 /* Smart 5.1 PW2(1bh) */ 5168 if (spec->smart51_enabled) 5169 set_pin_power_state(codec, 0x1b, &parm); 5170 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, parm); 5171 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm); 5172 5173 /* PW7 (23h), SW3 (27h), AOW3 (25h) */ 5174 parm = AC_PWRST_D3; 5175 set_pin_power_state(codec, 0x23, &parm); 5176 /* Smart 5.1 PW1(1ah) */ 5177 if (spec->smart51_enabled) 5178 set_pin_power_state(codec, 0x1a, &parm); 5179 snd_hda_codec_write(codec, 0x27, 0, AC_VERB_SET_POWER_STATE, parm); 5180 5181 /* Smart 5.1 PW5(1eh) */ 5182 if (spec->smart51_enabled) 5183 set_pin_power_state(codec, 0x1e, &parm); 5184 snd_hda_codec_write(codec, 0x25, 0, AC_VERB_SET_POWER_STATE, parm); 5185 5186 /* Mono out */ 5187 /* SW4(28h)->MW1(29h)-> PW12 (2ah)*/ 5188 present = snd_hda_jack_detect(codec, 0x1c); 5189 5190 if (present) 5191 mono_out = 0; 5192 else { 5193 present = snd_hda_jack_detect(codec, 0x1d); 5194 if (!spec->hp_independent_mode && present) 5195 mono_out = 0; 5196 else 5197 mono_out = 1; 5198 } 5199 parm = mono_out ? AC_PWRST_D0 : AC_PWRST_D3; 5200 snd_hda_codec_write(codec, 0x28, 0, AC_VERB_SET_POWER_STATE, parm); 5201 snd_hda_codec_write(codec, 0x29, 0, AC_VERB_SET_POWER_STATE, parm); 5202 snd_hda_codec_write(codec, 0x2a, 0, AC_VERB_SET_POWER_STATE, parm); 5203 5204 /* PW 3/4 (1ch/1dh) */ 5205 parm = AC_PWRST_D3; 5206 set_pin_power_state(codec, 0x1c, &parm); 5207 set_pin_power_state(codec, 0x1d, &parm); 5208 /* HP Independent Mode, power on AOW3 */ 5209 if (spec->hp_independent_mode) 5210 snd_hda_codec_write(codec, 0x25, 0, 5211 AC_VERB_SET_POWER_STATE, parm); 5212 5213 /* force to D0 for internal Speaker */ 5214 /* MW0 (16h), AOW0 (10h) */ 5215 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_POWER_STATE, 5216 imux_is_smixer ? AC_PWRST_D0 : parm); 5217 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, 5218 mono_out ? AC_PWRST_D0 : parm); 5219 } 5220 5221 static int patch_vt1716S(struct hda_codec *codec) 5222 { 5223 struct via_spec *spec; 5224 int err; 5225 5226 /* create a codec specific record */ 5227 spec = via_new_spec(codec); 5228 if (spec == NULL) 5229 return -ENOMEM; 5230 5231 /* automatic parse from the BIOS config */ 5232 err = vt1716S_parse_auto_config(codec); 5233 if (err < 0) { 5234 via_free(codec); 5235 return err; 5236 } else if (!err) { 5237 printk(KERN_INFO "hda_codec: Cannot set up configuration " 5238 "from BIOS. Using genenic mode...\n"); 5239 } 5240 5241 spec->init_verbs[spec->num_iverbs++] = vt1716S_volume_init_verbs; 5242 spec->init_verbs[spec->num_iverbs++] = vt1716S_uniwill_init_verbs; 5243 5244 spec->stream_name_analog = "VT1716S Analog"; 5245 spec->stream_analog_playback = &vt1716S_pcm_analog_playback; 5246 spec->stream_analog_capture = &vt1716S_pcm_analog_capture; 5247 5248 spec->stream_name_digital = "VT1716S Digital"; 5249 spec->stream_digital_playback = &vt1716S_pcm_digital_playback; 5250 5251 if (!spec->adc_nids && spec->input_mux) { 5252 spec->adc_nids = vt1716S_adc_nids; 5253 spec->num_adc_nids = ARRAY_SIZE(vt1716S_adc_nids); 5254 get_mux_nids(codec); 5255 override_mic_boost(codec, 0x1a, 0, 3, 40); 5256 override_mic_boost(codec, 0x1e, 0, 3, 40); 5257 spec->mixers[spec->num_mixers] = vt1716S_capture_mixer; 5258 spec->num_mixers++; 5259 } 5260 5261 spec->mixers[spec->num_mixers] = vt1716s_dmic_mixer; 5262 spec->num_mixers++; 5263 5264 spec->mixers[spec->num_mixers++] = vt1716S_mono_out_mixer; 5265 5266 codec->patch_ops = via_patch_ops; 5267 5268 codec->patch_ops.init = via_auto_init; 5269 codec->patch_ops.unsol_event = via_unsol_event; 5270 5271 #ifdef CONFIG_SND_HDA_POWER_SAVE 5272 spec->loopback.amplist = vt1716S_loopbacks; 5273 #endif 5274 5275 spec->set_widgets_power_state = set_widgets_power_state_vt1716S; 5276 return 0; 5277 } 5278 5279 /* for vt2002P */ 5280 5281 /* capture mixer elements */ 5282 static const struct snd_kcontrol_new vt2002P_capture_mixer[] = { 5283 HDA_CODEC_VOLUME("Capture Volume", 0x10, 0x0, HDA_INPUT), 5284 HDA_CODEC_MUTE("Capture Switch", 0x10, 0x0, HDA_INPUT), 5285 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x11, 0x0, HDA_INPUT), 5286 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x11, 0x0, HDA_INPUT), 5287 HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x2b, 0x0, HDA_INPUT), 5288 HDA_CODEC_VOLUME("Front Mic Boost Capture Volume", 0x29, 0x0, 5289 HDA_INPUT), 5290 { 5291 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 5292 /* The multiple "Capture Source" controls confuse alsamixer 5293 * So call somewhat different.. 5294 */ 5295 /* .name = "Capture Source", */ 5296 .name = "Input Source", 5297 .count = 2, 5298 .info = via_mux_enum_info, 5299 .get = via_mux_enum_get, 5300 .put = via_mux_enum_put, 5301 }, 5302 { } /* end */ 5303 }; 5304 5305 static const struct hda_verb vt2002P_volume_init_verbs[] = { 5306 /* Class-D speaker related verbs */ 5307 {0x1, 0xfe0, 0x4}, 5308 {0x1, 0xfe9, 0x80}, 5309 {0x1, 0xfe2, 0x22}, 5310 /* 5311 * Unmute ADC0-1 and set the default input to mic-in 5312 */ 5313 {0x8, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5314 {0x9, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5315 5316 5317 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 5318 * mixer widget 5319 */ 5320 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ 5321 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5322 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5323 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5324 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5325 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5326 5327 /* MUX Indices: Mic = 0 */ 5328 {0x1e, AC_VERB_SET_CONNECT_SEL, 0}, 5329 {0x1f, AC_VERB_SET_CONNECT_SEL, 0}, 5330 5331 /* PW9 Output enable */ 5332 {0x2d, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN}, 5333 5334 /* Enable Boost Volume backdoor */ 5335 {0x1, 0xfb9, 0x24}, 5336 5337 /* MW0/1/4/8: un-mute index 0 (MUXx), un-mute index 1 (MW9) */ 5338 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5339 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5340 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5341 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5342 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5343 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5344 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5345 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5346 5347 /* set MUX0/1/4/8 = 0 (AOW0) */ 5348 {0x34, AC_VERB_SET_CONNECT_SEL, 0}, 5349 {0x35, AC_VERB_SET_CONNECT_SEL, 0}, 5350 {0x37, AC_VERB_SET_CONNECT_SEL, 0}, 5351 {0x3b, AC_VERB_SET_CONNECT_SEL, 0}, 5352 5353 /* set PW0 index=0 (MW0) */ 5354 {0x24, AC_VERB_SET_CONNECT_SEL, 0}, 5355 5356 /* Enable AOW0 to MW9 */ 5357 {0x1, 0xfb8, 0x88}, 5358 { } 5359 }; 5360 static const struct hda_verb vt1802_volume_init_verbs[] = { 5361 /* 5362 * Unmute ADC0-1 and set the default input to mic-in 5363 */ 5364 {0x8, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5365 {0x9, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5366 5367 5368 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 5369 * mixer widget 5370 */ 5371 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ 5372 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5373 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5374 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5375 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5376 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5377 5378 /* MUX Indices: Mic = 0 */ 5379 {0x1e, AC_VERB_SET_CONNECT_SEL, 0}, 5380 {0x1f, AC_VERB_SET_CONNECT_SEL, 0}, 5381 5382 /* PW9 Output enable */ 5383 {0x2d, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN}, 5384 5385 /* Enable Boost Volume backdoor */ 5386 {0x1, 0xfb9, 0x24}, 5387 5388 /* MW0/1/4/8: un-mute index 0 (MUXx), un-mute index 1 (MW9) */ 5389 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5390 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5391 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5392 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5393 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5394 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5395 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5396 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5397 5398 /* set MUX0/1/4/8 = 0 (AOW0) */ 5399 {0x34, AC_VERB_SET_CONNECT_SEL, 0}, 5400 {0x35, AC_VERB_SET_CONNECT_SEL, 0}, 5401 {0x38, AC_VERB_SET_CONNECT_SEL, 0}, 5402 {0x3c, AC_VERB_SET_CONNECT_SEL, 0}, 5403 5404 /* set PW0 index=0 (MW0) */ 5405 {0x24, AC_VERB_SET_CONNECT_SEL, 0}, 5406 5407 /* Enable AOW0 to MW9 */ 5408 {0x1, 0xfb8, 0x88}, 5409 { } 5410 }; 5411 5412 5413 static const struct hda_verb vt2002P_uniwill_init_verbs[] = { 5414 {0x25, AC_VERB_SET_UNSOLICITED_ENABLE, 5415 AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT}, 5416 {0x26, AC_VERB_SET_UNSOLICITED_ENABLE, 5417 AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT}, 5418 {0x29, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 5419 {0x2a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 5420 {0x2b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 5421 { } 5422 }; 5423 static const struct hda_verb vt1802_uniwill_init_verbs[] = { 5424 {0x25, AC_VERB_SET_UNSOLICITED_ENABLE, 5425 AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT}, 5426 {0x28, AC_VERB_SET_UNSOLICITED_ENABLE, 5427 AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT}, 5428 {0x29, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 5429 {0x2a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 5430 {0x2b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 5431 { } 5432 }; 5433 5434 static const struct hda_pcm_stream vt2002P_pcm_analog_playback = { 5435 .substreams = 2, 5436 .channels_min = 2, 5437 .channels_max = 2, 5438 .nid = 0x8, /* NID to query formats and rates */ 5439 .ops = { 5440 .open = via_playback_pcm_open, 5441 .prepare = via_playback_multi_pcm_prepare, 5442 .cleanup = via_playback_multi_pcm_cleanup, 5443 .close = via_pcm_open_close, 5444 }, 5445 }; 5446 5447 static const struct hda_pcm_stream vt2002P_pcm_analog_capture = { 5448 .substreams = 2, 5449 .channels_min = 2, 5450 .channels_max = 2, 5451 .nid = 0x10, /* NID to query formats and rates */ 5452 .ops = { 5453 .open = via_pcm_open_close, 5454 .prepare = via_capture_pcm_prepare, 5455 .cleanup = via_capture_pcm_cleanup, 5456 .close = via_pcm_open_close, 5457 }, 5458 }; 5459 5460 static const struct hda_pcm_stream vt2002P_pcm_digital_playback = { 5461 .substreams = 1, 5462 .channels_min = 2, 5463 .channels_max = 2, 5464 /* NID is set in via_build_pcms */ 5465 .ops = { 5466 .open = via_dig_playback_pcm_open, 5467 .close = via_dig_playback_pcm_close, 5468 .prepare = via_dig_playback_pcm_prepare, 5469 .cleanup = via_dig_playback_pcm_cleanup 5470 }, 5471 }; 5472 5473 /* fill in the dac_nids table from the parsed pin configuration */ 5474 static int vt2002P_auto_fill_dac_nids(struct via_spec *spec, 5475 const struct auto_pin_cfg *cfg) 5476 { 5477 spec->multiout.num_dacs = 1; 5478 spec->multiout.dac_nids = spec->private_dac_nids; 5479 if (cfg->line_out_pins[0]) 5480 spec->private_dac_nids[0] = 0x8; 5481 return 0; 5482 } 5483 5484 /* add playback controls from the parsed DAC table */ 5485 static int vt2002P_auto_create_multi_out_ctls(struct via_spec *spec, 5486 const struct auto_pin_cfg *cfg) 5487 { 5488 int err; 5489 hda_nid_t sw_nid; 5490 5491 if (!cfg->line_out_pins[0]) 5492 return -1; 5493 5494 if (spec->codec_type == VT1802) 5495 sw_nid = 0x28; 5496 else 5497 sw_nid = 0x26; 5498 5499 /* Line-Out: PortE */ 5500 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 5501 "Master Front Playback Volume", 5502 HDA_COMPOSE_AMP_VAL(0x8, 3, 0, HDA_OUTPUT)); 5503 if (err < 0) 5504 return err; 5505 err = via_add_control(spec, VIA_CTL_WIDGET_BIND_PIN_MUTE, 5506 "Master Front Playback Switch", 5507 HDA_COMPOSE_AMP_VAL(sw_nid, 3, 0, HDA_OUTPUT)); 5508 if (err < 0) 5509 return err; 5510 5511 return 0; 5512 } 5513 5514 static int vt2002P_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) 5515 { 5516 int err; 5517 5518 if (!pin) 5519 return 0; 5520 5521 spec->multiout.hp_nid = 0x9; 5522 spec->hp_independent_mode_index = 1; 5523 5524 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 5525 "Headphone Playback Volume", 5526 HDA_COMPOSE_AMP_VAL( 5527 spec->multiout.hp_nid, 3, 0, HDA_OUTPUT)); 5528 if (err < 0) 5529 return err; 5530 5531 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 5532 "Headphone Playback Switch", 5533 HDA_COMPOSE_AMP_VAL(0x25, 3, 0, HDA_OUTPUT)); 5534 if (err < 0) 5535 return err; 5536 5537 create_hp_imux(spec); 5538 return 0; 5539 } 5540 5541 /* create playback/capture controls for input pins */ 5542 static int vt2002P_auto_create_analog_input_ctls(struct hda_codec *codec, 5543 const struct auto_pin_cfg *cfg) 5544 { 5545 struct via_spec *spec = codec->spec; 5546 struct hda_input_mux *imux = &spec->private_imux[0]; 5547 static const hda_nid_t pin_idxs[] = { 0x2b, 0x2a, 0x29, 0xff }; 5548 int err; 5549 5550 err = vt_auto_create_analog_input_ctls(codec, cfg, 0x21, pin_idxs, 5551 ARRAY_SIZE(pin_idxs)); 5552 if (err < 0) 5553 return err; 5554 /* build volume/mute control of loopback */ 5555 err = via_new_analog_input(spec, "Stereo Mixer", 0, 3, 0x21); 5556 if (err < 0) 5557 return err; 5558 5559 /* for digital mic select */ 5560 snd_hda_add_imux_item(imux, "Digital Mic", 4, NULL); 5561 5562 return 0; 5563 } 5564 5565 static int vt2002P_parse_auto_config(struct hda_codec *codec) 5566 { 5567 struct via_spec *spec = codec->spec; 5568 int err; 5569 5570 5571 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); 5572 if (err < 0) 5573 return err; 5574 5575 err = vt2002P_auto_fill_dac_nids(spec, &spec->autocfg); 5576 if (err < 0) 5577 return err; 5578 5579 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) 5580 return 0; /* can't find valid BIOS pin config */ 5581 5582 err = vt2002P_auto_create_multi_out_ctls(spec, &spec->autocfg); 5583 if (err < 0) 5584 return err; 5585 err = vt2002P_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); 5586 if (err < 0) 5587 return err; 5588 err = vt2002P_auto_create_analog_input_ctls(codec, &spec->autocfg); 5589 if (err < 0) 5590 return err; 5591 5592 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 5593 5594 fill_dig_outs(codec); 5595 5596 if (spec->kctls.list) 5597 spec->mixers[spec->num_mixers++] = spec->kctls.list; 5598 5599 spec->input_mux = &spec->private_imux[0]; 5600 5601 if (spec->hp_mux) 5602 via_hp_build(codec); 5603 5604 return 1; 5605 } 5606 5607 #ifdef CONFIG_SND_HDA_POWER_SAVE 5608 static const struct hda_amp_list vt2002P_loopbacks[] = { 5609 { 0x21, HDA_INPUT, 0 }, 5610 { 0x21, HDA_INPUT, 1 }, 5611 { 0x21, HDA_INPUT, 2 }, 5612 { } /* end */ 5613 }; 5614 #endif 5615 5616 static void set_widgets_power_state_vt2002P(struct hda_codec *codec) 5617 { 5618 struct via_spec *spec = codec->spec; 5619 int imux_is_smixer; 5620 unsigned int parm; 5621 unsigned int present; 5622 /* MUX9 (1eh) = stereo mixer */ 5623 imux_is_smixer = 5624 snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3; 5625 /* inputs */ 5626 /* PW 5/6/7 (29h/2ah/2bh) */ 5627 parm = AC_PWRST_D3; 5628 set_pin_power_state(codec, 0x29, &parm); 5629 set_pin_power_state(codec, 0x2a, &parm); 5630 set_pin_power_state(codec, 0x2b, &parm); 5631 parm = AC_PWRST_D0; 5632 /* MUX9/10 (1eh/1fh), AIW 0/1 (10h/11h) */ 5633 snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE, parm); 5634 snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm); 5635 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm); 5636 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm); 5637 5638 /* outputs */ 5639 /* AOW0 (8h)*/ 5640 snd_hda_codec_write(codec, 0x8, 0, AC_VERB_SET_POWER_STATE, parm); 5641 5642 if (spec->codec_type == VT1802) { 5643 /* PW4 (28h), MW4 (18h), MUX4(38h) */ 5644 parm = AC_PWRST_D3; 5645 set_pin_power_state(codec, 0x28, &parm); 5646 snd_hda_codec_write(codec, 0x18, 0, 5647 AC_VERB_SET_POWER_STATE, parm); 5648 snd_hda_codec_write(codec, 0x38, 0, 5649 AC_VERB_SET_POWER_STATE, parm); 5650 } else { 5651 /* PW4 (26h), MW4 (1ch), MUX4(37h) */ 5652 parm = AC_PWRST_D3; 5653 set_pin_power_state(codec, 0x26, &parm); 5654 snd_hda_codec_write(codec, 0x1c, 0, 5655 AC_VERB_SET_POWER_STATE, parm); 5656 snd_hda_codec_write(codec, 0x37, 0, 5657 AC_VERB_SET_POWER_STATE, parm); 5658 } 5659 5660 if (spec->codec_type == VT1802) { 5661 /* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */ 5662 parm = AC_PWRST_D3; 5663 set_pin_power_state(codec, 0x25, &parm); 5664 snd_hda_codec_write(codec, 0x15, 0, 5665 AC_VERB_SET_POWER_STATE, parm); 5666 snd_hda_codec_write(codec, 0x35, 0, 5667 AC_VERB_SET_POWER_STATE, parm); 5668 } else { 5669 /* PW1 (25h), MW1 (19h), MUX1(35h), AOW1 (9h) */ 5670 parm = AC_PWRST_D3; 5671 set_pin_power_state(codec, 0x25, &parm); 5672 snd_hda_codec_write(codec, 0x19, 0, 5673 AC_VERB_SET_POWER_STATE, parm); 5674 snd_hda_codec_write(codec, 0x35, 0, 5675 AC_VERB_SET_POWER_STATE, parm); 5676 } 5677 5678 if (spec->hp_independent_mode) 5679 snd_hda_codec_write(codec, 0x9, 0, 5680 AC_VERB_SET_POWER_STATE, AC_PWRST_D0); 5681 5682 /* Class-D */ 5683 /* PW0 (24h), MW0(18h/14h), MUX0(34h) */ 5684 present = snd_hda_jack_detect(codec, 0x25); 5685 5686 parm = AC_PWRST_D3; 5687 set_pin_power_state(codec, 0x24, &parm); 5688 parm = present ? AC_PWRST_D3 : AC_PWRST_D0; 5689 if (spec->codec_type == VT1802) 5690 snd_hda_codec_write(codec, 0x14, 0, 5691 AC_VERB_SET_POWER_STATE, parm); 5692 else 5693 snd_hda_codec_write(codec, 0x18, 0, 5694 AC_VERB_SET_POWER_STATE, parm); 5695 snd_hda_codec_write(codec, 0x34, 0, AC_VERB_SET_POWER_STATE, parm); 5696 5697 /* Mono Out */ 5698 present = snd_hda_jack_detect(codec, 0x26); 5699 5700 parm = present ? AC_PWRST_D3 : AC_PWRST_D0; 5701 if (spec->codec_type == VT1802) { 5702 /* PW15 (33h), MW8(1ch), MUX8(3ch) */ 5703 snd_hda_codec_write(codec, 0x33, 0, 5704 AC_VERB_SET_POWER_STATE, parm); 5705 snd_hda_codec_write(codec, 0x1c, 0, 5706 AC_VERB_SET_POWER_STATE, parm); 5707 snd_hda_codec_write(codec, 0x3c, 0, 5708 AC_VERB_SET_POWER_STATE, parm); 5709 } else { 5710 /* PW15 (31h), MW8(17h), MUX8(3bh) */ 5711 snd_hda_codec_write(codec, 0x31, 0, 5712 AC_VERB_SET_POWER_STATE, parm); 5713 snd_hda_codec_write(codec, 0x17, 0, 5714 AC_VERB_SET_POWER_STATE, parm); 5715 snd_hda_codec_write(codec, 0x3b, 0, 5716 AC_VERB_SET_POWER_STATE, parm); 5717 } 5718 /* MW9 (21h) */ 5719 if (imux_is_smixer || !is_aa_path_mute(codec)) 5720 snd_hda_codec_write(codec, 0x21, 0, 5721 AC_VERB_SET_POWER_STATE, AC_PWRST_D0); 5722 else 5723 snd_hda_codec_write(codec, 0x21, 0, 5724 AC_VERB_SET_POWER_STATE, AC_PWRST_D3); 5725 } 5726 5727 /* patch for vt2002P */ 5728 static int patch_vt2002P(struct hda_codec *codec) 5729 { 5730 struct via_spec *spec; 5731 int err; 5732 5733 /* create a codec specific record */ 5734 spec = via_new_spec(codec); 5735 if (spec == NULL) 5736 return -ENOMEM; 5737 5738 /* automatic parse from the BIOS config */ 5739 err = vt2002P_parse_auto_config(codec); 5740 if (err < 0) { 5741 via_free(codec); 5742 return err; 5743 } else if (!err) { 5744 printk(KERN_INFO "hda_codec: Cannot set up configuration " 5745 "from BIOS. Using genenic mode...\n"); 5746 } 5747 5748 if (spec->codec_type == VT1802) 5749 spec->init_verbs[spec->num_iverbs++] = 5750 vt1802_volume_init_verbs; 5751 else 5752 spec->init_verbs[spec->num_iverbs++] = 5753 vt2002P_volume_init_verbs; 5754 5755 if (spec->codec_type == VT1802) 5756 spec->init_verbs[spec->num_iverbs++] = 5757 vt1802_uniwill_init_verbs; 5758 else 5759 spec->init_verbs[spec->num_iverbs++] = 5760 vt2002P_uniwill_init_verbs; 5761 5762 if (spec->codec_type == VT1802) 5763 spec->stream_name_analog = "VT1802 Analog"; 5764 else 5765 spec->stream_name_analog = "VT2002P Analog"; 5766 spec->stream_analog_playback = &vt2002P_pcm_analog_playback; 5767 spec->stream_analog_capture = &vt2002P_pcm_analog_capture; 5768 5769 if (spec->codec_type == VT1802) 5770 spec->stream_name_digital = "VT1802 Digital"; 5771 else 5772 spec->stream_name_digital = "VT2002P Digital"; 5773 spec->stream_digital_playback = &vt2002P_pcm_digital_playback; 5774 5775 if (!spec->adc_nids && spec->input_mux) { 5776 spec->adc_nids = vt2002P_adc_nids; 5777 spec->num_adc_nids = ARRAY_SIZE(vt2002P_adc_nids); 5778 get_mux_nids(codec); 5779 override_mic_boost(codec, 0x2b, 0, 3, 40); 5780 override_mic_boost(codec, 0x29, 0, 3, 40); 5781 spec->mixers[spec->num_mixers] = vt2002P_capture_mixer; 5782 spec->num_mixers++; 5783 } 5784 5785 codec->patch_ops = via_patch_ops; 5786 5787 codec->patch_ops.init = via_auto_init; 5788 codec->patch_ops.unsol_event = via_unsol_event; 5789 5790 #ifdef CONFIG_SND_HDA_POWER_SAVE 5791 spec->loopback.amplist = vt2002P_loopbacks; 5792 #endif 5793 5794 spec->set_widgets_power_state = set_widgets_power_state_vt2002P; 5795 return 0; 5796 } 5797 5798 /* for vt1812 */ 5799 5800 /* capture mixer elements */ 5801 static const struct snd_kcontrol_new vt1812_capture_mixer[] = { 5802 HDA_CODEC_VOLUME("Capture Volume", 0x10, 0x0, HDA_INPUT), 5803 HDA_CODEC_MUTE("Capture Switch", 0x10, 0x0, HDA_INPUT), 5804 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x11, 0x0, HDA_INPUT), 5805 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x11, 0x0, HDA_INPUT), 5806 HDA_CODEC_MUTE("Mic Boost Capture Volume", 0x2b, 0x0, HDA_INPUT), 5807 HDA_CODEC_MUTE("Front Mic Boost Capture Volume", 0x29, 0x0, 5808 HDA_INPUT), 5809 { 5810 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 5811 /* The multiple "Capture Source" controls confuse alsamixer 5812 * So call somewhat different.. 5813 */ 5814 .name = "Input Source", 5815 .count = 2, 5816 .info = via_mux_enum_info, 5817 .get = via_mux_enum_get, 5818 .put = via_mux_enum_put, 5819 }, 5820 { } /* end */ 5821 }; 5822 5823 static const struct hda_verb vt1812_volume_init_verbs[] = { 5824 /* 5825 * Unmute ADC0-1 and set the default input to mic-in 5826 */ 5827 {0x8, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5828 {0x9, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5829 5830 5831 /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback 5832 * mixer widget 5833 */ 5834 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */ 5835 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 5836 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 5837 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 5838 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 5839 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 5840 5841 /* MUX Indices: Mic = 0 */ 5842 {0x1e, AC_VERB_SET_CONNECT_SEL, 0}, 5843 {0x1f, AC_VERB_SET_CONNECT_SEL, 0}, 5844 5845 /* PW9 Output enable */ 5846 {0x2d, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN}, 5847 5848 /* Enable Boost Volume backdoor */ 5849 {0x1, 0xfb9, 0x24}, 5850 5851 /* MW0/1/4/13/15: un-mute index 0 (MUXx), un-mute index 1 (MW9) */ 5852 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5853 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5854 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5855 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5856 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 5857 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5858 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5859 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5860 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5861 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 5862 5863 /* set MUX0/1/4/13/15 = 0 (AOW0) */ 5864 {0x34, AC_VERB_SET_CONNECT_SEL, 0}, 5865 {0x35, AC_VERB_SET_CONNECT_SEL, 0}, 5866 {0x38, AC_VERB_SET_CONNECT_SEL, 0}, 5867 {0x3c, AC_VERB_SET_CONNECT_SEL, 0}, 5868 {0x3d, AC_VERB_SET_CONNECT_SEL, 0}, 5869 5870 /* Enable AOW0 to MW9 */ 5871 {0x1, 0xfb8, 0xa8}, 5872 { } 5873 }; 5874 5875 5876 static const struct hda_verb vt1812_uniwill_init_verbs[] = { 5877 {0x33, AC_VERB_SET_UNSOLICITED_ENABLE, 5878 AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT}, 5879 {0x25, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT }, 5880 {0x28, AC_VERB_SET_UNSOLICITED_ENABLE, 5881 AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT}, 5882 {0x29, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 5883 {0x2a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 5884 {0x2b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT}, 5885 { } 5886 }; 5887 5888 static const struct hda_pcm_stream vt1812_pcm_analog_playback = { 5889 .substreams = 2, 5890 .channels_min = 2, 5891 .channels_max = 2, 5892 .nid = 0x8, /* NID to query formats and rates */ 5893 .ops = { 5894 .open = via_playback_pcm_open, 5895 .prepare = via_playback_multi_pcm_prepare, 5896 .cleanup = via_playback_multi_pcm_cleanup, 5897 .close = via_pcm_open_close, 5898 }, 5899 }; 5900 5901 static const struct hda_pcm_stream vt1812_pcm_analog_capture = { 5902 .substreams = 2, 5903 .channels_min = 2, 5904 .channels_max = 2, 5905 .nid = 0x10, /* NID to query formats and rates */ 5906 .ops = { 5907 .open = via_pcm_open_close, 5908 .prepare = via_capture_pcm_prepare, 5909 .cleanup = via_capture_pcm_cleanup, 5910 .close = via_pcm_open_close, 5911 }, 5912 }; 5913 5914 static const struct hda_pcm_stream vt1812_pcm_digital_playback = { 5915 .substreams = 1, 5916 .channels_min = 2, 5917 .channels_max = 2, 5918 /* NID is set in via_build_pcms */ 5919 .ops = { 5920 .open = via_dig_playback_pcm_open, 5921 .close = via_dig_playback_pcm_close, 5922 .prepare = via_dig_playback_pcm_prepare, 5923 .cleanup = via_dig_playback_pcm_cleanup 5924 }, 5925 }; 5926 /* fill in the dac_nids table from the parsed pin configuration */ 5927 static int vt1812_auto_fill_dac_nids(struct via_spec *spec, 5928 const struct auto_pin_cfg *cfg) 5929 { 5930 spec->multiout.num_dacs = 1; 5931 spec->multiout.dac_nids = spec->private_dac_nids; 5932 if (cfg->line_out_pins[0]) 5933 spec->private_dac_nids[0] = 0x8; 5934 return 0; 5935 } 5936 5937 5938 /* add playback controls from the parsed DAC table */ 5939 static int vt1812_auto_create_multi_out_ctls(struct via_spec *spec, 5940 const struct auto_pin_cfg *cfg) 5941 { 5942 int err; 5943 5944 if (!cfg->line_out_pins[0]) 5945 return -1; 5946 5947 /* Line-Out: PortE */ 5948 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 5949 "Front Playback Volume", 5950 HDA_COMPOSE_AMP_VAL(0x8, 3, 0, HDA_OUTPUT)); 5951 if (err < 0) 5952 return err; 5953 err = via_add_control(spec, VIA_CTL_WIDGET_BIND_PIN_MUTE, 5954 "Front Playback Switch", 5955 HDA_COMPOSE_AMP_VAL(0x28, 3, 0, HDA_OUTPUT)); 5956 if (err < 0) 5957 return err; 5958 5959 return 0; 5960 } 5961 5962 static int vt1812_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) 5963 { 5964 int err; 5965 5966 if (!pin) 5967 return 0; 5968 5969 spec->multiout.hp_nid = 0x9; 5970 spec->hp_independent_mode_index = 1; 5971 5972 5973 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, 5974 "Headphone Playback Volume", 5975 HDA_COMPOSE_AMP_VAL( 5976 spec->multiout.hp_nid, 3, 0, HDA_OUTPUT)); 5977 if (err < 0) 5978 return err; 5979 5980 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, 5981 "Headphone Playback Switch", 5982 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT)); 5983 if (err < 0) 5984 return err; 5985 5986 create_hp_imux(spec); 5987 return 0; 5988 } 5989 5990 /* create playback/capture controls for input pins */ 5991 static int vt1812_auto_create_analog_input_ctls(struct hda_codec *codec, 5992 const struct auto_pin_cfg *cfg) 5993 { 5994 struct via_spec *spec = codec->spec; 5995 struct hda_input_mux *imux = &spec->private_imux[0]; 5996 static const hda_nid_t pin_idxs[] = { 0x2b, 0x2a, 0x29, 0, 0, 0xff }; 5997 int err; 5998 5999 err = vt_auto_create_analog_input_ctls(codec, cfg, 0x21, pin_idxs, 6000 ARRAY_SIZE(pin_idxs)); 6001 if (err < 0) 6002 return err; 6003 6004 /* build volume/mute control of loopback */ 6005 err = via_new_analog_input(spec, "Stereo Mixer", 0, 5, 0x21); 6006 if (err < 0) 6007 return err; 6008 6009 /* for digital mic select */ 6010 snd_hda_add_imux_item(imux, "Digital Mic", 6, NULL); 6011 6012 return 0; 6013 } 6014 6015 static int vt1812_parse_auto_config(struct hda_codec *codec) 6016 { 6017 struct via_spec *spec = codec->spec; 6018 int err; 6019 6020 6021 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); 6022 if (err < 0) 6023 return err; 6024 fill_dig_outs(codec); 6025 err = vt1812_auto_fill_dac_nids(spec, &spec->autocfg); 6026 if (err < 0) 6027 return err; 6028 6029 if (!spec->autocfg.line_outs && !spec->autocfg.hp_outs) 6030 return 0; /* can't find valid BIOS pin config */ 6031 6032 err = vt1812_auto_create_multi_out_ctls(spec, &spec->autocfg); 6033 if (err < 0) 6034 return err; 6035 err = vt1812_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); 6036 if (err < 0) 6037 return err; 6038 err = vt1812_auto_create_analog_input_ctls(codec, &spec->autocfg); 6039 if (err < 0) 6040 return err; 6041 6042 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 6043 6044 fill_dig_outs(codec); 6045 6046 if (spec->kctls.list) 6047 spec->mixers[spec->num_mixers++] = spec->kctls.list; 6048 6049 spec->input_mux = &spec->private_imux[0]; 6050 6051 if (spec->hp_mux) 6052 via_hp_build(codec); 6053 6054 return 1; 6055 } 6056 6057 #ifdef CONFIG_SND_HDA_POWER_SAVE 6058 static const struct hda_amp_list vt1812_loopbacks[] = { 6059 { 0x21, HDA_INPUT, 0 }, 6060 { 0x21, HDA_INPUT, 1 }, 6061 { 0x21, HDA_INPUT, 2 }, 6062 { } /* end */ 6063 }; 6064 #endif 6065 6066 static void set_widgets_power_state_vt1812(struct hda_codec *codec) 6067 { 6068 struct via_spec *spec = codec->spec; 6069 int imux_is_smixer = 6070 snd_hda_codec_read(codec, 0x13, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3; 6071 unsigned int parm; 6072 unsigned int present; 6073 /* MUX10 (1eh) = stereo mixer */ 6074 imux_is_smixer = 6075 snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 5; 6076 /* inputs */ 6077 /* PW 5/6/7 (29h/2ah/2bh) */ 6078 parm = AC_PWRST_D3; 6079 set_pin_power_state(codec, 0x29, &parm); 6080 set_pin_power_state(codec, 0x2a, &parm); 6081 set_pin_power_state(codec, 0x2b, &parm); 6082 parm = AC_PWRST_D0; 6083 /* MUX10/11 (1eh/1fh), AIW 0/1 (10h/11h) */ 6084 snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE, parm); 6085 snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm); 6086 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm); 6087 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm); 6088 6089 /* outputs */ 6090 /* AOW0 (8h)*/ 6091 snd_hda_codec_write(codec, 0x8, 0, 6092 AC_VERB_SET_POWER_STATE, AC_PWRST_D0); 6093 6094 /* PW4 (28h), MW4 (18h), MUX4(38h) */ 6095 parm = AC_PWRST_D3; 6096 set_pin_power_state(codec, 0x28, &parm); 6097 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, parm); 6098 snd_hda_codec_write(codec, 0x38, 0, AC_VERB_SET_POWER_STATE, parm); 6099 6100 /* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */ 6101 parm = AC_PWRST_D3; 6102 set_pin_power_state(codec, 0x25, &parm); 6103 snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_POWER_STATE, parm); 6104 snd_hda_codec_write(codec, 0x35, 0, AC_VERB_SET_POWER_STATE, parm); 6105 if (spec->hp_independent_mode) 6106 snd_hda_codec_write(codec, 0x9, 0, 6107 AC_VERB_SET_POWER_STATE, AC_PWRST_D0); 6108 6109 /* Internal Speaker */ 6110 /* PW0 (24h), MW0(14h), MUX0(34h) */ 6111 present = snd_hda_jack_detect(codec, 0x25); 6112 6113 parm = AC_PWRST_D3; 6114 set_pin_power_state(codec, 0x24, &parm); 6115 if (present) { 6116 snd_hda_codec_write(codec, 0x14, 0, 6117 AC_VERB_SET_POWER_STATE, AC_PWRST_D3); 6118 snd_hda_codec_write(codec, 0x34, 0, 6119 AC_VERB_SET_POWER_STATE, AC_PWRST_D3); 6120 } else { 6121 snd_hda_codec_write(codec, 0x14, 0, 6122 AC_VERB_SET_POWER_STATE, AC_PWRST_D0); 6123 snd_hda_codec_write(codec, 0x34, 0, 6124 AC_VERB_SET_POWER_STATE, AC_PWRST_D0); 6125 } 6126 6127 6128 /* Mono Out */ 6129 /* PW13 (31h), MW13(1ch), MUX13(3ch), MW14(3eh) */ 6130 present = snd_hda_jack_detect(codec, 0x28); 6131 6132 parm = AC_PWRST_D3; 6133 set_pin_power_state(codec, 0x31, &parm); 6134 if (present) { 6135 snd_hda_codec_write(codec, 0x1c, 0, 6136 AC_VERB_SET_POWER_STATE, AC_PWRST_D3); 6137 snd_hda_codec_write(codec, 0x3c, 0, 6138 AC_VERB_SET_POWER_STATE, AC_PWRST_D3); 6139 snd_hda_codec_write(codec, 0x3e, 0, 6140 AC_VERB_SET_POWER_STATE, AC_PWRST_D3); 6141 } else { 6142 snd_hda_codec_write(codec, 0x1c, 0, 6143 AC_VERB_SET_POWER_STATE, AC_PWRST_D0); 6144 snd_hda_codec_write(codec, 0x3c, 0, 6145 AC_VERB_SET_POWER_STATE, AC_PWRST_D0); 6146 snd_hda_codec_write(codec, 0x3e, 0, 6147 AC_VERB_SET_POWER_STATE, AC_PWRST_D0); 6148 } 6149 6150 /* PW15 (33h), MW15 (1dh), MUX15(3dh) */ 6151 parm = AC_PWRST_D3; 6152 set_pin_power_state(codec, 0x33, &parm); 6153 snd_hda_codec_write(codec, 0x1d, 0, AC_VERB_SET_POWER_STATE, parm); 6154 snd_hda_codec_write(codec, 0x3d, 0, AC_VERB_SET_POWER_STATE, parm); 6155 6156 } 6157 6158 /* patch for vt1812 */ 6159 static int patch_vt1812(struct hda_codec *codec) 6160 { 6161 struct via_spec *spec; 6162 int err; 6163 6164 /* create a codec specific record */ 6165 spec = via_new_spec(codec); 6166 if (spec == NULL) 6167 return -ENOMEM; 6168 6169 /* automatic parse from the BIOS config */ 6170 err = vt1812_parse_auto_config(codec); 6171 if (err < 0) { 6172 via_free(codec); 6173 return err; 6174 } else if (!err) { 6175 printk(KERN_INFO "hda_codec: Cannot set up configuration " 6176 "from BIOS. Using genenic mode...\n"); 6177 } 6178 6179 6180 spec->init_verbs[spec->num_iverbs++] = vt1812_volume_init_verbs; 6181 spec->init_verbs[spec->num_iverbs++] = vt1812_uniwill_init_verbs; 6182 6183 spec->stream_name_analog = "VT1812 Analog"; 6184 spec->stream_analog_playback = &vt1812_pcm_analog_playback; 6185 spec->stream_analog_capture = &vt1812_pcm_analog_capture; 6186 6187 spec->stream_name_digital = "VT1812 Digital"; 6188 spec->stream_digital_playback = &vt1812_pcm_digital_playback; 6189 6190 6191 if (!spec->adc_nids && spec->input_mux) { 6192 spec->adc_nids = vt1812_adc_nids; 6193 spec->num_adc_nids = ARRAY_SIZE(vt1812_adc_nids); 6194 get_mux_nids(codec); 6195 override_mic_boost(codec, 0x2b, 0, 3, 40); 6196 override_mic_boost(codec, 0x29, 0, 3, 40); 6197 spec->mixers[spec->num_mixers] = vt1812_capture_mixer; 6198 spec->num_mixers++; 6199 } 6200 6201 codec->patch_ops = via_patch_ops; 6202 6203 codec->patch_ops.init = via_auto_init; 6204 codec->patch_ops.unsol_event = via_unsol_event; 6205 6206 #ifdef CONFIG_SND_HDA_POWER_SAVE 6207 spec->loopback.amplist = vt1812_loopbacks; 6208 #endif 6209 6210 spec->set_widgets_power_state = set_widgets_power_state_vt1812; 6211 return 0; 6212 } 6213 6214 /* 6215 * patch entries 6216 */ 6217 static const struct hda_codec_preset snd_hda_preset_via[] = { 6218 { .id = 0x11061708, .name = "VT1708", .patch = patch_vt1708}, 6219 { .id = 0x11061709, .name = "VT1708", .patch = patch_vt1708}, 6220 { .id = 0x1106170a, .name = "VT1708", .patch = patch_vt1708}, 6221 { .id = 0x1106170b, .name = "VT1708", .patch = patch_vt1708}, 6222 { .id = 0x1106e710, .name = "VT1709 10-Ch", 6223 .patch = patch_vt1709_10ch}, 6224 { .id = 0x1106e711, .name = "VT1709 10-Ch", 6225 .patch = patch_vt1709_10ch}, 6226 { .id = 0x1106e712, .name = "VT1709 10-Ch", 6227 .patch = patch_vt1709_10ch}, 6228 { .id = 0x1106e713, .name = "VT1709 10-Ch", 6229 .patch = patch_vt1709_10ch}, 6230 { .id = 0x1106e714, .name = "VT1709 6-Ch", 6231 .patch = patch_vt1709_6ch}, 6232 { .id = 0x1106e715, .name = "VT1709 6-Ch", 6233 .patch = patch_vt1709_6ch}, 6234 { .id = 0x1106e716, .name = "VT1709 6-Ch", 6235 .patch = patch_vt1709_6ch}, 6236 { .id = 0x1106e717, .name = "VT1709 6-Ch", 6237 .patch = patch_vt1709_6ch}, 6238 { .id = 0x1106e720, .name = "VT1708B 8-Ch", 6239 .patch = patch_vt1708B_8ch}, 6240 { .id = 0x1106e721, .name = "VT1708B 8-Ch", 6241 .patch = patch_vt1708B_8ch}, 6242 { .id = 0x1106e722, .name = "VT1708B 8-Ch", 6243 .patch = patch_vt1708B_8ch}, 6244 { .id = 0x1106e723, .name = "VT1708B 8-Ch", 6245 .patch = patch_vt1708B_8ch}, 6246 { .id = 0x1106e724, .name = "VT1708B 4-Ch", 6247 .patch = patch_vt1708B_4ch}, 6248 { .id = 0x1106e725, .name = "VT1708B 4-Ch", 6249 .patch = patch_vt1708B_4ch}, 6250 { .id = 0x1106e726, .name = "VT1708B 4-Ch", 6251 .patch = patch_vt1708B_4ch}, 6252 { .id = 0x1106e727, .name = "VT1708B 4-Ch", 6253 .patch = patch_vt1708B_4ch}, 6254 { .id = 0x11060397, .name = "VT1708S", 6255 .patch = patch_vt1708S}, 6256 { .id = 0x11061397, .name = "VT1708S", 6257 .patch = patch_vt1708S}, 6258 { .id = 0x11062397, .name = "VT1708S", 6259 .patch = patch_vt1708S}, 6260 { .id = 0x11063397, .name = "VT1708S", 6261 .patch = patch_vt1708S}, 6262 { .id = 0x11064397, .name = "VT1705", 6263 .patch = patch_vt1708S}, 6264 { .id = 0x11065397, .name = "VT1708S", 6265 .patch = patch_vt1708S}, 6266 { .id = 0x11066397, .name = "VT1708S", 6267 .patch = patch_vt1708S}, 6268 { .id = 0x11067397, .name = "VT1708S", 6269 .patch = patch_vt1708S}, 6270 { .id = 0x11060398, .name = "VT1702", 6271 .patch = patch_vt1702}, 6272 { .id = 0x11061398, .name = "VT1702", 6273 .patch = patch_vt1702}, 6274 { .id = 0x11062398, .name = "VT1702", 6275 .patch = patch_vt1702}, 6276 { .id = 0x11063398, .name = "VT1702", 6277 .patch = patch_vt1702}, 6278 { .id = 0x11064398, .name = "VT1702", 6279 .patch = patch_vt1702}, 6280 { .id = 0x11065398, .name = "VT1702", 6281 .patch = patch_vt1702}, 6282 { .id = 0x11066398, .name = "VT1702", 6283 .patch = patch_vt1702}, 6284 { .id = 0x11067398, .name = "VT1702", 6285 .patch = patch_vt1702}, 6286 { .id = 0x11060428, .name = "VT1718S", 6287 .patch = patch_vt1718S}, 6288 { .id = 0x11064428, .name = "VT1718S", 6289 .patch = patch_vt1718S}, 6290 { .id = 0x11060441, .name = "VT2020", 6291 .patch = patch_vt1718S}, 6292 { .id = 0x11064441, .name = "VT1828S", 6293 .patch = patch_vt1718S}, 6294 { .id = 0x11060433, .name = "VT1716S", 6295 .patch = patch_vt1716S}, 6296 { .id = 0x1106a721, .name = "VT1716S", 6297 .patch = patch_vt1716S}, 6298 { .id = 0x11060438, .name = "VT2002P", .patch = patch_vt2002P}, 6299 { .id = 0x11064438, .name = "VT2002P", .patch = patch_vt2002P}, 6300 { .id = 0x11060448, .name = "VT1812", .patch = patch_vt1812}, 6301 { .id = 0x11060440, .name = "VT1818S", 6302 .patch = patch_vt1708S}, 6303 { .id = 0x11060446, .name = "VT1802", 6304 .patch = patch_vt2002P}, 6305 { .id = 0x11068446, .name = "VT1802", 6306 .patch = patch_vt2002P}, 6307 {} /* terminator */ 6308 }; 6309 6310 MODULE_ALIAS("snd-hda-codec-id:1106*"); 6311 6312 static struct hda_codec_preset_list via_list = { 6313 .preset = snd_hda_preset_via, 6314 .owner = THIS_MODULE, 6315 }; 6316 6317 MODULE_LICENSE("GPL"); 6318 MODULE_DESCRIPTION("VIA HD-audio codec"); 6319 6320 static int __init patch_via_init(void) 6321 { 6322 return snd_hda_add_codec_preset(&via_list); 6323 } 6324 6325 static void __exit patch_via_exit(void) 6326 { 6327 snd_hda_delete_codec_preset(&via_list); 6328 } 6329 6330 module_init(patch_via_init) 6331 module_exit(patch_via_exit) 6332