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 <linux/module.h> 53 #include <sound/core.h> 54 #include <sound/asoundef.h> 55 #include "hda_codec.h" 56 #include "hda_local.h" 57 #include "hda_auto_parser.h" 58 #include "hda_jack.h" 59 60 /* Pin Widget NID */ 61 #define VT1708_HP_PIN_NID 0x20 62 #define VT1708_CD_PIN_NID 0x24 63 64 enum VIA_HDA_CODEC { 65 UNKNOWN = -1, 66 VT1708, 67 VT1709_10CH, 68 VT1709_6CH, 69 VT1708B_8CH, 70 VT1708B_4CH, 71 VT1708S, 72 VT1708BCE, 73 VT1702, 74 VT1718S, 75 VT1716S, 76 VT2002P, 77 VT1812, 78 VT1802, 79 VT1705CF, 80 VT1808, 81 CODEC_TYPES, 82 }; 83 84 #define VT2002P_COMPATIBLE(spec) \ 85 ((spec)->codec_type == VT2002P ||\ 86 (spec)->codec_type == VT1812 ||\ 87 (spec)->codec_type == VT1802) 88 89 #define MAX_NID_PATH_DEPTH 5 90 91 /* output-path: DAC -> ... -> pin 92 * idx[] contains the source index number of the next widget; 93 * e.g. idx[0] is the index of the DAC selected by path[1] widget 94 * multi[] indicates whether it's a selector widget with multi-connectors 95 * (i.e. the connection selection is mandatory) 96 * vol_ctl and mute_ctl contains the NIDs for the assigned mixers 97 */ 98 struct nid_path { 99 int depth; 100 hda_nid_t path[MAX_NID_PATH_DEPTH]; 101 unsigned char idx[MAX_NID_PATH_DEPTH]; 102 unsigned char multi[MAX_NID_PATH_DEPTH]; 103 unsigned int vol_ctl; 104 unsigned int mute_ctl; 105 }; 106 107 /* input-path */ 108 struct via_input { 109 hda_nid_t pin; /* input-pin or aa-mix */ 110 int adc_idx; /* ADC index to be used */ 111 int mux_idx; /* MUX index (if any) */ 112 const char *label; /* input-source label */ 113 }; 114 115 #define VIA_MAX_ADCS 3 116 117 enum { 118 STREAM_MULTI_OUT = (1 << 0), 119 STREAM_INDEP_HP = (1 << 1), 120 }; 121 122 struct via_spec { 123 struct hda_gen_spec gen; 124 125 /* codec parameterization */ 126 const struct snd_kcontrol_new *mixers[6]; 127 unsigned int num_mixers; 128 129 const struct hda_verb *init_verbs[5]; 130 unsigned int num_iverbs; 131 132 char stream_name_analog[32]; 133 char stream_name_hp[32]; 134 const struct hda_pcm_stream *stream_analog_playback; 135 const struct hda_pcm_stream *stream_analog_capture; 136 137 char stream_name_digital[32]; 138 const struct hda_pcm_stream *stream_digital_playback; 139 const struct hda_pcm_stream *stream_digital_capture; 140 141 /* playback */ 142 struct hda_multi_out multiout; 143 hda_nid_t slave_dig_outs[2]; 144 hda_nid_t hp_dac_nid; 145 hda_nid_t speaker_dac_nid; 146 int hp_indep_shared; /* indep HP-DAC is shared with side ch */ 147 int opened_streams; /* STREAM_* bits */ 148 int active_streams; /* STREAM_* bits */ 149 int aamix_mode; /* loopback is enabled for output-path? */ 150 151 /* Output-paths: 152 * There are different output-paths depending on the setup. 153 * out_path, hp_path and speaker_path are primary paths. If both 154 * direct DAC and aa-loopback routes are available, these contain 155 * the former paths. Meanwhile *_mix_path contain the paths with 156 * loopback mixer. (Since the loopback is only for front channel, 157 * no out_mix_path for surround channels.) 158 * The HP output has another path, hp_indep_path, which is used in 159 * the independent-HP mode. 160 */ 161 struct nid_path out_path[HDA_SIDE + 1]; 162 struct nid_path out_mix_path; 163 struct nid_path hp_path; 164 struct nid_path hp_mix_path; 165 struct nid_path hp_indep_path; 166 struct nid_path speaker_path; 167 struct nid_path speaker_mix_path; 168 169 /* capture */ 170 unsigned int num_adc_nids; 171 hda_nid_t adc_nids[VIA_MAX_ADCS]; 172 hda_nid_t mux_nids[VIA_MAX_ADCS]; 173 hda_nid_t aa_mix_nid; 174 hda_nid_t dig_in_nid; 175 176 /* capture source */ 177 bool dyn_adc_switch; 178 int num_inputs; 179 struct via_input inputs[AUTO_CFG_MAX_INS + 1]; 180 unsigned int cur_mux[VIA_MAX_ADCS]; 181 182 /* dynamic DAC switching */ 183 unsigned int cur_dac_stream_tag; 184 unsigned int cur_dac_format; 185 unsigned int cur_hp_stream_tag; 186 unsigned int cur_hp_format; 187 188 /* dynamic ADC switching */ 189 hda_nid_t cur_adc; 190 unsigned int cur_adc_stream_tag; 191 unsigned int cur_adc_format; 192 193 /* PCM information */ 194 struct hda_pcm pcm_rec[3]; 195 196 /* dynamic controls, init_verbs and input_mux */ 197 struct auto_pin_cfg autocfg; 198 struct snd_array kctls; 199 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS]; 200 201 /* HP mode source */ 202 unsigned int hp_independent_mode; 203 unsigned int dmic_enabled; 204 unsigned int no_pin_power_ctl; 205 enum VIA_HDA_CODEC codec_type; 206 207 /* analog low-power control */ 208 bool alc_mode; 209 210 /* smart51 setup */ 211 unsigned int smart51_nums; 212 hda_nid_t smart51_pins[2]; 213 int smart51_idxs[2]; 214 const char *smart51_labels[2]; 215 unsigned int smart51_enabled; 216 217 /* work to check hp jack state */ 218 struct hda_codec *codec; 219 struct delayed_work vt1708_hp_work; 220 int hp_work_active; 221 int vt1708_jack_detect; 222 int vt1708_hp_present; 223 224 void (*set_widgets_power_state)(struct hda_codec *codec); 225 unsigned int dac_stream_tag[4]; 226 227 struct hda_loopback_check loopback; 228 int num_loopbacks; 229 struct hda_amp_list loopback_list[8]; 230 231 /* bind capture-volume */ 232 struct hda_bind_ctls *bind_cap_vol; 233 struct hda_bind_ctls *bind_cap_sw; 234 235 struct mutex config_mutex; 236 }; 237 238 static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec); 239 static struct via_spec * via_new_spec(struct hda_codec *codec) 240 { 241 struct via_spec *spec; 242 243 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 244 if (spec == NULL) 245 return NULL; 246 247 snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32); 248 mutex_init(&spec->config_mutex); 249 codec->spec = spec; 250 spec->codec = codec; 251 spec->codec_type = get_codec_type(codec); 252 /* VT1708BCE & VT1708S are almost same */ 253 if (spec->codec_type == VT1708BCE) 254 spec->codec_type = VT1708S; 255 snd_hda_gen_init(&spec->gen); 256 return spec; 257 } 258 259 static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec) 260 { 261 u32 vendor_id = codec->vendor_id; 262 u16 ven_id = vendor_id >> 16; 263 u16 dev_id = vendor_id & 0xffff; 264 enum VIA_HDA_CODEC codec_type; 265 266 /* get codec type */ 267 if (ven_id != 0x1106) 268 codec_type = UNKNOWN; 269 else if (dev_id >= 0x1708 && dev_id <= 0x170b) 270 codec_type = VT1708; 271 else if (dev_id >= 0xe710 && dev_id <= 0xe713) 272 codec_type = VT1709_10CH; 273 else if (dev_id >= 0xe714 && dev_id <= 0xe717) 274 codec_type = VT1709_6CH; 275 else if (dev_id >= 0xe720 && dev_id <= 0xe723) { 276 codec_type = VT1708B_8CH; 277 if (snd_hda_param_read(codec, 0x16, AC_PAR_CONNLIST_LEN) == 0x7) 278 codec_type = VT1708BCE; 279 } else if (dev_id >= 0xe724 && dev_id <= 0xe727) 280 codec_type = VT1708B_4CH; 281 else if ((dev_id & 0xfff) == 0x397 282 && (dev_id >> 12) < 8) 283 codec_type = VT1708S; 284 else if ((dev_id & 0xfff) == 0x398 285 && (dev_id >> 12) < 8) 286 codec_type = VT1702; 287 else if ((dev_id & 0xfff) == 0x428 288 && (dev_id >> 12) < 8) 289 codec_type = VT1718S; 290 else if (dev_id == 0x0433 || dev_id == 0xa721) 291 codec_type = VT1716S; 292 else if (dev_id == 0x0441 || dev_id == 0x4441) 293 codec_type = VT1718S; 294 else if (dev_id == 0x0438 || dev_id == 0x4438) 295 codec_type = VT2002P; 296 else if (dev_id == 0x0448) 297 codec_type = VT1812; 298 else if (dev_id == 0x0440) 299 codec_type = VT1708S; 300 else if ((dev_id & 0xfff) == 0x446) 301 codec_type = VT1802; 302 else if (dev_id == 0x4760) 303 codec_type = VT1705CF; 304 else if (dev_id == 0x4761 || dev_id == 0x4762) 305 codec_type = VT1808; 306 else 307 codec_type = UNKNOWN; 308 return codec_type; 309 }; 310 311 #define VIA_JACK_EVENT 0x20 312 #define VIA_HP_EVENT 0x01 313 #define VIA_LINE_EVENT 0x03 314 315 enum { 316 VIA_CTL_WIDGET_VOL, 317 VIA_CTL_WIDGET_MUTE, 318 VIA_CTL_WIDGET_ANALOG_MUTE, 319 }; 320 321 static void analog_low_current_mode(struct hda_codec *codec); 322 static bool is_aa_path_mute(struct hda_codec *codec); 323 324 #define hp_detect_with_aa(codec) \ 325 (snd_hda_get_bool_hint(codec, "analog_loopback_hp_detect") == 1 && \ 326 !is_aa_path_mute(codec)) 327 328 static void vt1708_stop_hp_work(struct via_spec *spec) 329 { 330 if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0) 331 return; 332 if (spec->hp_work_active) { 333 snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81, 1); 334 cancel_delayed_work_sync(&spec->vt1708_hp_work); 335 spec->hp_work_active = 0; 336 } 337 } 338 339 static void vt1708_update_hp_work(struct via_spec *spec) 340 { 341 if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0) 342 return; 343 if (spec->vt1708_jack_detect && 344 (spec->active_streams || hp_detect_with_aa(spec->codec))) { 345 if (!spec->hp_work_active) { 346 snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81, 0); 347 schedule_delayed_work(&spec->vt1708_hp_work, 348 msecs_to_jiffies(100)); 349 spec->hp_work_active = 1; 350 } 351 } else if (!hp_detect_with_aa(spec->codec)) 352 vt1708_stop_hp_work(spec); 353 } 354 355 static void set_widgets_power_state(struct hda_codec *codec) 356 { 357 struct via_spec *spec = codec->spec; 358 if (spec->set_widgets_power_state) 359 spec->set_widgets_power_state(codec); 360 } 361 362 static int analog_input_switch_put(struct snd_kcontrol *kcontrol, 363 struct snd_ctl_elem_value *ucontrol) 364 { 365 int change = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); 366 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 367 368 set_widgets_power_state(codec); 369 analog_low_current_mode(snd_kcontrol_chip(kcontrol)); 370 vt1708_update_hp_work(codec->spec); 371 return change; 372 } 373 374 /* modify .put = snd_hda_mixer_amp_switch_put */ 375 #define ANALOG_INPUT_MUTE \ 376 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 377 .name = NULL, \ 378 .index = 0, \ 379 .info = snd_hda_mixer_amp_switch_info, \ 380 .get = snd_hda_mixer_amp_switch_get, \ 381 .put = analog_input_switch_put, \ 382 .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0) } 383 384 static const struct snd_kcontrol_new via_control_templates[] = { 385 HDA_CODEC_VOLUME(NULL, 0, 0, 0), 386 HDA_CODEC_MUTE(NULL, 0, 0, 0), 387 ANALOG_INPUT_MUTE, 388 }; 389 390 391 /* add dynamic controls */ 392 static struct snd_kcontrol_new *__via_clone_ctl(struct via_spec *spec, 393 const struct snd_kcontrol_new *tmpl, 394 const char *name) 395 { 396 struct snd_kcontrol_new *knew; 397 398 knew = snd_array_new(&spec->kctls); 399 if (!knew) 400 return NULL; 401 *knew = *tmpl; 402 if (!name) 403 name = tmpl->name; 404 if (name) { 405 knew->name = kstrdup(name, GFP_KERNEL); 406 if (!knew->name) 407 return NULL; 408 } 409 return knew; 410 } 411 412 static int __via_add_control(struct via_spec *spec, int type, const char *name, 413 int idx, unsigned long val) 414 { 415 struct snd_kcontrol_new *knew; 416 417 knew = __via_clone_ctl(spec, &via_control_templates[type], name); 418 if (!knew) 419 return -ENOMEM; 420 knew->index = idx; 421 if (get_amp_nid_(val)) 422 knew->subdevice = HDA_SUBDEV_AMP_FLAG; 423 knew->private_value = val; 424 return 0; 425 } 426 427 #define via_add_control(spec, type, name, val) \ 428 __via_add_control(spec, type, name, 0, val) 429 430 #define via_clone_control(spec, tmpl) __via_clone_ctl(spec, tmpl, NULL) 431 432 static void via_free_kctls(struct hda_codec *codec) 433 { 434 struct via_spec *spec = codec->spec; 435 436 if (spec->kctls.list) { 437 struct snd_kcontrol_new *kctl = spec->kctls.list; 438 int i; 439 for (i = 0; i < spec->kctls.used; i++) 440 kfree(kctl[i].name); 441 } 442 snd_array_free(&spec->kctls); 443 } 444 445 /* create input playback/capture controls for the given pin */ 446 static int via_new_analog_input(struct via_spec *spec, const char *ctlname, 447 int type_idx, int idx, int mix_nid) 448 { 449 char name[32]; 450 int err; 451 452 sprintf(name, "%s Playback Volume", ctlname); 453 err = __via_add_control(spec, VIA_CTL_WIDGET_VOL, name, type_idx, 454 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); 455 if (err < 0) 456 return err; 457 sprintf(name, "%s Playback Switch", ctlname); 458 err = __via_add_control(spec, VIA_CTL_WIDGET_ANALOG_MUTE, name, type_idx, 459 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); 460 if (err < 0) 461 return err; 462 return 0; 463 } 464 465 #define get_connection_index(codec, mux, nid) \ 466 snd_hda_get_conn_index(codec, mux, nid, 0) 467 468 static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir, 469 unsigned int mask) 470 { 471 unsigned int caps; 472 if (!nid) 473 return false; 474 caps = get_wcaps(codec, nid); 475 if (dir == HDA_INPUT) 476 caps &= AC_WCAP_IN_AMP; 477 else 478 caps &= AC_WCAP_OUT_AMP; 479 if (!caps) 480 return false; 481 if (query_amp_caps(codec, nid, dir) & mask) 482 return true; 483 return false; 484 } 485 486 #define have_mute(codec, nid, dir) \ 487 check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE) 488 489 /* enable/disable the output-route mixers */ 490 static void activate_output_mix(struct hda_codec *codec, struct nid_path *path, 491 hda_nid_t mix_nid, int idx, bool enable) 492 { 493 int i, num, val; 494 495 if (!path) 496 return; 497 num = snd_hda_get_num_conns(codec, mix_nid); 498 for (i = 0; i < num; i++) { 499 if (i == idx) 500 val = AMP_IN_UNMUTE(i); 501 else 502 val = AMP_IN_MUTE(i); 503 snd_hda_codec_write(codec, mix_nid, 0, 504 AC_VERB_SET_AMP_GAIN_MUTE, val); 505 } 506 } 507 508 /* enable/disable the output-route */ 509 static void activate_output_path(struct hda_codec *codec, struct nid_path *path, 510 bool enable, bool force) 511 { 512 struct via_spec *spec = codec->spec; 513 int i; 514 for (i = 0; i < path->depth; i++) { 515 hda_nid_t src, dst; 516 int idx = path->idx[i]; 517 src = path->path[i]; 518 if (i < path->depth - 1) 519 dst = path->path[i + 1]; 520 else 521 dst = 0; 522 if (enable && path->multi[i]) 523 snd_hda_codec_write(codec, dst, 0, 524 AC_VERB_SET_CONNECT_SEL, idx); 525 if (!force && (dst == spec->aa_mix_nid)) 526 continue; 527 if (have_mute(codec, dst, HDA_INPUT)) 528 activate_output_mix(codec, path, dst, idx, enable); 529 if (!force && (src == path->vol_ctl || src == path->mute_ctl)) 530 continue; 531 if (have_mute(codec, src, HDA_OUTPUT)) { 532 int val = enable ? AMP_OUT_UNMUTE : AMP_OUT_MUTE; 533 snd_hda_codec_write(codec, src, 0, 534 AC_VERB_SET_AMP_GAIN_MUTE, val); 535 } 536 } 537 } 538 539 /* set the given pin as output */ 540 static void init_output_pin(struct hda_codec *codec, hda_nid_t pin, 541 int pin_type) 542 { 543 if (!pin) 544 return; 545 snd_hda_set_pin_ctl(codec, pin, pin_type); 546 if (snd_hda_query_pin_caps(codec, pin) & AC_PINCAP_EAPD) 547 snd_hda_codec_write(codec, pin, 0, 548 AC_VERB_SET_EAPD_BTLENABLE, 0x02); 549 } 550 551 static void via_auto_init_output(struct hda_codec *codec, 552 struct nid_path *path, int pin_type) 553 { 554 unsigned int caps; 555 hda_nid_t pin; 556 557 if (!path->depth) 558 return; 559 pin = path->path[path->depth - 1]; 560 561 init_output_pin(codec, pin, pin_type); 562 if (get_wcaps(codec, pin) & AC_WCAP_OUT_AMP) 563 caps = query_amp_caps(codec, pin, HDA_OUTPUT); 564 else 565 caps = 0; 566 if (caps & AC_AMPCAP_MUTE) { 567 unsigned int val; 568 val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT; 569 snd_hda_codec_write(codec, pin, 0, AC_VERB_SET_AMP_GAIN_MUTE, 570 AMP_OUT_MUTE | val); 571 } 572 activate_output_path(codec, path, true, true); /* force on */ 573 } 574 575 static void via_auto_init_multi_out(struct hda_codec *codec) 576 { 577 struct via_spec *spec = codec->spec; 578 struct nid_path *path; 579 int i; 580 581 for (i = 0; i < spec->autocfg.line_outs + spec->smart51_nums; i++) { 582 path = &spec->out_path[i]; 583 if (!i && spec->aamix_mode && spec->out_mix_path.depth) 584 path = &spec->out_mix_path; 585 via_auto_init_output(codec, path, PIN_OUT); 586 } 587 } 588 589 /* deactivate the inactive headphone-paths */ 590 static void deactivate_hp_paths(struct hda_codec *codec) 591 { 592 struct via_spec *spec = codec->spec; 593 int shared = spec->hp_indep_shared; 594 595 if (spec->hp_independent_mode) { 596 activate_output_path(codec, &spec->hp_path, false, false); 597 activate_output_path(codec, &spec->hp_mix_path, false, false); 598 if (shared) 599 activate_output_path(codec, &spec->out_path[shared], 600 false, false); 601 } else if (spec->aamix_mode || !spec->hp_path.depth) { 602 activate_output_path(codec, &spec->hp_indep_path, false, false); 603 activate_output_path(codec, &spec->hp_path, false, false); 604 } else { 605 activate_output_path(codec, &spec->hp_indep_path, false, false); 606 activate_output_path(codec, &spec->hp_mix_path, false, false); 607 } 608 } 609 610 static void via_auto_init_hp_out(struct hda_codec *codec) 611 { 612 struct via_spec *spec = codec->spec; 613 614 if (!spec->hp_path.depth) { 615 via_auto_init_output(codec, &spec->hp_mix_path, PIN_HP); 616 return; 617 } 618 deactivate_hp_paths(codec); 619 if (spec->hp_independent_mode) 620 via_auto_init_output(codec, &spec->hp_indep_path, PIN_HP); 621 else if (spec->aamix_mode) 622 via_auto_init_output(codec, &spec->hp_mix_path, PIN_HP); 623 else 624 via_auto_init_output(codec, &spec->hp_path, PIN_HP); 625 } 626 627 static void via_auto_init_speaker_out(struct hda_codec *codec) 628 { 629 struct via_spec *spec = codec->spec; 630 631 if (!spec->autocfg.speaker_outs) 632 return; 633 if (!spec->speaker_path.depth) { 634 via_auto_init_output(codec, &spec->speaker_mix_path, PIN_OUT); 635 return; 636 } 637 if (!spec->aamix_mode) { 638 activate_output_path(codec, &spec->speaker_mix_path, 639 false, false); 640 via_auto_init_output(codec, &spec->speaker_path, PIN_OUT); 641 } else { 642 activate_output_path(codec, &spec->speaker_path, false, false); 643 via_auto_init_output(codec, &spec->speaker_mix_path, PIN_OUT); 644 } 645 } 646 647 static bool is_smart51_pins(struct hda_codec *codec, hda_nid_t pin); 648 static void via_hp_automute(struct hda_codec *codec); 649 650 static void via_auto_init_analog_input(struct hda_codec *codec) 651 { 652 struct via_spec *spec = codec->spec; 653 const struct auto_pin_cfg *cfg = &spec->autocfg; 654 hda_nid_t conn[HDA_MAX_CONNECTIONS]; 655 unsigned int ctl; 656 int i, num_conns; 657 658 /* init ADCs */ 659 for (i = 0; i < spec->num_adc_nids; i++) { 660 hda_nid_t nid = spec->adc_nids[i]; 661 if (!(get_wcaps(codec, nid) & AC_WCAP_IN_AMP) || 662 !(query_amp_caps(codec, nid, HDA_INPUT) & AC_AMPCAP_MUTE)) 663 continue; 664 snd_hda_codec_write(codec, spec->adc_nids[i], 0, 665 AC_VERB_SET_AMP_GAIN_MUTE, 666 AMP_IN_UNMUTE(0)); 667 } 668 669 /* init pins */ 670 for (i = 0; i < cfg->num_inputs; i++) { 671 hda_nid_t nid = cfg->inputs[i].pin; 672 if (spec->smart51_enabled && is_smart51_pins(codec, nid)) 673 ctl = PIN_OUT; 674 else { 675 ctl = PIN_IN; 676 if (cfg->inputs[i].type == AUTO_PIN_MIC) 677 ctl |= snd_hda_get_default_vref(codec, nid); 678 } 679 snd_hda_set_pin_ctl(codec, nid, ctl); 680 } 681 682 /* init input-src */ 683 for (i = 0; i < spec->num_adc_nids; i++) { 684 int adc_idx = spec->inputs[spec->cur_mux[i]].adc_idx; 685 /* secondary ADCs must have the unique MUX */ 686 if (i > 0 && !spec->mux_nids[i]) 687 break; 688 if (spec->mux_nids[adc_idx]) { 689 int mux_idx = spec->inputs[spec->cur_mux[i]].mux_idx; 690 snd_hda_codec_write(codec, spec->mux_nids[adc_idx], 0, 691 AC_VERB_SET_CONNECT_SEL, 692 mux_idx); 693 } 694 if (spec->dyn_adc_switch) 695 break; /* only one input-src */ 696 } 697 698 /* init aa-mixer */ 699 if (!spec->aa_mix_nid) 700 return; 701 num_conns = snd_hda_get_connections(codec, spec->aa_mix_nid, conn, 702 ARRAY_SIZE(conn)); 703 for (i = 0; i < num_conns; i++) { 704 unsigned int caps = get_wcaps(codec, conn[i]); 705 if (get_wcaps_type(caps) == AC_WID_PIN) 706 snd_hda_codec_write(codec, spec->aa_mix_nid, 0, 707 AC_VERB_SET_AMP_GAIN_MUTE, 708 AMP_IN_MUTE(i)); 709 } 710 } 711 712 static void update_power_state(struct hda_codec *codec, hda_nid_t nid, 713 unsigned int parm) 714 { 715 if (snd_hda_codec_read(codec, nid, 0, 716 AC_VERB_GET_POWER_STATE, 0) == parm) 717 return; 718 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE, parm); 719 } 720 721 static void update_conv_power_state(struct hda_codec *codec, hda_nid_t nid, 722 unsigned int parm, unsigned int index) 723 { 724 struct via_spec *spec = codec->spec; 725 unsigned int format; 726 if (snd_hda_codec_read(codec, nid, 0, 727 AC_VERB_GET_POWER_STATE, 0) == parm) 728 return; 729 format = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0); 730 if (format && (spec->dac_stream_tag[index] != format)) 731 spec->dac_stream_tag[index] = format; 732 733 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE, parm); 734 if (parm == AC_PWRST_D0) { 735 format = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0); 736 if (!format && (spec->dac_stream_tag[index] != format)) 737 snd_hda_codec_write(codec, nid, 0, 738 AC_VERB_SET_CHANNEL_STREAMID, 739 spec->dac_stream_tag[index]); 740 } 741 } 742 743 static void set_pin_power_state(struct hda_codec *codec, hda_nid_t nid, 744 unsigned int *affected_parm) 745 { 746 unsigned parm; 747 unsigned def_conf = snd_hda_codec_get_pincfg(codec, nid); 748 unsigned no_presence = (def_conf & AC_DEFCFG_MISC) 749 >> AC_DEFCFG_MISC_SHIFT 750 & AC_DEFCFG_MISC_NO_PRESENCE; /* do not support pin sense */ 751 struct via_spec *spec = codec->spec; 752 unsigned present = 0; 753 754 no_presence |= spec->no_pin_power_ctl; 755 if (!no_presence) 756 present = snd_hda_jack_detect(codec, nid); 757 if ((spec->smart51_enabled && is_smart51_pins(codec, nid)) 758 || ((no_presence || present) 759 && get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)) { 760 *affected_parm = AC_PWRST_D0; /* if it's connected */ 761 parm = AC_PWRST_D0; 762 } else 763 parm = AC_PWRST_D3; 764 765 update_power_state(codec, nid, parm); 766 } 767 768 static int via_pin_power_ctl_info(struct snd_kcontrol *kcontrol, 769 struct snd_ctl_elem_info *uinfo) 770 { 771 return snd_hda_enum_bool_helper_info(kcontrol, uinfo); 772 } 773 774 static int via_pin_power_ctl_get(struct snd_kcontrol *kcontrol, 775 struct snd_ctl_elem_value *ucontrol) 776 { 777 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 778 struct via_spec *spec = codec->spec; 779 ucontrol->value.enumerated.item[0] = !spec->no_pin_power_ctl; 780 return 0; 781 } 782 783 static int via_pin_power_ctl_put(struct snd_kcontrol *kcontrol, 784 struct snd_ctl_elem_value *ucontrol) 785 { 786 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 787 struct via_spec *spec = codec->spec; 788 unsigned int val = !ucontrol->value.enumerated.item[0]; 789 790 if (val == spec->no_pin_power_ctl) 791 return 0; 792 spec->no_pin_power_ctl = val; 793 set_widgets_power_state(codec); 794 analog_low_current_mode(codec); 795 return 1; 796 } 797 798 static const struct snd_kcontrol_new via_pin_power_ctl_enum = { 799 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 800 .name = "Dynamic Power-Control", 801 .info = via_pin_power_ctl_info, 802 .get = via_pin_power_ctl_get, 803 .put = via_pin_power_ctl_put, 804 }; 805 806 807 static int via_independent_hp_info(struct snd_kcontrol *kcontrol, 808 struct snd_ctl_elem_info *uinfo) 809 { 810 static const char * const texts[] = { "OFF", "ON" }; 811 812 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 813 uinfo->count = 1; 814 uinfo->value.enumerated.items = 2; 815 if (uinfo->value.enumerated.item >= 2) 816 uinfo->value.enumerated.item = 1; 817 strcpy(uinfo->value.enumerated.name, 818 texts[uinfo->value.enumerated.item]); 819 return 0; 820 } 821 822 static int via_independent_hp_get(struct snd_kcontrol *kcontrol, 823 struct snd_ctl_elem_value *ucontrol) 824 { 825 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 826 struct via_spec *spec = codec->spec; 827 828 ucontrol->value.enumerated.item[0] = spec->hp_independent_mode; 829 return 0; 830 } 831 832 /* adjust spec->multiout setup according to the current flags */ 833 static void setup_playback_multi_pcm(struct via_spec *spec) 834 { 835 const struct auto_pin_cfg *cfg = &spec->autocfg; 836 spec->multiout.num_dacs = cfg->line_outs + spec->smart51_nums; 837 spec->multiout.hp_nid = 0; 838 if (!spec->hp_independent_mode) { 839 if (!spec->hp_indep_shared) 840 spec->multiout.hp_nid = spec->hp_dac_nid; 841 } else { 842 if (spec->hp_indep_shared) 843 spec->multiout.num_dacs = cfg->line_outs - 1; 844 } 845 } 846 847 /* update DAC setups according to indep-HP switch; 848 * this function is called only when indep-HP is modified 849 */ 850 static void switch_indep_hp_dacs(struct hda_codec *codec) 851 { 852 struct via_spec *spec = codec->spec; 853 int shared = spec->hp_indep_shared; 854 hda_nid_t shared_dac, hp_dac; 855 856 if (!spec->opened_streams) 857 return; 858 859 shared_dac = shared ? spec->multiout.dac_nids[shared] : 0; 860 hp_dac = spec->hp_dac_nid; 861 if (spec->hp_independent_mode) { 862 /* switch to indep-HP mode */ 863 if (spec->active_streams & STREAM_MULTI_OUT) { 864 __snd_hda_codec_cleanup_stream(codec, hp_dac, 1); 865 __snd_hda_codec_cleanup_stream(codec, shared_dac, 1); 866 } 867 if (spec->active_streams & STREAM_INDEP_HP) 868 snd_hda_codec_setup_stream(codec, hp_dac, 869 spec->cur_hp_stream_tag, 0, 870 spec->cur_hp_format); 871 } else { 872 /* back to HP or shared-DAC */ 873 if (spec->active_streams & STREAM_INDEP_HP) 874 __snd_hda_codec_cleanup_stream(codec, hp_dac, 1); 875 if (spec->active_streams & STREAM_MULTI_OUT) { 876 hda_nid_t dac; 877 int ch; 878 if (shared_dac) { /* reset mutli-ch DAC */ 879 dac = shared_dac; 880 ch = shared * 2; 881 } else { /* reset HP DAC */ 882 dac = hp_dac; 883 ch = 0; 884 } 885 snd_hda_codec_setup_stream(codec, dac, 886 spec->cur_dac_stream_tag, ch, 887 spec->cur_dac_format); 888 } 889 } 890 setup_playback_multi_pcm(spec); 891 } 892 893 static int via_independent_hp_put(struct snd_kcontrol *kcontrol, 894 struct snd_ctl_elem_value *ucontrol) 895 { 896 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 897 struct via_spec *spec = codec->spec; 898 int cur, shared; 899 900 mutex_lock(&spec->config_mutex); 901 cur = !!ucontrol->value.enumerated.item[0]; 902 if (spec->hp_independent_mode == cur) { 903 mutex_unlock(&spec->config_mutex); 904 return 0; 905 } 906 spec->hp_independent_mode = cur; 907 shared = spec->hp_indep_shared; 908 deactivate_hp_paths(codec); 909 if (cur) 910 activate_output_path(codec, &spec->hp_indep_path, true, false); 911 else { 912 if (shared) 913 activate_output_path(codec, &spec->out_path[shared], 914 true, false); 915 if (spec->aamix_mode || !spec->hp_path.depth) 916 activate_output_path(codec, &spec->hp_mix_path, 917 true, false); 918 else 919 activate_output_path(codec, &spec->hp_path, 920 true, false); 921 } 922 923 switch_indep_hp_dacs(codec); 924 mutex_unlock(&spec->config_mutex); 925 926 /* update jack power state */ 927 set_widgets_power_state(codec); 928 via_hp_automute(codec); 929 return 1; 930 } 931 932 static const struct snd_kcontrol_new via_hp_mixer = { 933 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 934 .name = "Independent HP", 935 .info = via_independent_hp_info, 936 .get = via_independent_hp_get, 937 .put = via_independent_hp_put, 938 }; 939 940 static int via_hp_build(struct hda_codec *codec) 941 { 942 struct via_spec *spec = codec->spec; 943 struct snd_kcontrol_new *knew; 944 hda_nid_t nid; 945 946 nid = spec->autocfg.hp_pins[0]; 947 knew = via_clone_control(spec, &via_hp_mixer); 948 if (knew == NULL) 949 return -ENOMEM; 950 951 knew->subdevice = HDA_SUBDEV_NID_FLAG | nid; 952 953 return 0; 954 } 955 956 static void notify_aa_path_ctls(struct hda_codec *codec) 957 { 958 struct via_spec *spec = codec->spec; 959 int i; 960 961 for (i = 0; i < spec->smart51_nums; i++) { 962 struct snd_kcontrol *ctl; 963 struct snd_ctl_elem_id id; 964 memset(&id, 0, sizeof(id)); 965 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 966 sprintf(id.name, "%s Playback Volume", spec->smart51_labels[i]); 967 ctl = snd_hda_find_mixer_ctl(codec, id.name); 968 if (ctl) 969 snd_ctl_notify(codec->bus->card, 970 SNDRV_CTL_EVENT_MASK_VALUE, 971 &ctl->id); 972 } 973 } 974 975 static void mute_aa_path(struct hda_codec *codec, int mute) 976 { 977 struct via_spec *spec = codec->spec; 978 int val = mute ? HDA_AMP_MUTE : HDA_AMP_UNMUTE; 979 int i; 980 981 /* check AA path's mute status */ 982 for (i = 0; i < spec->smart51_nums; i++) { 983 if (spec->smart51_idxs[i] < 0) 984 continue; 985 snd_hda_codec_amp_stereo(codec, spec->aa_mix_nid, 986 HDA_INPUT, spec->smart51_idxs[i], 987 HDA_AMP_MUTE, val); 988 } 989 } 990 991 static bool is_smart51_pins(struct hda_codec *codec, hda_nid_t pin) 992 { 993 struct via_spec *spec = codec->spec; 994 int i; 995 996 for (i = 0; i < spec->smart51_nums; i++) 997 if (spec->smart51_pins[i] == pin) 998 return true; 999 return false; 1000 } 1001 1002 static int via_smart51_get(struct snd_kcontrol *kcontrol, 1003 struct snd_ctl_elem_value *ucontrol) 1004 { 1005 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1006 struct via_spec *spec = codec->spec; 1007 1008 *ucontrol->value.integer.value = spec->smart51_enabled; 1009 return 0; 1010 } 1011 1012 static int via_smart51_put(struct snd_kcontrol *kcontrol, 1013 struct snd_ctl_elem_value *ucontrol) 1014 { 1015 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1016 struct via_spec *spec = codec->spec; 1017 int out_in = *ucontrol->value.integer.value 1018 ? AC_PINCTL_OUT_EN : AC_PINCTL_IN_EN; 1019 int i; 1020 1021 for (i = 0; i < spec->smart51_nums; i++) { 1022 hda_nid_t nid = spec->smart51_pins[i]; 1023 unsigned int parm; 1024 1025 parm = snd_hda_codec_read(codec, nid, 0, 1026 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 1027 parm &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN); 1028 parm |= out_in; 1029 snd_hda_set_pin_ctl(codec, nid, parm); 1030 if (out_in == AC_PINCTL_OUT_EN) { 1031 mute_aa_path(codec, 1); 1032 notify_aa_path_ctls(codec); 1033 } 1034 } 1035 spec->smart51_enabled = *ucontrol->value.integer.value; 1036 set_widgets_power_state(codec); 1037 return 1; 1038 } 1039 1040 static const struct snd_kcontrol_new via_smart51_mixer = { 1041 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1042 .name = "Smart 5.1", 1043 .count = 1, 1044 .info = snd_ctl_boolean_mono_info, 1045 .get = via_smart51_get, 1046 .put = via_smart51_put, 1047 }; 1048 1049 static int via_smart51_build(struct hda_codec *codec) 1050 { 1051 struct via_spec *spec = codec->spec; 1052 1053 if (!spec->smart51_nums) 1054 return 0; 1055 if (!via_clone_control(spec, &via_smart51_mixer)) 1056 return -ENOMEM; 1057 return 0; 1058 } 1059 1060 /* check AA path's mute status */ 1061 static bool is_aa_path_mute(struct hda_codec *codec) 1062 { 1063 struct via_spec *spec = codec->spec; 1064 const struct hda_amp_list *p; 1065 int i, ch, v; 1066 1067 for (i = 0; i < spec->num_loopbacks; i++) { 1068 p = &spec->loopback_list[i]; 1069 for (ch = 0; ch < 2; ch++) { 1070 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir, 1071 p->idx); 1072 if (!(v & HDA_AMP_MUTE) && v > 0) 1073 return false; 1074 } 1075 } 1076 return true; 1077 } 1078 1079 /* enter/exit analog low-current mode */ 1080 static void __analog_low_current_mode(struct hda_codec *codec, bool force) 1081 { 1082 struct via_spec *spec = codec->spec; 1083 bool enable; 1084 unsigned int verb, parm; 1085 1086 if (spec->no_pin_power_ctl) 1087 enable = false; 1088 else 1089 enable = is_aa_path_mute(codec) && !spec->opened_streams; 1090 if (enable == spec->alc_mode && !force) 1091 return; 1092 spec->alc_mode = enable; 1093 1094 /* decide low current mode's verb & parameter */ 1095 switch (spec->codec_type) { 1096 case VT1708B_8CH: 1097 case VT1708B_4CH: 1098 verb = 0xf70; 1099 parm = enable ? 0x02 : 0x00; /* 0x02: 2/3x, 0x00: 1x */ 1100 break; 1101 case VT1708S: 1102 case VT1718S: 1103 case VT1716S: 1104 verb = 0xf73; 1105 parm = enable ? 0x51 : 0xe1; /* 0x51: 4/28x, 0xe1: 1x */ 1106 break; 1107 case VT1702: 1108 verb = 0xf73; 1109 parm = enable ? 0x01 : 0x1d; /* 0x01: 4/40x, 0x1d: 1x */ 1110 break; 1111 case VT2002P: 1112 case VT1812: 1113 case VT1802: 1114 verb = 0xf93; 1115 parm = enable ? 0x00 : 0xe0; /* 0x00: 4/40x, 0xe0: 1x */ 1116 break; 1117 case VT1705CF: 1118 case VT1808: 1119 verb = 0xf82; 1120 parm = enable ? 0x00 : 0xe0; /* 0x00: 4/40x, 0xe0: 1x */ 1121 break; 1122 default: 1123 return; /* other codecs are not supported */ 1124 } 1125 /* send verb */ 1126 snd_hda_codec_write(codec, codec->afg, 0, verb, parm); 1127 } 1128 1129 static void analog_low_current_mode(struct hda_codec *codec) 1130 { 1131 return __analog_low_current_mode(codec, false); 1132 } 1133 1134 /* 1135 * generic initialization of ADC, input mixers and output mixers 1136 */ 1137 static const struct hda_verb vt1708_init_verbs[] = { 1138 /* power down jack detect function */ 1139 {0x1, 0xf81, 0x1}, 1140 { } 1141 }; 1142 1143 static void set_stream_open(struct hda_codec *codec, int bit, bool active) 1144 { 1145 struct via_spec *spec = codec->spec; 1146 1147 if (active) 1148 spec->opened_streams |= bit; 1149 else 1150 spec->opened_streams &= ~bit; 1151 analog_low_current_mode(codec); 1152 } 1153 1154 static int via_playback_multi_pcm_open(struct hda_pcm_stream *hinfo, 1155 struct hda_codec *codec, 1156 struct snd_pcm_substream *substream) 1157 { 1158 struct via_spec *spec = codec->spec; 1159 const struct auto_pin_cfg *cfg = &spec->autocfg; 1160 int err; 1161 1162 spec->multiout.num_dacs = cfg->line_outs + spec->smart51_nums; 1163 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 1164 set_stream_open(codec, STREAM_MULTI_OUT, true); 1165 err = snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, 1166 hinfo); 1167 if (err < 0) { 1168 set_stream_open(codec, STREAM_MULTI_OUT, false); 1169 return err; 1170 } 1171 return 0; 1172 } 1173 1174 static int via_playback_multi_pcm_close(struct hda_pcm_stream *hinfo, 1175 struct hda_codec *codec, 1176 struct snd_pcm_substream *substream) 1177 { 1178 set_stream_open(codec, STREAM_MULTI_OUT, false); 1179 return 0; 1180 } 1181 1182 static int via_playback_hp_pcm_open(struct hda_pcm_stream *hinfo, 1183 struct hda_codec *codec, 1184 struct snd_pcm_substream *substream) 1185 { 1186 struct via_spec *spec = codec->spec; 1187 1188 if (snd_BUG_ON(!spec->hp_dac_nid)) 1189 return -EINVAL; 1190 set_stream_open(codec, STREAM_INDEP_HP, true); 1191 return 0; 1192 } 1193 1194 static int via_playback_hp_pcm_close(struct hda_pcm_stream *hinfo, 1195 struct hda_codec *codec, 1196 struct snd_pcm_substream *substream) 1197 { 1198 set_stream_open(codec, STREAM_INDEP_HP, false); 1199 return 0; 1200 } 1201 1202 static int via_playback_multi_pcm_prepare(struct hda_pcm_stream *hinfo, 1203 struct hda_codec *codec, 1204 unsigned int stream_tag, 1205 unsigned int format, 1206 struct snd_pcm_substream *substream) 1207 { 1208 struct via_spec *spec = codec->spec; 1209 1210 mutex_lock(&spec->config_mutex); 1211 setup_playback_multi_pcm(spec); 1212 snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, 1213 format, substream); 1214 /* remember for dynamic DAC switch with indep-HP */ 1215 spec->active_streams |= STREAM_MULTI_OUT; 1216 spec->cur_dac_stream_tag = stream_tag; 1217 spec->cur_dac_format = format; 1218 mutex_unlock(&spec->config_mutex); 1219 vt1708_update_hp_work(spec); 1220 return 0; 1221 } 1222 1223 static int via_playback_hp_pcm_prepare(struct hda_pcm_stream *hinfo, 1224 struct hda_codec *codec, 1225 unsigned int stream_tag, 1226 unsigned int format, 1227 struct snd_pcm_substream *substream) 1228 { 1229 struct via_spec *spec = codec->spec; 1230 1231 mutex_lock(&spec->config_mutex); 1232 if (spec->hp_independent_mode) 1233 snd_hda_codec_setup_stream(codec, spec->hp_dac_nid, 1234 stream_tag, 0, format); 1235 spec->active_streams |= STREAM_INDEP_HP; 1236 spec->cur_hp_stream_tag = stream_tag; 1237 spec->cur_hp_format = format; 1238 mutex_unlock(&spec->config_mutex); 1239 vt1708_update_hp_work(spec); 1240 return 0; 1241 } 1242 1243 static int via_playback_multi_pcm_cleanup(struct hda_pcm_stream *hinfo, 1244 struct hda_codec *codec, 1245 struct snd_pcm_substream *substream) 1246 { 1247 struct via_spec *spec = codec->spec; 1248 1249 mutex_lock(&spec->config_mutex); 1250 snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); 1251 spec->active_streams &= ~STREAM_MULTI_OUT; 1252 mutex_unlock(&spec->config_mutex); 1253 vt1708_update_hp_work(spec); 1254 return 0; 1255 } 1256 1257 static int via_playback_hp_pcm_cleanup(struct hda_pcm_stream *hinfo, 1258 struct hda_codec *codec, 1259 struct snd_pcm_substream *substream) 1260 { 1261 struct via_spec *spec = codec->spec; 1262 1263 mutex_lock(&spec->config_mutex); 1264 if (spec->hp_independent_mode) 1265 snd_hda_codec_setup_stream(codec, spec->hp_dac_nid, 0, 0, 0); 1266 spec->active_streams &= ~STREAM_INDEP_HP; 1267 mutex_unlock(&spec->config_mutex); 1268 vt1708_update_hp_work(spec); 1269 return 0; 1270 } 1271 1272 /* 1273 * Digital out 1274 */ 1275 static int via_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, 1276 struct hda_codec *codec, 1277 struct snd_pcm_substream *substream) 1278 { 1279 struct via_spec *spec = codec->spec; 1280 return snd_hda_multi_out_dig_open(codec, &spec->multiout); 1281 } 1282 1283 static int via_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, 1284 struct hda_codec *codec, 1285 struct snd_pcm_substream *substream) 1286 { 1287 struct via_spec *spec = codec->spec; 1288 return snd_hda_multi_out_dig_close(codec, &spec->multiout); 1289 } 1290 1291 static int via_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 1292 struct hda_codec *codec, 1293 unsigned int stream_tag, 1294 unsigned int format, 1295 struct snd_pcm_substream *substream) 1296 { 1297 struct via_spec *spec = codec->spec; 1298 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, 1299 stream_tag, format, substream); 1300 } 1301 1302 static int via_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 1303 struct hda_codec *codec, 1304 struct snd_pcm_substream *substream) 1305 { 1306 struct via_spec *spec = codec->spec; 1307 snd_hda_multi_out_dig_cleanup(codec, &spec->multiout); 1308 return 0; 1309 } 1310 1311 /* 1312 * Analog capture 1313 */ 1314 static int via_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 1315 struct hda_codec *codec, 1316 unsigned int stream_tag, 1317 unsigned int format, 1318 struct snd_pcm_substream *substream) 1319 { 1320 struct via_spec *spec = codec->spec; 1321 1322 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 1323 stream_tag, 0, format); 1324 return 0; 1325 } 1326 1327 static int via_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 1328 struct hda_codec *codec, 1329 struct snd_pcm_substream *substream) 1330 { 1331 struct via_spec *spec = codec->spec; 1332 snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]); 1333 return 0; 1334 } 1335 1336 /* analog capture with dynamic ADC switching */ 1337 static int via_dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 1338 struct hda_codec *codec, 1339 unsigned int stream_tag, 1340 unsigned int format, 1341 struct snd_pcm_substream *substream) 1342 { 1343 struct via_spec *spec = codec->spec; 1344 int adc_idx = spec->inputs[spec->cur_mux[0]].adc_idx; 1345 1346 mutex_lock(&spec->config_mutex); 1347 spec->cur_adc = spec->adc_nids[adc_idx]; 1348 spec->cur_adc_stream_tag = stream_tag; 1349 spec->cur_adc_format = format; 1350 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format); 1351 mutex_unlock(&spec->config_mutex); 1352 return 0; 1353 } 1354 1355 static int via_dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 1356 struct hda_codec *codec, 1357 struct snd_pcm_substream *substream) 1358 { 1359 struct via_spec *spec = codec->spec; 1360 1361 mutex_lock(&spec->config_mutex); 1362 snd_hda_codec_cleanup_stream(codec, spec->cur_adc); 1363 spec->cur_adc = 0; 1364 mutex_unlock(&spec->config_mutex); 1365 return 0; 1366 } 1367 1368 /* re-setup the stream if running; called from input-src put */ 1369 static bool via_dyn_adc_pcm_resetup(struct hda_codec *codec, int cur) 1370 { 1371 struct via_spec *spec = codec->spec; 1372 int adc_idx = spec->inputs[cur].adc_idx; 1373 hda_nid_t adc = spec->adc_nids[adc_idx]; 1374 bool ret = false; 1375 1376 mutex_lock(&spec->config_mutex); 1377 if (spec->cur_adc && spec->cur_adc != adc) { 1378 /* stream is running, let's swap the current ADC */ 1379 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1); 1380 spec->cur_adc = adc; 1381 snd_hda_codec_setup_stream(codec, adc, 1382 spec->cur_adc_stream_tag, 0, 1383 spec->cur_adc_format); 1384 ret = true; 1385 } 1386 mutex_unlock(&spec->config_mutex); 1387 return ret; 1388 } 1389 1390 static const struct hda_pcm_stream via_pcm_analog_playback = { 1391 .substreams = 1, 1392 .channels_min = 2, 1393 .channels_max = 8, 1394 /* NID is set in via_build_pcms */ 1395 .ops = { 1396 .open = via_playback_multi_pcm_open, 1397 .close = via_playback_multi_pcm_close, 1398 .prepare = via_playback_multi_pcm_prepare, 1399 .cleanup = via_playback_multi_pcm_cleanup 1400 }, 1401 }; 1402 1403 static const struct hda_pcm_stream via_pcm_hp_playback = { 1404 .substreams = 1, 1405 .channels_min = 2, 1406 .channels_max = 2, 1407 /* NID is set in via_build_pcms */ 1408 .ops = { 1409 .open = via_playback_hp_pcm_open, 1410 .close = via_playback_hp_pcm_close, 1411 .prepare = via_playback_hp_pcm_prepare, 1412 .cleanup = via_playback_hp_pcm_cleanup 1413 }, 1414 }; 1415 1416 static const struct hda_pcm_stream vt1708_pcm_analog_s16_playback = { 1417 .substreams = 1, 1418 .channels_min = 2, 1419 .channels_max = 8, 1420 /* NID is set in via_build_pcms */ 1421 /* We got noisy outputs on the right channel on VT1708 when 1422 * 24bit samples are used. Until any workaround is found, 1423 * disable the 24bit format, so far. 1424 */ 1425 .formats = SNDRV_PCM_FMTBIT_S16_LE, 1426 .ops = { 1427 .open = via_playback_multi_pcm_open, 1428 .close = via_playback_multi_pcm_close, 1429 .prepare = via_playback_multi_pcm_prepare, 1430 .cleanup = via_playback_multi_pcm_cleanup 1431 }, 1432 }; 1433 1434 static const struct hda_pcm_stream via_pcm_analog_capture = { 1435 .substreams = 1, /* will be changed in via_build_pcms() */ 1436 .channels_min = 2, 1437 .channels_max = 2, 1438 /* NID is set in via_build_pcms */ 1439 .ops = { 1440 .prepare = via_capture_pcm_prepare, 1441 .cleanup = via_capture_pcm_cleanup 1442 }, 1443 }; 1444 1445 static const struct hda_pcm_stream via_pcm_dyn_adc_analog_capture = { 1446 .substreams = 1, 1447 .channels_min = 2, 1448 .channels_max = 2, 1449 /* NID is set in via_build_pcms */ 1450 .ops = { 1451 .prepare = via_dyn_adc_capture_pcm_prepare, 1452 .cleanup = via_dyn_adc_capture_pcm_cleanup, 1453 }, 1454 }; 1455 1456 static const struct hda_pcm_stream via_pcm_digital_playback = { 1457 .substreams = 1, 1458 .channels_min = 2, 1459 .channels_max = 2, 1460 /* NID is set in via_build_pcms */ 1461 .ops = { 1462 .open = via_dig_playback_pcm_open, 1463 .close = via_dig_playback_pcm_close, 1464 .prepare = via_dig_playback_pcm_prepare, 1465 .cleanup = via_dig_playback_pcm_cleanup 1466 }, 1467 }; 1468 1469 static const struct hda_pcm_stream via_pcm_digital_capture = { 1470 .substreams = 1, 1471 .channels_min = 2, 1472 .channels_max = 2, 1473 }; 1474 1475 /* 1476 * slave controls for virtual master 1477 */ 1478 static const char * const via_slave_pfxs[] = { 1479 "Front", "Surround", "Center", "LFE", "Side", 1480 "Headphone", "Speaker", "Bass Speaker", 1481 NULL, 1482 }; 1483 1484 static int via_build_controls(struct hda_codec *codec) 1485 { 1486 struct via_spec *spec = codec->spec; 1487 struct snd_kcontrol *kctl; 1488 int err, i; 1489 1490 spec->no_pin_power_ctl = 1; 1491 if (spec->set_widgets_power_state) 1492 if (!via_clone_control(spec, &via_pin_power_ctl_enum)) 1493 return -ENOMEM; 1494 1495 for (i = 0; i < spec->num_mixers; i++) { 1496 err = snd_hda_add_new_ctls(codec, spec->mixers[i]); 1497 if (err < 0) 1498 return err; 1499 } 1500 1501 if (spec->multiout.dig_out_nid) { 1502 err = snd_hda_create_spdif_out_ctls(codec, 1503 spec->multiout.dig_out_nid, 1504 spec->multiout.dig_out_nid); 1505 if (err < 0) 1506 return err; 1507 err = snd_hda_create_spdif_share_sw(codec, 1508 &spec->multiout); 1509 if (err < 0) 1510 return err; 1511 spec->multiout.share_spdif = 1; 1512 } 1513 if (spec->dig_in_nid) { 1514 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid); 1515 if (err < 0) 1516 return err; 1517 } 1518 1519 /* if we have no master control, let's create it */ 1520 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) { 1521 unsigned int vmaster_tlv[4]; 1522 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0], 1523 HDA_OUTPUT, vmaster_tlv); 1524 err = snd_hda_add_vmaster(codec, "Master Playback Volume", 1525 vmaster_tlv, via_slave_pfxs, 1526 "Playback Volume"); 1527 if (err < 0) 1528 return err; 1529 } 1530 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) { 1531 err = snd_hda_add_vmaster(codec, "Master Playback Switch", 1532 NULL, via_slave_pfxs, 1533 "Playback Switch"); 1534 if (err < 0) 1535 return err; 1536 } 1537 1538 /* assign Capture Source enums to NID */ 1539 kctl = snd_hda_find_mixer_ctl(codec, "Input Source"); 1540 for (i = 0; kctl && i < kctl->count; i++) { 1541 if (!spec->mux_nids[i]) 1542 continue; 1543 err = snd_hda_add_nid(codec, kctl, i, spec->mux_nids[i]); 1544 if (err < 0) 1545 return err; 1546 } 1547 1548 via_free_kctls(codec); /* no longer needed */ 1549 1550 err = snd_hda_jack_add_kctls(codec, &spec->autocfg); 1551 if (err < 0) 1552 return err; 1553 1554 return 0; 1555 } 1556 1557 static int via_build_pcms(struct hda_codec *codec) 1558 { 1559 struct via_spec *spec = codec->spec; 1560 struct hda_pcm *info = spec->pcm_rec; 1561 1562 codec->num_pcms = 0; 1563 codec->pcm_info = info; 1564 1565 if (spec->multiout.num_dacs || spec->num_adc_nids) { 1566 snprintf(spec->stream_name_analog, 1567 sizeof(spec->stream_name_analog), 1568 "%s Analog", codec->chip_name); 1569 info->name = spec->stream_name_analog; 1570 1571 if (spec->multiout.num_dacs) { 1572 if (!spec->stream_analog_playback) 1573 spec->stream_analog_playback = 1574 &via_pcm_analog_playback; 1575 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 1576 *spec->stream_analog_playback; 1577 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 1578 spec->multiout.dac_nids[0]; 1579 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 1580 spec->multiout.max_channels; 1581 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT 1582 && spec->autocfg.line_outs == 2) 1583 info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap = 1584 snd_pcm_2_1_chmaps; 1585 } 1586 1587 if (!spec->stream_analog_capture) { 1588 if (spec->dyn_adc_switch) 1589 spec->stream_analog_capture = 1590 &via_pcm_dyn_adc_analog_capture; 1591 else 1592 spec->stream_analog_capture = 1593 &via_pcm_analog_capture; 1594 } 1595 if (spec->num_adc_nids) { 1596 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 1597 *spec->stream_analog_capture; 1598 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 1599 spec->adc_nids[0]; 1600 if (!spec->dyn_adc_switch) 1601 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 1602 spec->num_adc_nids; 1603 } 1604 codec->num_pcms++; 1605 info++; 1606 } 1607 1608 if (spec->multiout.dig_out_nid || spec->dig_in_nid) { 1609 snprintf(spec->stream_name_digital, 1610 sizeof(spec->stream_name_digital), 1611 "%s Digital", codec->chip_name); 1612 info->name = spec->stream_name_digital; 1613 info->pcm_type = HDA_PCM_TYPE_SPDIF; 1614 if (spec->multiout.dig_out_nid) { 1615 if (!spec->stream_digital_playback) 1616 spec->stream_digital_playback = 1617 &via_pcm_digital_playback; 1618 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 1619 *spec->stream_digital_playback; 1620 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 1621 spec->multiout.dig_out_nid; 1622 } 1623 if (spec->dig_in_nid) { 1624 if (!spec->stream_digital_capture) 1625 spec->stream_digital_capture = 1626 &via_pcm_digital_capture; 1627 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 1628 *spec->stream_digital_capture; 1629 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 1630 spec->dig_in_nid; 1631 } 1632 codec->num_pcms++; 1633 info++; 1634 } 1635 1636 if (spec->hp_dac_nid) { 1637 snprintf(spec->stream_name_hp, sizeof(spec->stream_name_hp), 1638 "%s HP", codec->chip_name); 1639 info->name = spec->stream_name_hp; 1640 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = via_pcm_hp_playback; 1641 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 1642 spec->hp_dac_nid; 1643 codec->num_pcms++; 1644 info++; 1645 } 1646 return 0; 1647 } 1648 1649 static void via_free(struct hda_codec *codec) 1650 { 1651 struct via_spec *spec = codec->spec; 1652 1653 if (!spec) 1654 return; 1655 1656 via_free_kctls(codec); 1657 vt1708_stop_hp_work(spec); 1658 kfree(spec->bind_cap_vol); 1659 kfree(spec->bind_cap_sw); 1660 snd_hda_gen_free(&spec->gen); 1661 kfree(spec); 1662 } 1663 1664 /* mute/unmute outputs */ 1665 static void toggle_output_mutes(struct hda_codec *codec, int num_pins, 1666 hda_nid_t *pins, bool mute) 1667 { 1668 int i; 1669 for (i = 0; i < num_pins; i++) { 1670 unsigned int parm = snd_hda_codec_read(codec, pins[i], 0, 1671 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 1672 if (parm & AC_PINCTL_IN_EN) 1673 continue; 1674 if (mute) 1675 parm &= ~AC_PINCTL_OUT_EN; 1676 else 1677 parm |= AC_PINCTL_OUT_EN; 1678 snd_hda_set_pin_ctl(codec, pins[i], parm); 1679 } 1680 } 1681 1682 /* mute internal speaker if line-out is plugged */ 1683 static void via_line_automute(struct hda_codec *codec, int present) 1684 { 1685 struct via_spec *spec = codec->spec; 1686 1687 if (!spec->autocfg.speaker_outs) 1688 return; 1689 if (!present) 1690 present = snd_hda_jack_detect(codec, 1691 spec->autocfg.line_out_pins[0]); 1692 toggle_output_mutes(codec, spec->autocfg.speaker_outs, 1693 spec->autocfg.speaker_pins, 1694 present); 1695 } 1696 1697 /* mute internal speaker if HP is plugged */ 1698 static void via_hp_automute(struct hda_codec *codec) 1699 { 1700 int present = 0; 1701 int nums; 1702 struct via_spec *spec = codec->spec; 1703 1704 if (!spec->hp_independent_mode && spec->autocfg.hp_pins[0] && 1705 (spec->codec_type != VT1708 || spec->vt1708_jack_detect) && 1706 is_jack_detectable(codec, spec->autocfg.hp_pins[0])) 1707 present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]); 1708 1709 if (spec->smart51_enabled) 1710 nums = spec->autocfg.line_outs + spec->smart51_nums; 1711 else 1712 nums = spec->autocfg.line_outs; 1713 toggle_output_mutes(codec, nums, spec->autocfg.line_out_pins, present); 1714 1715 via_line_automute(codec, present); 1716 } 1717 1718 #ifdef CONFIG_PM 1719 static int via_suspend(struct hda_codec *codec) 1720 { 1721 struct via_spec *spec = codec->spec; 1722 vt1708_stop_hp_work(spec); 1723 1724 if (spec->codec_type == VT1802) { 1725 /* Fix pop noise on headphones */ 1726 int i; 1727 for (i = 0; i < spec->autocfg.hp_outs; i++) 1728 snd_hda_set_pin_ctl(codec, spec->autocfg.hp_pins[i], 0); 1729 } 1730 1731 return 0; 1732 } 1733 #endif 1734 1735 #ifdef CONFIG_PM 1736 static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid) 1737 { 1738 struct via_spec *spec = codec->spec; 1739 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid); 1740 } 1741 #endif 1742 1743 /* 1744 */ 1745 1746 static int via_init(struct hda_codec *codec); 1747 1748 static const struct hda_codec_ops via_patch_ops = { 1749 .build_controls = via_build_controls, 1750 .build_pcms = via_build_pcms, 1751 .init = via_init, 1752 .free = via_free, 1753 .unsol_event = snd_hda_jack_unsol_event, 1754 #ifdef CONFIG_PM 1755 .suspend = via_suspend, 1756 .check_power_status = via_check_power_status, 1757 #endif 1758 }; 1759 1760 static bool is_empty_dac(struct hda_codec *codec, hda_nid_t dac) 1761 { 1762 struct via_spec *spec = codec->spec; 1763 int i; 1764 1765 for (i = 0; i < spec->multiout.num_dacs; i++) { 1766 if (spec->multiout.dac_nids[i] == dac) 1767 return false; 1768 } 1769 if (spec->hp_dac_nid == dac) 1770 return false; 1771 return true; 1772 } 1773 1774 static bool __parse_output_path(struct hda_codec *codec, hda_nid_t nid, 1775 hda_nid_t target_dac, int with_aa_mix, 1776 struct nid_path *path, int depth) 1777 { 1778 struct via_spec *spec = codec->spec; 1779 hda_nid_t conn[8]; 1780 int i, nums; 1781 1782 if (nid == spec->aa_mix_nid) { 1783 if (!with_aa_mix) 1784 return false; 1785 with_aa_mix = 2; /* mark aa-mix is included */ 1786 } 1787 1788 nums = snd_hda_get_connections(codec, nid, conn, ARRAY_SIZE(conn)); 1789 for (i = 0; i < nums; i++) { 1790 if (get_wcaps_type(get_wcaps(codec, conn[i])) != AC_WID_AUD_OUT) 1791 continue; 1792 if (conn[i] == target_dac || is_empty_dac(codec, conn[i])) { 1793 /* aa-mix is requested but not included? */ 1794 if (!(spec->aa_mix_nid && with_aa_mix == 1)) 1795 goto found; 1796 } 1797 } 1798 if (depth >= MAX_NID_PATH_DEPTH) 1799 return false; 1800 for (i = 0; i < nums; i++) { 1801 unsigned int type; 1802 type = get_wcaps_type(get_wcaps(codec, conn[i])); 1803 if (type == AC_WID_AUD_OUT) 1804 continue; 1805 if (__parse_output_path(codec, conn[i], target_dac, 1806 with_aa_mix, path, depth + 1)) 1807 goto found; 1808 } 1809 return false; 1810 1811 found: 1812 path->path[path->depth] = conn[i]; 1813 path->idx[path->depth] = i; 1814 if (nums > 1 && get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_MIX) 1815 path->multi[path->depth] = 1; 1816 path->depth++; 1817 return true; 1818 } 1819 1820 static bool parse_output_path(struct hda_codec *codec, hda_nid_t nid, 1821 hda_nid_t target_dac, int with_aa_mix, 1822 struct nid_path *path) 1823 { 1824 if (__parse_output_path(codec, nid, target_dac, with_aa_mix, path, 1)) { 1825 path->path[path->depth] = nid; 1826 path->depth++; 1827 snd_printdd("output-path: depth=%d, %02x/%02x/%02x/%02x/%02x\n", 1828 path->depth, path->path[0], path->path[1], 1829 path->path[2], path->path[3], path->path[4]); 1830 return true; 1831 } 1832 return false; 1833 } 1834 1835 static int via_auto_fill_dac_nids(struct hda_codec *codec) 1836 { 1837 struct via_spec *spec = codec->spec; 1838 const struct auto_pin_cfg *cfg = &spec->autocfg; 1839 int i; 1840 hda_nid_t nid; 1841 1842 spec->multiout.num_dacs = 0; 1843 spec->multiout.dac_nids = spec->private_dac_nids; 1844 for (i = 0; i < cfg->line_outs; i++) { 1845 hda_nid_t dac = 0; 1846 nid = cfg->line_out_pins[i]; 1847 if (!nid) 1848 continue; 1849 if (parse_output_path(codec, nid, 0, 0, &spec->out_path[i])) 1850 dac = spec->out_path[i].path[0]; 1851 if (!i && parse_output_path(codec, nid, dac, 1, 1852 &spec->out_mix_path)) 1853 dac = spec->out_mix_path.path[0]; 1854 if (dac) 1855 spec->private_dac_nids[spec->multiout.num_dacs++] = dac; 1856 } 1857 if (!spec->out_path[0].depth && spec->out_mix_path.depth) { 1858 spec->out_path[0] = spec->out_mix_path; 1859 spec->out_mix_path.depth = 0; 1860 } 1861 return 0; 1862 } 1863 1864 static int create_ch_ctls(struct hda_codec *codec, const char *pfx, 1865 int chs, bool check_dac, struct nid_path *path) 1866 { 1867 struct via_spec *spec = codec->spec; 1868 char name[32]; 1869 hda_nid_t dac, pin, sel, nid; 1870 int err; 1871 1872 dac = check_dac ? path->path[0] : 0; 1873 pin = path->path[path->depth - 1]; 1874 sel = path->depth > 1 ? path->path[1] : 0; 1875 1876 if (dac && check_amp_caps(codec, dac, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS)) 1877 nid = dac; 1878 else if (check_amp_caps(codec, pin, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS)) 1879 nid = pin; 1880 else if (check_amp_caps(codec, sel, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS)) 1881 nid = sel; 1882 else 1883 nid = 0; 1884 if (nid) { 1885 sprintf(name, "%s Playback Volume", pfx); 1886 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 1887 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT)); 1888 if (err < 0) 1889 return err; 1890 path->vol_ctl = nid; 1891 } 1892 1893 if (dac && check_amp_caps(codec, dac, HDA_OUTPUT, AC_AMPCAP_MUTE)) 1894 nid = dac; 1895 else if (check_amp_caps(codec, pin, HDA_OUTPUT, AC_AMPCAP_MUTE)) 1896 nid = pin; 1897 else if (check_amp_caps(codec, sel, HDA_OUTPUT, AC_AMPCAP_MUTE)) 1898 nid = sel; 1899 else 1900 nid = 0; 1901 if (nid) { 1902 sprintf(name, "%s Playback Switch", pfx); 1903 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 1904 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT)); 1905 if (err < 0) 1906 return err; 1907 path->mute_ctl = nid; 1908 } 1909 return 0; 1910 } 1911 1912 static void mangle_smart51(struct hda_codec *codec) 1913 { 1914 struct via_spec *spec = codec->spec; 1915 struct auto_pin_cfg *cfg = &spec->autocfg; 1916 struct auto_pin_cfg_item *ins = cfg->inputs; 1917 int i, j, nums, attr; 1918 int pins[AUTO_CFG_MAX_INS]; 1919 1920 for (attr = INPUT_PIN_ATTR_REAR; attr >= INPUT_PIN_ATTR_NORMAL; attr--) { 1921 nums = 0; 1922 for (i = 0; i < cfg->num_inputs; i++) { 1923 unsigned int def; 1924 if (ins[i].type > AUTO_PIN_LINE_IN) 1925 continue; 1926 def = snd_hda_codec_get_pincfg(codec, ins[i].pin); 1927 if (snd_hda_get_input_pin_attr(def) != attr) 1928 continue; 1929 for (j = 0; j < nums; j++) 1930 if (ins[pins[j]].type < ins[i].type) { 1931 memmove(pins + j + 1, pins + j, 1932 (nums - j) * sizeof(int)); 1933 break; 1934 } 1935 pins[j] = i; 1936 nums++; 1937 } 1938 if (cfg->line_outs + nums < 3) 1939 continue; 1940 for (i = 0; i < nums; i++) { 1941 hda_nid_t pin = ins[pins[i]].pin; 1942 spec->smart51_pins[spec->smart51_nums++] = pin; 1943 cfg->line_out_pins[cfg->line_outs++] = pin; 1944 if (cfg->line_outs == 3) 1945 break; 1946 } 1947 return; 1948 } 1949 } 1950 1951 static void copy_path_mixer_ctls(struct nid_path *dst, struct nid_path *src) 1952 { 1953 dst->vol_ctl = src->vol_ctl; 1954 dst->mute_ctl = src->mute_ctl; 1955 } 1956 1957 /* add playback controls from the parsed DAC table */ 1958 static int via_auto_create_multi_out_ctls(struct hda_codec *codec) 1959 { 1960 struct via_spec *spec = codec->spec; 1961 struct auto_pin_cfg *cfg = &spec->autocfg; 1962 struct nid_path *path; 1963 static const char * const chname[4] = { 1964 "Front", "Surround", NULL /* "CLFE" */, "Side" 1965 }; 1966 int i, idx, err; 1967 int old_line_outs; 1968 1969 /* check smart51 */ 1970 old_line_outs = cfg->line_outs; 1971 if (cfg->line_outs == 1) 1972 mangle_smart51(codec); 1973 1974 err = via_auto_fill_dac_nids(codec); 1975 if (err < 0) 1976 return err; 1977 1978 if (spec->multiout.num_dacs < 3) { 1979 spec->smart51_nums = 0; 1980 cfg->line_outs = old_line_outs; 1981 } 1982 for (i = 0; i < cfg->line_outs; i++) { 1983 hda_nid_t pin, dac; 1984 pin = cfg->line_out_pins[i]; 1985 dac = spec->multiout.dac_nids[i]; 1986 if (!pin || !dac) 1987 continue; 1988 path = spec->out_path + i; 1989 if (i == HDA_CLFE) { 1990 err = create_ch_ctls(codec, "Center", 1, true, path); 1991 if (err < 0) 1992 return err; 1993 err = create_ch_ctls(codec, "LFE", 2, true, path); 1994 if (err < 0) 1995 return err; 1996 } else { 1997 const char *pfx = chname[i]; 1998 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT && 1999 cfg->line_outs <= 2) 2000 pfx = i ? "Bass Speaker" : "Speaker"; 2001 err = create_ch_ctls(codec, pfx, 3, true, path); 2002 if (err < 0) 2003 return err; 2004 } 2005 if (path != spec->out_path + i) 2006 copy_path_mixer_ctls(&spec->out_path[i], path); 2007 if (path == spec->out_path && spec->out_mix_path.depth) 2008 copy_path_mixer_ctls(&spec->out_mix_path, path); 2009 } 2010 2011 idx = get_connection_index(codec, spec->aa_mix_nid, 2012 spec->multiout.dac_nids[0]); 2013 if (idx >= 0) { 2014 /* add control to mixer */ 2015 const char *name; 2016 name = spec->out_mix_path.depth ? 2017 "PCM Loopback Playback Volume" : "PCM Playback Volume"; 2018 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, 2019 HDA_COMPOSE_AMP_VAL(spec->aa_mix_nid, 3, 2020 idx, HDA_INPUT)); 2021 if (err < 0) 2022 return err; 2023 name = spec->out_mix_path.depth ? 2024 "PCM Loopback Playback Switch" : "PCM Playback Switch"; 2025 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name, 2026 HDA_COMPOSE_AMP_VAL(spec->aa_mix_nid, 3, 2027 idx, HDA_INPUT)); 2028 if (err < 0) 2029 return err; 2030 } 2031 2032 cfg->line_outs = old_line_outs; 2033 2034 return 0; 2035 } 2036 2037 static int via_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin) 2038 { 2039 struct via_spec *spec = codec->spec; 2040 struct nid_path *path; 2041 bool check_dac; 2042 int i, err; 2043 2044 if (!pin) 2045 return 0; 2046 2047 if (!parse_output_path(codec, pin, 0, 0, &spec->hp_indep_path)) { 2048 for (i = HDA_SIDE; i >= HDA_CLFE; i--) { 2049 if (i < spec->multiout.num_dacs && 2050 parse_output_path(codec, pin, 2051 spec->multiout.dac_nids[i], 0, 2052 &spec->hp_indep_path)) { 2053 spec->hp_indep_shared = i; 2054 break; 2055 } 2056 } 2057 } 2058 if (spec->hp_indep_path.depth) { 2059 spec->hp_dac_nid = spec->hp_indep_path.path[0]; 2060 if (!spec->hp_indep_shared) 2061 spec->hp_path = spec->hp_indep_path; 2062 } 2063 /* optionally check front-path w/o AA-mix */ 2064 if (!spec->hp_path.depth) 2065 parse_output_path(codec, pin, 2066 spec->multiout.dac_nids[HDA_FRONT], 0, 2067 &spec->hp_path); 2068 2069 if (!parse_output_path(codec, pin, spec->multiout.dac_nids[HDA_FRONT], 2070 1, &spec->hp_mix_path) && !spec->hp_path.depth) 2071 return 0; 2072 2073 if (spec->hp_path.depth) { 2074 path = &spec->hp_path; 2075 check_dac = true; 2076 } else { 2077 path = &spec->hp_mix_path; 2078 check_dac = false; 2079 } 2080 err = create_ch_ctls(codec, "Headphone", 3, check_dac, path); 2081 if (err < 0) 2082 return err; 2083 if (check_dac) 2084 copy_path_mixer_ctls(&spec->hp_mix_path, path); 2085 else 2086 copy_path_mixer_ctls(&spec->hp_path, path); 2087 if (spec->hp_indep_path.depth) 2088 copy_path_mixer_ctls(&spec->hp_indep_path, path); 2089 return 0; 2090 } 2091 2092 static int via_auto_create_speaker_ctls(struct hda_codec *codec) 2093 { 2094 struct via_spec *spec = codec->spec; 2095 struct nid_path *path; 2096 bool check_dac; 2097 hda_nid_t pin, dac = 0; 2098 int err; 2099 2100 pin = spec->autocfg.speaker_pins[0]; 2101 if (!spec->autocfg.speaker_outs || !pin) 2102 return 0; 2103 2104 if (parse_output_path(codec, pin, 0, 0, &spec->speaker_path)) 2105 dac = spec->speaker_path.path[0]; 2106 if (!dac) 2107 parse_output_path(codec, pin, 2108 spec->multiout.dac_nids[HDA_FRONT], 0, 2109 &spec->speaker_path); 2110 if (!parse_output_path(codec, pin, spec->multiout.dac_nids[HDA_FRONT], 2111 1, &spec->speaker_mix_path) && !dac) 2112 return 0; 2113 2114 /* no AA-path for front? */ 2115 if (!spec->out_mix_path.depth && spec->speaker_mix_path.depth) 2116 dac = 0; 2117 2118 spec->speaker_dac_nid = dac; 2119 spec->multiout.extra_out_nid[0] = dac; 2120 if (dac) { 2121 path = &spec->speaker_path; 2122 check_dac = true; 2123 } else { 2124 path = &spec->speaker_mix_path; 2125 check_dac = false; 2126 } 2127 err = create_ch_ctls(codec, "Speaker", 3, check_dac, path); 2128 if (err < 0) 2129 return err; 2130 if (check_dac) 2131 copy_path_mixer_ctls(&spec->speaker_mix_path, path); 2132 else 2133 copy_path_mixer_ctls(&spec->speaker_path, path); 2134 return 0; 2135 } 2136 2137 #define via_aamix_ctl_info via_pin_power_ctl_info 2138 2139 static int via_aamix_ctl_get(struct snd_kcontrol *kcontrol, 2140 struct snd_ctl_elem_value *ucontrol) 2141 { 2142 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2143 struct via_spec *spec = codec->spec; 2144 ucontrol->value.enumerated.item[0] = spec->aamix_mode; 2145 return 0; 2146 } 2147 2148 static void update_aamix_paths(struct hda_codec *codec, int do_mix, 2149 struct nid_path *nomix, struct nid_path *mix) 2150 { 2151 if (do_mix) { 2152 activate_output_path(codec, nomix, false, false); 2153 activate_output_path(codec, mix, true, false); 2154 } else { 2155 activate_output_path(codec, mix, false, false); 2156 activate_output_path(codec, nomix, true, false); 2157 } 2158 } 2159 2160 static int via_aamix_ctl_put(struct snd_kcontrol *kcontrol, 2161 struct snd_ctl_elem_value *ucontrol) 2162 { 2163 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2164 struct via_spec *spec = codec->spec; 2165 unsigned int val = ucontrol->value.enumerated.item[0]; 2166 2167 if (val == spec->aamix_mode) 2168 return 0; 2169 spec->aamix_mode = val; 2170 /* update front path */ 2171 update_aamix_paths(codec, val, &spec->out_path[0], &spec->out_mix_path); 2172 /* update HP path */ 2173 if (!spec->hp_independent_mode) { 2174 update_aamix_paths(codec, val, &spec->hp_path, 2175 &spec->hp_mix_path); 2176 } 2177 /* update speaker path */ 2178 update_aamix_paths(codec, val, &spec->speaker_path, 2179 &spec->speaker_mix_path); 2180 return 1; 2181 } 2182 2183 static const struct snd_kcontrol_new via_aamix_ctl_enum = { 2184 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2185 .name = "Loopback Mixing", 2186 .info = via_aamix_ctl_info, 2187 .get = via_aamix_ctl_get, 2188 .put = via_aamix_ctl_put, 2189 }; 2190 2191 static int via_auto_create_loopback_switch(struct hda_codec *codec) 2192 { 2193 struct via_spec *spec = codec->spec; 2194 2195 if (!spec->aa_mix_nid) 2196 return 0; /* no loopback switching available */ 2197 if (!(spec->out_mix_path.depth || spec->hp_mix_path.depth || 2198 spec->speaker_path.depth)) 2199 return 0; /* no loopback switching available */ 2200 if (!via_clone_control(spec, &via_aamix_ctl_enum)) 2201 return -ENOMEM; 2202 return 0; 2203 } 2204 2205 /* look for ADCs */ 2206 static int via_fill_adcs(struct hda_codec *codec) 2207 { 2208 struct via_spec *spec = codec->spec; 2209 hda_nid_t nid = codec->start_nid; 2210 int i; 2211 2212 for (i = 0; i < codec->num_nodes; i++, nid++) { 2213 unsigned int wcaps = get_wcaps(codec, nid); 2214 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN) 2215 continue; 2216 if (wcaps & AC_WCAP_DIGITAL) 2217 continue; 2218 if (!(wcaps & AC_WCAP_CONN_LIST)) 2219 continue; 2220 if (spec->num_adc_nids >= ARRAY_SIZE(spec->adc_nids)) 2221 return -ENOMEM; 2222 spec->adc_nids[spec->num_adc_nids++] = nid; 2223 } 2224 return 0; 2225 } 2226 2227 /* input-src control */ 2228 static int via_mux_enum_info(struct snd_kcontrol *kcontrol, 2229 struct snd_ctl_elem_info *uinfo) 2230 { 2231 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2232 struct via_spec *spec = codec->spec; 2233 2234 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 2235 uinfo->count = 1; 2236 uinfo->value.enumerated.items = spec->num_inputs; 2237 if (uinfo->value.enumerated.item >= spec->num_inputs) 2238 uinfo->value.enumerated.item = spec->num_inputs - 1; 2239 strcpy(uinfo->value.enumerated.name, 2240 spec->inputs[uinfo->value.enumerated.item].label); 2241 return 0; 2242 } 2243 2244 static int via_mux_enum_get(struct snd_kcontrol *kcontrol, 2245 struct snd_ctl_elem_value *ucontrol) 2246 { 2247 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2248 struct via_spec *spec = codec->spec; 2249 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 2250 2251 ucontrol->value.enumerated.item[0] = spec->cur_mux[idx]; 2252 return 0; 2253 } 2254 2255 static int via_mux_enum_put(struct snd_kcontrol *kcontrol, 2256 struct snd_ctl_elem_value *ucontrol) 2257 { 2258 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2259 struct via_spec *spec = codec->spec; 2260 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 2261 hda_nid_t mux; 2262 int cur; 2263 2264 cur = ucontrol->value.enumerated.item[0]; 2265 if (cur < 0 || cur >= spec->num_inputs) 2266 return -EINVAL; 2267 if (spec->cur_mux[idx] == cur) 2268 return 0; 2269 spec->cur_mux[idx] = cur; 2270 if (spec->dyn_adc_switch) { 2271 int adc_idx = spec->inputs[cur].adc_idx; 2272 mux = spec->mux_nids[adc_idx]; 2273 via_dyn_adc_pcm_resetup(codec, cur); 2274 } else { 2275 mux = spec->mux_nids[idx]; 2276 if (snd_BUG_ON(!mux)) 2277 return -EINVAL; 2278 } 2279 2280 if (mux) { 2281 /* switch to D0 beofre change index */ 2282 update_power_state(codec, mux, AC_PWRST_D0); 2283 snd_hda_codec_write(codec, mux, 0, 2284 AC_VERB_SET_CONNECT_SEL, 2285 spec->inputs[cur].mux_idx); 2286 } 2287 2288 /* update jack power state */ 2289 set_widgets_power_state(codec); 2290 return 0; 2291 } 2292 2293 static const struct snd_kcontrol_new via_input_src_ctl = { 2294 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2295 /* The multiple "Capture Source" controls confuse alsamixer 2296 * So call somewhat different.. 2297 */ 2298 /* .name = "Capture Source", */ 2299 .name = "Input Source", 2300 .info = via_mux_enum_info, 2301 .get = via_mux_enum_get, 2302 .put = via_mux_enum_put, 2303 }; 2304 2305 static int create_input_src_ctls(struct hda_codec *codec, int count) 2306 { 2307 struct via_spec *spec = codec->spec; 2308 struct snd_kcontrol_new *knew; 2309 2310 if (spec->num_inputs <= 1 || !count) 2311 return 0; /* no need for single src */ 2312 2313 knew = via_clone_control(spec, &via_input_src_ctl); 2314 if (!knew) 2315 return -ENOMEM; 2316 knew->count = count; 2317 return 0; 2318 } 2319 2320 /* add the powersave loopback-list entry */ 2321 static void add_loopback_list(struct via_spec *spec, hda_nid_t mix, int idx) 2322 { 2323 struct hda_amp_list *list; 2324 2325 if (spec->num_loopbacks >= ARRAY_SIZE(spec->loopback_list) - 1) 2326 return; 2327 list = spec->loopback_list + spec->num_loopbacks; 2328 list->nid = mix; 2329 list->dir = HDA_INPUT; 2330 list->idx = idx; 2331 spec->num_loopbacks++; 2332 spec->loopback.amplist = spec->loopback_list; 2333 } 2334 2335 static bool is_reachable_nid(struct hda_codec *codec, hda_nid_t src, 2336 hda_nid_t dst) 2337 { 2338 return snd_hda_get_conn_index(codec, src, dst, 1) >= 0; 2339 } 2340 2341 /* add the input-route to the given pin */ 2342 static bool add_input_route(struct hda_codec *codec, hda_nid_t pin) 2343 { 2344 struct via_spec *spec = codec->spec; 2345 int c, idx; 2346 2347 spec->inputs[spec->num_inputs].adc_idx = -1; 2348 spec->inputs[spec->num_inputs].pin = pin; 2349 for (c = 0; c < spec->num_adc_nids; c++) { 2350 if (spec->mux_nids[c]) { 2351 idx = get_connection_index(codec, spec->mux_nids[c], 2352 pin); 2353 if (idx < 0) 2354 continue; 2355 spec->inputs[spec->num_inputs].mux_idx = idx; 2356 } else { 2357 if (!is_reachable_nid(codec, spec->adc_nids[c], pin)) 2358 continue; 2359 } 2360 spec->inputs[spec->num_inputs].adc_idx = c; 2361 /* Can primary ADC satisfy all inputs? */ 2362 if (!spec->dyn_adc_switch && 2363 spec->num_inputs > 0 && spec->inputs[0].adc_idx != c) { 2364 snd_printd(KERN_INFO 2365 "via: dynamic ADC switching enabled\n"); 2366 spec->dyn_adc_switch = 1; 2367 } 2368 return true; 2369 } 2370 return false; 2371 } 2372 2373 static int get_mux_nids(struct hda_codec *codec); 2374 2375 /* parse input-routes; fill ADCs, MUXs and input-src entries */ 2376 static int parse_analog_inputs(struct hda_codec *codec) 2377 { 2378 struct via_spec *spec = codec->spec; 2379 const struct auto_pin_cfg *cfg = &spec->autocfg; 2380 int i, err; 2381 2382 err = via_fill_adcs(codec); 2383 if (err < 0) 2384 return err; 2385 err = get_mux_nids(codec); 2386 if (err < 0) 2387 return err; 2388 2389 /* fill all input-routes */ 2390 for (i = 0; i < cfg->num_inputs; i++) { 2391 if (add_input_route(codec, cfg->inputs[i].pin)) 2392 spec->inputs[spec->num_inputs++].label = 2393 hda_get_autocfg_input_label(codec, cfg, i); 2394 } 2395 2396 /* check for internal loopback recording */ 2397 if (spec->aa_mix_nid && 2398 add_input_route(codec, spec->aa_mix_nid)) 2399 spec->inputs[spec->num_inputs++].label = "Stereo Mixer"; 2400 2401 return 0; 2402 } 2403 2404 /* create analog-loopback volume/switch controls */ 2405 static int create_loopback_ctls(struct hda_codec *codec) 2406 { 2407 struct via_spec *spec = codec->spec; 2408 const struct auto_pin_cfg *cfg = &spec->autocfg; 2409 const char *prev_label = NULL; 2410 int type_idx = 0; 2411 int i, j, err, idx; 2412 2413 if (!spec->aa_mix_nid) 2414 return 0; 2415 2416 for (i = 0; i < cfg->num_inputs; i++) { 2417 hda_nid_t pin = cfg->inputs[i].pin; 2418 const char *label = hda_get_autocfg_input_label(codec, cfg, i); 2419 2420 if (prev_label && !strcmp(label, prev_label)) 2421 type_idx++; 2422 else 2423 type_idx = 0; 2424 prev_label = label; 2425 idx = get_connection_index(codec, spec->aa_mix_nid, pin); 2426 if (idx >= 0) { 2427 err = via_new_analog_input(spec, label, type_idx, 2428 idx, spec->aa_mix_nid); 2429 if (err < 0) 2430 return err; 2431 add_loopback_list(spec, spec->aa_mix_nid, idx); 2432 } 2433 2434 /* remember the label for smart51 control */ 2435 for (j = 0; j < spec->smart51_nums; j++) { 2436 if (spec->smart51_pins[j] == pin) { 2437 spec->smart51_idxs[j] = idx; 2438 spec->smart51_labels[j] = label; 2439 break; 2440 } 2441 } 2442 } 2443 return 0; 2444 } 2445 2446 /* create mic-boost controls (if present) */ 2447 static int create_mic_boost_ctls(struct hda_codec *codec) 2448 { 2449 struct via_spec *spec = codec->spec; 2450 const struct auto_pin_cfg *cfg = &spec->autocfg; 2451 const char *prev_label = NULL; 2452 int type_idx = 0; 2453 int i, err; 2454 2455 for (i = 0; i < cfg->num_inputs; i++) { 2456 hda_nid_t pin = cfg->inputs[i].pin; 2457 unsigned int caps; 2458 const char *label; 2459 char name[32]; 2460 2461 if (cfg->inputs[i].type != AUTO_PIN_MIC) 2462 continue; 2463 caps = query_amp_caps(codec, pin, HDA_INPUT); 2464 if (caps == -1 || !(caps & AC_AMPCAP_NUM_STEPS)) 2465 continue; 2466 label = hda_get_autocfg_input_label(codec, cfg, i); 2467 if (prev_label && !strcmp(label, prev_label)) 2468 type_idx++; 2469 else 2470 type_idx = 0; 2471 prev_label = label; 2472 snprintf(name, sizeof(name), "%s Boost Volume", label); 2473 err = __via_add_control(spec, VIA_CTL_WIDGET_VOL, name, type_idx, 2474 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_INPUT)); 2475 if (err < 0) 2476 return err; 2477 } 2478 return 0; 2479 } 2480 2481 /* create capture and input-src controls for multiple streams */ 2482 static int create_multi_adc_ctls(struct hda_codec *codec) 2483 { 2484 struct via_spec *spec = codec->spec; 2485 int i, err; 2486 2487 /* create capture mixer elements */ 2488 for (i = 0; i < spec->num_adc_nids; i++) { 2489 hda_nid_t adc = spec->adc_nids[i]; 2490 err = __via_add_control(spec, VIA_CTL_WIDGET_VOL, 2491 "Capture Volume", i, 2492 HDA_COMPOSE_AMP_VAL(adc, 3, 0, 2493 HDA_INPUT)); 2494 if (err < 0) 2495 return err; 2496 err = __via_add_control(spec, VIA_CTL_WIDGET_MUTE, 2497 "Capture Switch", i, 2498 HDA_COMPOSE_AMP_VAL(adc, 3, 0, 2499 HDA_INPUT)); 2500 if (err < 0) 2501 return err; 2502 } 2503 2504 /* input-source control */ 2505 for (i = 0; i < spec->num_adc_nids; i++) 2506 if (!spec->mux_nids[i]) 2507 break; 2508 err = create_input_src_ctls(codec, i); 2509 if (err < 0) 2510 return err; 2511 return 0; 2512 } 2513 2514 /* bind capture volume/switch */ 2515 static struct snd_kcontrol_new via_bind_cap_vol_ctl = 2516 HDA_BIND_VOL("Capture Volume", 0); 2517 static struct snd_kcontrol_new via_bind_cap_sw_ctl = 2518 HDA_BIND_SW("Capture Switch", 0); 2519 2520 static int init_bind_ctl(struct via_spec *spec, struct hda_bind_ctls **ctl_ret, 2521 struct hda_ctl_ops *ops) 2522 { 2523 struct hda_bind_ctls *ctl; 2524 int i; 2525 2526 ctl = kzalloc(sizeof(*ctl) + sizeof(long) * 4, GFP_KERNEL); 2527 if (!ctl) 2528 return -ENOMEM; 2529 ctl->ops = ops; 2530 for (i = 0; i < spec->num_adc_nids; i++) 2531 ctl->values[i] = 2532 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i], 3, 0, HDA_INPUT); 2533 *ctl_ret = ctl; 2534 return 0; 2535 } 2536 2537 /* create capture and input-src controls for dynamic ADC-switch case */ 2538 static int create_dyn_adc_ctls(struct hda_codec *codec) 2539 { 2540 struct via_spec *spec = codec->spec; 2541 struct snd_kcontrol_new *knew; 2542 int err; 2543 2544 /* set up the bind capture ctls */ 2545 err = init_bind_ctl(spec, &spec->bind_cap_vol, &snd_hda_bind_vol); 2546 if (err < 0) 2547 return err; 2548 err = init_bind_ctl(spec, &spec->bind_cap_sw, &snd_hda_bind_sw); 2549 if (err < 0) 2550 return err; 2551 2552 /* create capture mixer elements */ 2553 knew = via_clone_control(spec, &via_bind_cap_vol_ctl); 2554 if (!knew) 2555 return -ENOMEM; 2556 knew->private_value = (long)spec->bind_cap_vol; 2557 2558 knew = via_clone_control(spec, &via_bind_cap_sw_ctl); 2559 if (!knew) 2560 return -ENOMEM; 2561 knew->private_value = (long)spec->bind_cap_sw; 2562 2563 /* input-source control */ 2564 err = create_input_src_ctls(codec, 1); 2565 if (err < 0) 2566 return err; 2567 return 0; 2568 } 2569 2570 /* parse and create capture-related stuff */ 2571 static int via_auto_create_analog_input_ctls(struct hda_codec *codec) 2572 { 2573 struct via_spec *spec = codec->spec; 2574 int err; 2575 2576 err = parse_analog_inputs(codec); 2577 if (err < 0) 2578 return err; 2579 if (spec->dyn_adc_switch) 2580 err = create_dyn_adc_ctls(codec); 2581 else 2582 err = create_multi_adc_ctls(codec); 2583 if (err < 0) 2584 return err; 2585 err = create_loopback_ctls(codec); 2586 if (err < 0) 2587 return err; 2588 err = create_mic_boost_ctls(codec); 2589 if (err < 0) 2590 return err; 2591 return 0; 2592 } 2593 2594 static void vt1708_set_pinconfig_connect(struct hda_codec *codec, hda_nid_t nid) 2595 { 2596 unsigned int def_conf; 2597 unsigned char seqassoc; 2598 2599 def_conf = snd_hda_codec_get_pincfg(codec, nid); 2600 seqassoc = (unsigned char) get_defcfg_association(def_conf); 2601 seqassoc = (seqassoc << 4) | get_defcfg_sequence(def_conf); 2602 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE 2603 && (seqassoc == 0xf0 || seqassoc == 0xff)) { 2604 def_conf = def_conf & (~(AC_JACK_PORT_BOTH << 30)); 2605 snd_hda_codec_set_pincfg(codec, nid, def_conf); 2606 } 2607 2608 return; 2609 } 2610 2611 static int vt1708_jack_detect_get(struct snd_kcontrol *kcontrol, 2612 struct snd_ctl_elem_value *ucontrol) 2613 { 2614 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2615 struct via_spec *spec = codec->spec; 2616 2617 if (spec->codec_type != VT1708) 2618 return 0; 2619 ucontrol->value.integer.value[0] = spec->vt1708_jack_detect; 2620 return 0; 2621 } 2622 2623 static int vt1708_jack_detect_put(struct snd_kcontrol *kcontrol, 2624 struct snd_ctl_elem_value *ucontrol) 2625 { 2626 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2627 struct via_spec *spec = codec->spec; 2628 int val; 2629 2630 if (spec->codec_type != VT1708) 2631 return 0; 2632 val = !!ucontrol->value.integer.value[0]; 2633 if (spec->vt1708_jack_detect == val) 2634 return 0; 2635 spec->vt1708_jack_detect = val; 2636 if (spec->vt1708_jack_detect && 2637 snd_hda_get_bool_hint(codec, "analog_loopback_hp_detect") != 1) { 2638 mute_aa_path(codec, 1); 2639 notify_aa_path_ctls(codec); 2640 } 2641 via_hp_automute(codec); 2642 vt1708_update_hp_work(spec); 2643 return 1; 2644 } 2645 2646 static const struct snd_kcontrol_new vt1708_jack_detect_ctl = { 2647 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2648 .name = "Jack Detect", 2649 .count = 1, 2650 .info = snd_ctl_boolean_mono_info, 2651 .get = vt1708_jack_detect_get, 2652 .put = vt1708_jack_detect_put, 2653 }; 2654 2655 static void fill_dig_outs(struct hda_codec *codec); 2656 static void fill_dig_in(struct hda_codec *codec); 2657 2658 static int via_parse_auto_config(struct hda_codec *codec) 2659 { 2660 struct via_spec *spec = codec->spec; 2661 int err; 2662 2663 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); 2664 if (err < 0) 2665 return err; 2666 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0]) 2667 return -EINVAL; 2668 2669 err = via_auto_create_multi_out_ctls(codec); 2670 if (err < 0) 2671 return err; 2672 err = via_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]); 2673 if (err < 0) 2674 return err; 2675 err = via_auto_create_speaker_ctls(codec); 2676 if (err < 0) 2677 return err; 2678 err = via_auto_create_loopback_switch(codec); 2679 if (err < 0) 2680 return err; 2681 err = via_auto_create_analog_input_ctls(codec); 2682 if (err < 0) 2683 return err; 2684 2685 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 2686 2687 fill_dig_outs(codec); 2688 fill_dig_in(codec); 2689 2690 if (spec->kctls.list) 2691 spec->mixers[spec->num_mixers++] = spec->kctls.list; 2692 2693 2694 if (spec->hp_dac_nid && spec->hp_mix_path.depth) { 2695 err = via_hp_build(codec); 2696 if (err < 0) 2697 return err; 2698 } 2699 2700 err = via_smart51_build(codec); 2701 if (err < 0) 2702 return err; 2703 2704 /* assign slave outs */ 2705 if (spec->slave_dig_outs[0]) 2706 codec->slave_dig_outs = spec->slave_dig_outs; 2707 2708 return 1; 2709 } 2710 2711 static void via_auto_init_dig_outs(struct hda_codec *codec) 2712 { 2713 struct via_spec *spec = codec->spec; 2714 if (spec->multiout.dig_out_nid) 2715 init_output_pin(codec, spec->autocfg.dig_out_pins[0], PIN_OUT); 2716 if (spec->slave_dig_outs[0]) 2717 init_output_pin(codec, spec->autocfg.dig_out_pins[1], PIN_OUT); 2718 } 2719 2720 static void via_auto_init_dig_in(struct hda_codec *codec) 2721 { 2722 struct via_spec *spec = codec->spec; 2723 if (!spec->dig_in_nid) 2724 return; 2725 snd_hda_set_pin_ctl(codec, spec->autocfg.dig_in_pin, PIN_IN); 2726 } 2727 2728 static void via_jack_output_event(struct hda_codec *codec, struct hda_jack_tbl *tbl) 2729 { 2730 set_widgets_power_state(codec); 2731 via_hp_automute(codec); 2732 } 2733 2734 static void via_jack_powerstate_event(struct hda_codec *codec, struct hda_jack_tbl *tbl) 2735 { 2736 set_widgets_power_state(codec); 2737 } 2738 2739 /* initialize the unsolicited events */ 2740 static void via_auto_init_unsol_event(struct hda_codec *codec) 2741 { 2742 struct via_spec *spec = codec->spec; 2743 struct auto_pin_cfg *cfg = &spec->autocfg; 2744 unsigned int ev; 2745 int i; 2746 hda_jack_callback cb; 2747 2748 if (cfg->hp_pins[0] && is_jack_detectable(codec, cfg->hp_pins[0])) 2749 snd_hda_jack_detect_enable_callback(codec, cfg->hp_pins[0], 2750 VIA_HP_EVENT | VIA_JACK_EVENT, 2751 via_jack_output_event); 2752 2753 if (cfg->speaker_pins[0]) 2754 ev = VIA_LINE_EVENT; 2755 else 2756 ev = 0; 2757 cb = ev ? via_jack_output_event : via_jack_powerstate_event; 2758 2759 for (i = 0; i < cfg->line_outs; i++) { 2760 if (cfg->line_out_pins[i] && 2761 is_jack_detectable(codec, cfg->line_out_pins[i])) 2762 snd_hda_jack_detect_enable_callback(codec, cfg->line_out_pins[i], 2763 ev | VIA_JACK_EVENT, cb); 2764 } 2765 2766 for (i = 0; i < cfg->num_inputs; i++) { 2767 if (is_jack_detectable(codec, cfg->inputs[i].pin)) 2768 snd_hda_jack_detect_enable_callback(codec, cfg->inputs[i].pin, 2769 VIA_JACK_EVENT, 2770 via_jack_powerstate_event); 2771 } 2772 } 2773 2774 static int via_init(struct hda_codec *codec) 2775 { 2776 struct via_spec *spec = codec->spec; 2777 int i; 2778 2779 for (i = 0; i < spec->num_iverbs; i++) 2780 snd_hda_sequence_write(codec, spec->init_verbs[i]); 2781 2782 /* init power states */ 2783 set_widgets_power_state(codec); 2784 __analog_low_current_mode(codec, true); 2785 2786 via_auto_init_multi_out(codec); 2787 via_auto_init_hp_out(codec); 2788 via_auto_init_speaker_out(codec); 2789 via_auto_init_analog_input(codec); 2790 via_auto_init_dig_outs(codec); 2791 via_auto_init_dig_in(codec); 2792 2793 via_auto_init_unsol_event(codec); 2794 2795 via_hp_automute(codec); 2796 vt1708_update_hp_work(spec); 2797 2798 return 0; 2799 } 2800 2801 static void vt1708_update_hp_jack_state(struct work_struct *work) 2802 { 2803 struct via_spec *spec = container_of(work, struct via_spec, 2804 vt1708_hp_work.work); 2805 if (spec->codec_type != VT1708) 2806 return; 2807 snd_hda_jack_set_dirty_all(spec->codec); 2808 /* if jack state toggled */ 2809 if (spec->vt1708_hp_present 2810 != snd_hda_jack_detect(spec->codec, spec->autocfg.hp_pins[0])) { 2811 spec->vt1708_hp_present ^= 1; 2812 via_hp_automute(spec->codec); 2813 } 2814 if (spec->vt1708_jack_detect) 2815 schedule_delayed_work(&spec->vt1708_hp_work, 2816 msecs_to_jiffies(100)); 2817 } 2818 2819 static int get_mux_nids(struct hda_codec *codec) 2820 { 2821 struct via_spec *spec = codec->spec; 2822 hda_nid_t nid, conn[8]; 2823 unsigned int type; 2824 int i, n; 2825 2826 for (i = 0; i < spec->num_adc_nids; i++) { 2827 nid = spec->adc_nids[i]; 2828 while (nid) { 2829 type = get_wcaps_type(get_wcaps(codec, nid)); 2830 if (type == AC_WID_PIN) 2831 break; 2832 n = snd_hda_get_connections(codec, nid, conn, 2833 ARRAY_SIZE(conn)); 2834 if (n <= 0) 2835 break; 2836 if (n > 1) { 2837 spec->mux_nids[i] = nid; 2838 break; 2839 } 2840 nid = conn[0]; 2841 } 2842 } 2843 return 0; 2844 } 2845 2846 static int patch_vt1708(struct hda_codec *codec) 2847 { 2848 struct via_spec *spec; 2849 int err; 2850 2851 /* create a codec specific record */ 2852 spec = via_new_spec(codec); 2853 if (spec == NULL) 2854 return -ENOMEM; 2855 2856 spec->aa_mix_nid = 0x17; 2857 2858 /* Add HP and CD pin config connect bit re-config action */ 2859 vt1708_set_pinconfig_connect(codec, VT1708_HP_PIN_NID); 2860 vt1708_set_pinconfig_connect(codec, VT1708_CD_PIN_NID); 2861 2862 /* automatic parse from the BIOS config */ 2863 err = via_parse_auto_config(codec); 2864 if (err < 0) { 2865 via_free(codec); 2866 return err; 2867 } 2868 2869 /* add jack detect on/off control */ 2870 if (!via_clone_control(spec, &vt1708_jack_detect_ctl)) 2871 return -ENOMEM; 2872 2873 /* disable 32bit format on VT1708 */ 2874 if (codec->vendor_id == 0x11061708) 2875 spec->stream_analog_playback = &vt1708_pcm_analog_s16_playback; 2876 2877 spec->init_verbs[spec->num_iverbs++] = vt1708_init_verbs; 2878 2879 codec->patch_ops = via_patch_ops; 2880 2881 INIT_DELAYED_WORK(&spec->vt1708_hp_work, vt1708_update_hp_jack_state); 2882 return 0; 2883 } 2884 2885 static int patch_vt1709(struct hda_codec *codec) 2886 { 2887 struct via_spec *spec; 2888 int err; 2889 2890 /* create a codec specific record */ 2891 spec = via_new_spec(codec); 2892 if (spec == NULL) 2893 return -ENOMEM; 2894 2895 spec->aa_mix_nid = 0x18; 2896 2897 err = via_parse_auto_config(codec); 2898 if (err < 0) { 2899 via_free(codec); 2900 return err; 2901 } 2902 2903 codec->patch_ops = via_patch_ops; 2904 2905 return 0; 2906 } 2907 2908 static void set_widgets_power_state_vt1708B(struct hda_codec *codec) 2909 { 2910 struct via_spec *spec = codec->spec; 2911 int imux_is_smixer; 2912 unsigned int parm; 2913 int is_8ch = 0; 2914 if ((spec->codec_type != VT1708B_4CH) && 2915 (codec->vendor_id != 0x11064397)) 2916 is_8ch = 1; 2917 2918 /* SW0 (17h) = stereo mixer */ 2919 imux_is_smixer = 2920 (snd_hda_codec_read(codec, 0x17, 0, AC_VERB_GET_CONNECT_SEL, 0x00) 2921 == ((spec->codec_type == VT1708S) ? 5 : 0)); 2922 /* inputs */ 2923 /* PW 1/2/5 (1ah/1bh/1eh) */ 2924 parm = AC_PWRST_D3; 2925 set_pin_power_state(codec, 0x1a, &parm); 2926 set_pin_power_state(codec, 0x1b, &parm); 2927 set_pin_power_state(codec, 0x1e, &parm); 2928 if (imux_is_smixer) 2929 parm = AC_PWRST_D0; 2930 /* SW0 (17h), AIW 0/1 (13h/14h) */ 2931 update_power_state(codec, 0x17, parm); 2932 update_power_state(codec, 0x13, parm); 2933 update_power_state(codec, 0x14, parm); 2934 2935 /* outputs */ 2936 /* PW0 (19h), SW1 (18h), AOW1 (11h) */ 2937 parm = AC_PWRST_D3; 2938 set_pin_power_state(codec, 0x19, &parm); 2939 if (spec->smart51_enabled) 2940 set_pin_power_state(codec, 0x1b, &parm); 2941 update_power_state(codec, 0x18, parm); 2942 update_power_state(codec, 0x11, parm); 2943 2944 /* PW6 (22h), SW2 (26h), AOW2 (24h) */ 2945 if (is_8ch) { 2946 parm = AC_PWRST_D3; 2947 set_pin_power_state(codec, 0x22, &parm); 2948 if (spec->smart51_enabled) 2949 set_pin_power_state(codec, 0x1a, &parm); 2950 update_power_state(codec, 0x26, parm); 2951 update_power_state(codec, 0x24, parm); 2952 } else if (codec->vendor_id == 0x11064397) { 2953 /* PW7(23h), SW2(27h), AOW2(25h) */ 2954 parm = AC_PWRST_D3; 2955 set_pin_power_state(codec, 0x23, &parm); 2956 if (spec->smart51_enabled) 2957 set_pin_power_state(codec, 0x1a, &parm); 2958 update_power_state(codec, 0x27, parm); 2959 update_power_state(codec, 0x25, parm); 2960 } 2961 2962 /* PW 3/4/7 (1ch/1dh/23h) */ 2963 parm = AC_PWRST_D3; 2964 /* force to D0 for internal Speaker */ 2965 set_pin_power_state(codec, 0x1c, &parm); 2966 set_pin_power_state(codec, 0x1d, &parm); 2967 if (is_8ch) 2968 set_pin_power_state(codec, 0x23, &parm); 2969 2970 /* MW0 (16h), Sw3 (27h), AOW 0/3 (10h/25h) */ 2971 update_power_state(codec, 0x16, imux_is_smixer ? AC_PWRST_D0 : parm); 2972 update_power_state(codec, 0x10, parm); 2973 if (is_8ch) { 2974 update_power_state(codec, 0x25, parm); 2975 update_power_state(codec, 0x27, parm); 2976 } else if (codec->vendor_id == 0x11064397 && spec->hp_independent_mode) 2977 update_power_state(codec, 0x25, parm); 2978 } 2979 2980 static int patch_vt1708S(struct hda_codec *codec); 2981 static int patch_vt1708B(struct hda_codec *codec) 2982 { 2983 struct via_spec *spec; 2984 int err; 2985 2986 if (get_codec_type(codec) == VT1708BCE) 2987 return patch_vt1708S(codec); 2988 2989 /* create a codec specific record */ 2990 spec = via_new_spec(codec); 2991 if (spec == NULL) 2992 return -ENOMEM; 2993 2994 spec->aa_mix_nid = 0x16; 2995 2996 /* automatic parse from the BIOS config */ 2997 err = via_parse_auto_config(codec); 2998 if (err < 0) { 2999 via_free(codec); 3000 return err; 3001 } 3002 3003 codec->patch_ops = via_patch_ops; 3004 3005 spec->set_widgets_power_state = set_widgets_power_state_vt1708B; 3006 3007 return 0; 3008 } 3009 3010 /* Patch for VT1708S */ 3011 static const struct hda_verb vt1708S_init_verbs[] = { 3012 /* Enable Mic Boost Volume backdoor */ 3013 {0x1, 0xf98, 0x1}, 3014 /* don't bybass mixer */ 3015 {0x1, 0xf88, 0xc0}, 3016 { } 3017 }; 3018 3019 /* fill out digital output widgets; one for master and one for slave outputs */ 3020 static void fill_dig_outs(struct hda_codec *codec) 3021 { 3022 struct via_spec *spec = codec->spec; 3023 int i; 3024 3025 for (i = 0; i < spec->autocfg.dig_outs; i++) { 3026 hda_nid_t nid; 3027 int conn; 3028 3029 nid = spec->autocfg.dig_out_pins[i]; 3030 if (!nid) 3031 continue; 3032 conn = snd_hda_get_connections(codec, nid, &nid, 1); 3033 if (conn < 1) 3034 continue; 3035 if (!spec->multiout.dig_out_nid) 3036 spec->multiout.dig_out_nid = nid; 3037 else { 3038 spec->slave_dig_outs[0] = nid; 3039 break; /* at most two dig outs */ 3040 } 3041 } 3042 } 3043 3044 static void fill_dig_in(struct hda_codec *codec) 3045 { 3046 struct via_spec *spec = codec->spec; 3047 hda_nid_t dig_nid; 3048 int i, err; 3049 3050 if (!spec->autocfg.dig_in_pin) 3051 return; 3052 3053 dig_nid = codec->start_nid; 3054 for (i = 0; i < codec->num_nodes; i++, dig_nid++) { 3055 unsigned int wcaps = get_wcaps(codec, dig_nid); 3056 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN) 3057 continue; 3058 if (!(wcaps & AC_WCAP_DIGITAL)) 3059 continue; 3060 if (!(wcaps & AC_WCAP_CONN_LIST)) 3061 continue; 3062 err = get_connection_index(codec, dig_nid, 3063 spec->autocfg.dig_in_pin); 3064 if (err >= 0) { 3065 spec->dig_in_nid = dig_nid; 3066 break; 3067 } 3068 } 3069 } 3070 3071 static void override_mic_boost(struct hda_codec *codec, hda_nid_t pin, 3072 int offset, int num_steps, int step_size) 3073 { 3074 snd_hda_override_amp_caps(codec, pin, HDA_INPUT, 3075 (offset << AC_AMPCAP_OFFSET_SHIFT) | 3076 (num_steps << AC_AMPCAP_NUM_STEPS_SHIFT) | 3077 (step_size << AC_AMPCAP_STEP_SIZE_SHIFT) | 3078 (0 << AC_AMPCAP_MUTE_SHIFT)); 3079 } 3080 3081 static int patch_vt1708S(struct hda_codec *codec) 3082 { 3083 struct via_spec *spec; 3084 int err; 3085 3086 /* create a codec specific record */ 3087 spec = via_new_spec(codec); 3088 if (spec == NULL) 3089 return -ENOMEM; 3090 3091 spec->aa_mix_nid = 0x16; 3092 override_mic_boost(codec, 0x1a, 0, 3, 40); 3093 override_mic_boost(codec, 0x1e, 0, 3, 40); 3094 3095 /* automatic parse from the BIOS config */ 3096 err = via_parse_auto_config(codec); 3097 if (err < 0) { 3098 via_free(codec); 3099 return err; 3100 } 3101 3102 spec->init_verbs[spec->num_iverbs++] = vt1708S_init_verbs; 3103 3104 codec->patch_ops = via_patch_ops; 3105 3106 /* correct names for VT1708BCE */ 3107 if (get_codec_type(codec) == VT1708BCE) { 3108 kfree(codec->chip_name); 3109 codec->chip_name = kstrdup("VT1708BCE", GFP_KERNEL); 3110 snprintf(codec->bus->card->mixername, 3111 sizeof(codec->bus->card->mixername), 3112 "%s %s", codec->vendor_name, codec->chip_name); 3113 } 3114 /* correct names for VT1705 */ 3115 if (codec->vendor_id == 0x11064397) { 3116 kfree(codec->chip_name); 3117 codec->chip_name = kstrdup("VT1705", GFP_KERNEL); 3118 snprintf(codec->bus->card->mixername, 3119 sizeof(codec->bus->card->mixername), 3120 "%s %s", codec->vendor_name, codec->chip_name); 3121 } 3122 spec->set_widgets_power_state = set_widgets_power_state_vt1708B; 3123 return 0; 3124 } 3125 3126 /* Patch for VT1702 */ 3127 3128 static const struct hda_verb vt1702_init_verbs[] = { 3129 /* mixer enable */ 3130 {0x1, 0xF88, 0x3}, 3131 /* GPIO 0~2 */ 3132 {0x1, 0xF82, 0x3F}, 3133 { } 3134 }; 3135 3136 static void set_widgets_power_state_vt1702(struct hda_codec *codec) 3137 { 3138 int imux_is_smixer = 3139 snd_hda_codec_read(codec, 0x13, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3; 3140 unsigned int parm; 3141 /* inputs */ 3142 /* PW 1/2/5 (14h/15h/18h) */ 3143 parm = AC_PWRST_D3; 3144 set_pin_power_state(codec, 0x14, &parm); 3145 set_pin_power_state(codec, 0x15, &parm); 3146 set_pin_power_state(codec, 0x18, &parm); 3147 if (imux_is_smixer) 3148 parm = AC_PWRST_D0; /* SW0 (13h) = stereo mixer (idx 3) */ 3149 /* SW0 (13h), AIW 0/1/2 (12h/1fh/20h) */ 3150 update_power_state(codec, 0x13, parm); 3151 update_power_state(codec, 0x12, parm); 3152 update_power_state(codec, 0x1f, parm); 3153 update_power_state(codec, 0x20, parm); 3154 3155 /* outputs */ 3156 /* PW 3/4 (16h/17h) */ 3157 parm = AC_PWRST_D3; 3158 set_pin_power_state(codec, 0x17, &parm); 3159 set_pin_power_state(codec, 0x16, &parm); 3160 /* MW0 (1ah), AOW 0/1 (10h/1dh) */ 3161 update_power_state(codec, 0x1a, imux_is_smixer ? AC_PWRST_D0 : parm); 3162 update_power_state(codec, 0x10, parm); 3163 update_power_state(codec, 0x1d, parm); 3164 } 3165 3166 static int patch_vt1702(struct hda_codec *codec) 3167 { 3168 struct via_spec *spec; 3169 int err; 3170 3171 /* create a codec specific record */ 3172 spec = via_new_spec(codec); 3173 if (spec == NULL) 3174 return -ENOMEM; 3175 3176 spec->aa_mix_nid = 0x1a; 3177 3178 /* limit AA path volume to 0 dB */ 3179 snd_hda_override_amp_caps(codec, 0x1A, HDA_INPUT, 3180 (0x17 << AC_AMPCAP_OFFSET_SHIFT) | 3181 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) | 3182 (0x5 << AC_AMPCAP_STEP_SIZE_SHIFT) | 3183 (1 << AC_AMPCAP_MUTE_SHIFT)); 3184 3185 /* automatic parse from the BIOS config */ 3186 err = via_parse_auto_config(codec); 3187 if (err < 0) { 3188 via_free(codec); 3189 return err; 3190 } 3191 3192 spec->init_verbs[spec->num_iverbs++] = vt1702_init_verbs; 3193 3194 codec->patch_ops = via_patch_ops; 3195 3196 spec->set_widgets_power_state = set_widgets_power_state_vt1702; 3197 return 0; 3198 } 3199 3200 /* Patch for VT1718S */ 3201 3202 static const struct hda_verb vt1718S_init_verbs[] = { 3203 /* Enable MW0 adjust Gain 5 */ 3204 {0x1, 0xfb2, 0x10}, 3205 /* Enable Boost Volume backdoor */ 3206 {0x1, 0xf88, 0x8}, 3207 3208 { } 3209 }; 3210 3211 static void set_widgets_power_state_vt1718S(struct hda_codec *codec) 3212 { 3213 struct via_spec *spec = codec->spec; 3214 int imux_is_smixer; 3215 unsigned int parm, parm2; 3216 /* MUX6 (1eh) = stereo mixer */ 3217 imux_is_smixer = 3218 snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 5; 3219 /* inputs */ 3220 /* PW 5/6/7 (29h/2ah/2bh) */ 3221 parm = AC_PWRST_D3; 3222 set_pin_power_state(codec, 0x29, &parm); 3223 set_pin_power_state(codec, 0x2a, &parm); 3224 set_pin_power_state(codec, 0x2b, &parm); 3225 if (imux_is_smixer) 3226 parm = AC_PWRST_D0; 3227 /* MUX6/7 (1eh/1fh), AIW 0/1 (10h/11h) */ 3228 update_power_state(codec, 0x1e, parm); 3229 update_power_state(codec, 0x1f, parm); 3230 update_power_state(codec, 0x10, parm); 3231 update_power_state(codec, 0x11, parm); 3232 3233 /* outputs */ 3234 /* PW3 (27h), MW2 (1ah), AOW3 (bh) */ 3235 parm = AC_PWRST_D3; 3236 set_pin_power_state(codec, 0x27, &parm); 3237 update_power_state(codec, 0x1a, parm); 3238 parm2 = parm; /* for pin 0x0b */ 3239 3240 /* PW2 (26h), AOW2 (ah) */ 3241 parm = AC_PWRST_D3; 3242 set_pin_power_state(codec, 0x26, &parm); 3243 if (spec->smart51_enabled) 3244 set_pin_power_state(codec, 0x2b, &parm); 3245 update_power_state(codec, 0xa, parm); 3246 3247 /* PW0 (24h), AOW0 (8h) */ 3248 parm = AC_PWRST_D3; 3249 set_pin_power_state(codec, 0x24, &parm); 3250 if (!spec->hp_independent_mode) /* check for redirected HP */ 3251 set_pin_power_state(codec, 0x28, &parm); 3252 update_power_state(codec, 0x8, parm); 3253 if (!spec->hp_independent_mode && parm2 != AC_PWRST_D3) 3254 parm = parm2; 3255 update_power_state(codec, 0xb, parm); 3256 /* MW9 (21h), Mw2 (1ah), AOW0 (8h) */ 3257 update_power_state(codec, 0x21, imux_is_smixer ? AC_PWRST_D0 : parm); 3258 3259 /* PW1 (25h), AOW1 (9h) */ 3260 parm = AC_PWRST_D3; 3261 set_pin_power_state(codec, 0x25, &parm); 3262 if (spec->smart51_enabled) 3263 set_pin_power_state(codec, 0x2a, &parm); 3264 update_power_state(codec, 0x9, parm); 3265 3266 if (spec->hp_independent_mode) { 3267 /* PW4 (28h), MW3 (1bh), MUX1(34h), AOW4 (ch) */ 3268 parm = AC_PWRST_D3; 3269 set_pin_power_state(codec, 0x28, &parm); 3270 update_power_state(codec, 0x1b, parm); 3271 update_power_state(codec, 0x34, parm); 3272 update_power_state(codec, 0xc, parm); 3273 } 3274 } 3275 3276 /* Add a connection to the primary DAC from AA-mixer for some codecs 3277 * This isn't listed from the raw info, but the chip has a secret connection. 3278 */ 3279 static int add_secret_dac_path(struct hda_codec *codec) 3280 { 3281 struct via_spec *spec = codec->spec; 3282 int i, nums; 3283 hda_nid_t conn[8]; 3284 hda_nid_t nid; 3285 3286 if (!spec->aa_mix_nid) 3287 return 0; 3288 nums = snd_hda_get_connections(codec, spec->aa_mix_nid, conn, 3289 ARRAY_SIZE(conn) - 1); 3290 for (i = 0; i < nums; i++) { 3291 if (get_wcaps_type(get_wcaps(codec, conn[i])) == AC_WID_AUD_OUT) 3292 return 0; 3293 } 3294 3295 /* find the primary DAC and add to the connection list */ 3296 nid = codec->start_nid; 3297 for (i = 0; i < codec->num_nodes; i++, nid++) { 3298 unsigned int caps = get_wcaps(codec, nid); 3299 if (get_wcaps_type(caps) == AC_WID_AUD_OUT && 3300 !(caps & AC_WCAP_DIGITAL)) { 3301 conn[nums++] = nid; 3302 return snd_hda_override_conn_list(codec, 3303 spec->aa_mix_nid, 3304 nums, conn); 3305 } 3306 } 3307 return 0; 3308 } 3309 3310 3311 static int patch_vt1718S(struct hda_codec *codec) 3312 { 3313 struct via_spec *spec; 3314 int err; 3315 3316 /* create a codec specific record */ 3317 spec = via_new_spec(codec); 3318 if (spec == NULL) 3319 return -ENOMEM; 3320 3321 spec->aa_mix_nid = 0x21; 3322 override_mic_boost(codec, 0x2b, 0, 3, 40); 3323 override_mic_boost(codec, 0x29, 0, 3, 40); 3324 add_secret_dac_path(codec); 3325 3326 /* automatic parse from the BIOS config */ 3327 err = via_parse_auto_config(codec); 3328 if (err < 0) { 3329 via_free(codec); 3330 return err; 3331 } 3332 3333 spec->init_verbs[spec->num_iverbs++] = vt1718S_init_verbs; 3334 3335 codec->patch_ops = via_patch_ops; 3336 3337 spec->set_widgets_power_state = set_widgets_power_state_vt1718S; 3338 3339 return 0; 3340 } 3341 3342 /* Patch for VT1716S */ 3343 3344 static int vt1716s_dmic_info(struct snd_kcontrol *kcontrol, 3345 struct snd_ctl_elem_info *uinfo) 3346 { 3347 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 3348 uinfo->count = 1; 3349 uinfo->value.integer.min = 0; 3350 uinfo->value.integer.max = 1; 3351 return 0; 3352 } 3353 3354 static int vt1716s_dmic_get(struct snd_kcontrol *kcontrol, 3355 struct snd_ctl_elem_value *ucontrol) 3356 { 3357 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3358 int index = 0; 3359 3360 index = snd_hda_codec_read(codec, 0x26, 0, 3361 AC_VERB_GET_CONNECT_SEL, 0); 3362 if (index != -1) 3363 *ucontrol->value.integer.value = index; 3364 3365 return 0; 3366 } 3367 3368 static int vt1716s_dmic_put(struct snd_kcontrol *kcontrol, 3369 struct snd_ctl_elem_value *ucontrol) 3370 { 3371 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3372 struct via_spec *spec = codec->spec; 3373 int index = *ucontrol->value.integer.value; 3374 3375 snd_hda_codec_write(codec, 0x26, 0, 3376 AC_VERB_SET_CONNECT_SEL, index); 3377 spec->dmic_enabled = index; 3378 set_widgets_power_state(codec); 3379 return 1; 3380 } 3381 3382 static const struct snd_kcontrol_new vt1716s_dmic_mixer[] = { 3383 HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x22, 0x0, HDA_INPUT), 3384 { 3385 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3386 .name = "Digital Mic Capture Switch", 3387 .subdevice = HDA_SUBDEV_NID_FLAG | 0x26, 3388 .count = 1, 3389 .info = vt1716s_dmic_info, 3390 .get = vt1716s_dmic_get, 3391 .put = vt1716s_dmic_put, 3392 }, 3393 {} /* end */ 3394 }; 3395 3396 3397 /* mono-out mixer elements */ 3398 static const struct snd_kcontrol_new vt1716S_mono_out_mixer[] = { 3399 HDA_CODEC_MUTE("Mono Playback Switch", 0x2a, 0x0, HDA_OUTPUT), 3400 { } /* end */ 3401 }; 3402 3403 static const struct hda_verb vt1716S_init_verbs[] = { 3404 /* Enable Boost Volume backdoor */ 3405 {0x1, 0xf8a, 0x80}, 3406 /* don't bybass mixer */ 3407 {0x1, 0xf88, 0xc0}, 3408 /* Enable mono output */ 3409 {0x1, 0xf90, 0x08}, 3410 { } 3411 }; 3412 3413 static void set_widgets_power_state_vt1716S(struct hda_codec *codec) 3414 { 3415 struct via_spec *spec = codec->spec; 3416 int imux_is_smixer; 3417 unsigned int parm; 3418 unsigned int mono_out, present; 3419 /* SW0 (17h) = stereo mixer */ 3420 imux_is_smixer = 3421 (snd_hda_codec_read(codec, 0x17, 0, 3422 AC_VERB_GET_CONNECT_SEL, 0x00) == 5); 3423 /* inputs */ 3424 /* PW 1/2/5 (1ah/1bh/1eh) */ 3425 parm = AC_PWRST_D3; 3426 set_pin_power_state(codec, 0x1a, &parm); 3427 set_pin_power_state(codec, 0x1b, &parm); 3428 set_pin_power_state(codec, 0x1e, &parm); 3429 if (imux_is_smixer) 3430 parm = AC_PWRST_D0; 3431 /* SW0 (17h), AIW0(13h) */ 3432 update_power_state(codec, 0x17, parm); 3433 update_power_state(codec, 0x13, parm); 3434 3435 parm = AC_PWRST_D3; 3436 set_pin_power_state(codec, 0x1e, &parm); 3437 /* PW11 (22h) */ 3438 if (spec->dmic_enabled) 3439 set_pin_power_state(codec, 0x22, &parm); 3440 else 3441 update_power_state(codec, 0x22, AC_PWRST_D3); 3442 3443 /* SW2(26h), AIW1(14h) */ 3444 update_power_state(codec, 0x26, parm); 3445 update_power_state(codec, 0x14, parm); 3446 3447 /* outputs */ 3448 /* PW0 (19h), SW1 (18h), AOW1 (11h) */ 3449 parm = AC_PWRST_D3; 3450 set_pin_power_state(codec, 0x19, &parm); 3451 /* Smart 5.1 PW2(1bh) */ 3452 if (spec->smart51_enabled) 3453 set_pin_power_state(codec, 0x1b, &parm); 3454 update_power_state(codec, 0x18, parm); 3455 update_power_state(codec, 0x11, parm); 3456 3457 /* PW7 (23h), SW3 (27h), AOW3 (25h) */ 3458 parm = AC_PWRST_D3; 3459 set_pin_power_state(codec, 0x23, &parm); 3460 /* Smart 5.1 PW1(1ah) */ 3461 if (spec->smart51_enabled) 3462 set_pin_power_state(codec, 0x1a, &parm); 3463 update_power_state(codec, 0x27, parm); 3464 3465 /* Smart 5.1 PW5(1eh) */ 3466 if (spec->smart51_enabled) 3467 set_pin_power_state(codec, 0x1e, &parm); 3468 update_power_state(codec, 0x25, parm); 3469 3470 /* Mono out */ 3471 /* SW4(28h)->MW1(29h)-> PW12 (2ah)*/ 3472 present = snd_hda_jack_detect(codec, 0x1c); 3473 3474 if (present) 3475 mono_out = 0; 3476 else { 3477 present = snd_hda_jack_detect(codec, 0x1d); 3478 if (!spec->hp_independent_mode && present) 3479 mono_out = 0; 3480 else 3481 mono_out = 1; 3482 } 3483 parm = mono_out ? AC_PWRST_D0 : AC_PWRST_D3; 3484 update_power_state(codec, 0x28, parm); 3485 update_power_state(codec, 0x29, parm); 3486 update_power_state(codec, 0x2a, parm); 3487 3488 /* PW 3/4 (1ch/1dh) */ 3489 parm = AC_PWRST_D3; 3490 set_pin_power_state(codec, 0x1c, &parm); 3491 set_pin_power_state(codec, 0x1d, &parm); 3492 /* HP Independent Mode, power on AOW3 */ 3493 if (spec->hp_independent_mode) 3494 update_power_state(codec, 0x25, parm); 3495 3496 /* force to D0 for internal Speaker */ 3497 /* MW0 (16h), AOW0 (10h) */ 3498 update_power_state(codec, 0x16, imux_is_smixer ? AC_PWRST_D0 : parm); 3499 update_power_state(codec, 0x10, mono_out ? AC_PWRST_D0 : parm); 3500 } 3501 3502 static int patch_vt1716S(struct hda_codec *codec) 3503 { 3504 struct via_spec *spec; 3505 int err; 3506 3507 /* create a codec specific record */ 3508 spec = via_new_spec(codec); 3509 if (spec == NULL) 3510 return -ENOMEM; 3511 3512 spec->aa_mix_nid = 0x16; 3513 override_mic_boost(codec, 0x1a, 0, 3, 40); 3514 override_mic_boost(codec, 0x1e, 0, 3, 40); 3515 3516 /* automatic parse from the BIOS config */ 3517 err = via_parse_auto_config(codec); 3518 if (err < 0) { 3519 via_free(codec); 3520 return err; 3521 } 3522 3523 spec->init_verbs[spec->num_iverbs++] = vt1716S_init_verbs; 3524 3525 spec->mixers[spec->num_mixers] = vt1716s_dmic_mixer; 3526 spec->num_mixers++; 3527 3528 spec->mixers[spec->num_mixers++] = vt1716S_mono_out_mixer; 3529 3530 codec->patch_ops = via_patch_ops; 3531 3532 spec->set_widgets_power_state = set_widgets_power_state_vt1716S; 3533 return 0; 3534 } 3535 3536 /* for vt2002P */ 3537 3538 static const struct hda_verb vt2002P_init_verbs[] = { 3539 /* Class-D speaker related verbs */ 3540 {0x1, 0xfe0, 0x4}, 3541 {0x1, 0xfe9, 0x80}, 3542 {0x1, 0xfe2, 0x22}, 3543 /* Enable Boost Volume backdoor */ 3544 {0x1, 0xfb9, 0x24}, 3545 /* Enable AOW0 to MW9 */ 3546 {0x1, 0xfb8, 0x88}, 3547 { } 3548 }; 3549 3550 static const struct hda_verb vt1802_init_verbs[] = { 3551 /* Enable Boost Volume backdoor */ 3552 {0x1, 0xfb9, 0x24}, 3553 /* Enable AOW0 to MW9 */ 3554 {0x1, 0xfb8, 0x88}, 3555 { } 3556 }; 3557 3558 static void set_widgets_power_state_vt2002P(struct hda_codec *codec) 3559 { 3560 struct via_spec *spec = codec->spec; 3561 int imux_is_smixer; 3562 unsigned int parm; 3563 unsigned int present; 3564 /* MUX9 (1eh) = stereo mixer */ 3565 imux_is_smixer = 3566 snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3; 3567 /* inputs */ 3568 /* PW 5/6/7 (29h/2ah/2bh) */ 3569 parm = AC_PWRST_D3; 3570 set_pin_power_state(codec, 0x29, &parm); 3571 set_pin_power_state(codec, 0x2a, &parm); 3572 set_pin_power_state(codec, 0x2b, &parm); 3573 parm = AC_PWRST_D0; 3574 /* MUX9/10 (1eh/1fh), AIW 0/1 (10h/11h) */ 3575 update_power_state(codec, 0x1e, parm); 3576 update_power_state(codec, 0x1f, parm); 3577 update_power_state(codec, 0x10, parm); 3578 update_power_state(codec, 0x11, parm); 3579 3580 /* outputs */ 3581 /* AOW0 (8h)*/ 3582 update_power_state(codec, 0x8, parm); 3583 3584 if (spec->codec_type == VT1802) { 3585 /* PW4 (28h), MW4 (18h), MUX4(38h) */ 3586 parm = AC_PWRST_D3; 3587 set_pin_power_state(codec, 0x28, &parm); 3588 update_power_state(codec, 0x18, parm); 3589 update_power_state(codec, 0x38, parm); 3590 } else { 3591 /* PW4 (26h), MW4 (1ch), MUX4(37h) */ 3592 parm = AC_PWRST_D3; 3593 set_pin_power_state(codec, 0x26, &parm); 3594 update_power_state(codec, 0x1c, parm); 3595 update_power_state(codec, 0x37, parm); 3596 } 3597 3598 if (spec->codec_type == VT1802) { 3599 /* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */ 3600 parm = AC_PWRST_D3; 3601 set_pin_power_state(codec, 0x25, &parm); 3602 update_power_state(codec, 0x15, parm); 3603 update_power_state(codec, 0x35, parm); 3604 } else { 3605 /* PW1 (25h), MW1 (19h), MUX1(35h), AOW1 (9h) */ 3606 parm = AC_PWRST_D3; 3607 set_pin_power_state(codec, 0x25, &parm); 3608 update_power_state(codec, 0x19, parm); 3609 update_power_state(codec, 0x35, parm); 3610 } 3611 3612 if (spec->hp_independent_mode) 3613 update_power_state(codec, 0x9, AC_PWRST_D0); 3614 3615 /* Class-D */ 3616 /* PW0 (24h), MW0(18h/14h), MUX0(34h) */ 3617 present = snd_hda_jack_detect(codec, 0x25); 3618 3619 parm = AC_PWRST_D3; 3620 set_pin_power_state(codec, 0x24, &parm); 3621 parm = present ? AC_PWRST_D3 : AC_PWRST_D0; 3622 if (spec->codec_type == VT1802) 3623 update_power_state(codec, 0x14, parm); 3624 else 3625 update_power_state(codec, 0x18, parm); 3626 update_power_state(codec, 0x34, parm); 3627 3628 /* Mono Out */ 3629 present = snd_hda_jack_detect(codec, 0x26); 3630 3631 parm = present ? AC_PWRST_D3 : AC_PWRST_D0; 3632 if (spec->codec_type == VT1802) { 3633 /* PW15 (33h), MW8(1ch), MUX8(3ch) */ 3634 update_power_state(codec, 0x33, parm); 3635 update_power_state(codec, 0x1c, parm); 3636 update_power_state(codec, 0x3c, parm); 3637 } else { 3638 /* PW15 (31h), MW8(17h), MUX8(3bh) */ 3639 update_power_state(codec, 0x31, parm); 3640 update_power_state(codec, 0x17, parm); 3641 update_power_state(codec, 0x3b, parm); 3642 } 3643 /* MW9 (21h) */ 3644 if (imux_is_smixer || !is_aa_path_mute(codec)) 3645 update_power_state(codec, 0x21, AC_PWRST_D0); 3646 else 3647 update_power_state(codec, 0x21, AC_PWRST_D3); 3648 } 3649 3650 /* 3651 * pin fix-up 3652 */ 3653 enum { 3654 VIA_FIXUP_INTMIC_BOOST, 3655 VIA_FIXUP_ASUS_G75, 3656 }; 3657 3658 static void via_fixup_intmic_boost(struct hda_codec *codec, 3659 const struct hda_fixup *fix, int action) 3660 { 3661 if (action == HDA_FIXUP_ACT_PRE_PROBE) 3662 override_mic_boost(codec, 0x30, 0, 2, 40); 3663 } 3664 3665 static const struct hda_fixup via_fixups[] = { 3666 [VIA_FIXUP_INTMIC_BOOST] = { 3667 .type = HDA_FIXUP_FUNC, 3668 .v.func = via_fixup_intmic_boost, 3669 }, 3670 [VIA_FIXUP_ASUS_G75] = { 3671 .type = HDA_FIXUP_PINS, 3672 .v.pins = (const struct hda_pintbl[]) { 3673 /* set 0x24 and 0x33 as speakers */ 3674 { 0x24, 0x991301f0 }, 3675 { 0x33, 0x991301f1 }, /* subwoofer */ 3676 { } 3677 } 3678 }, 3679 }; 3680 3681 static const struct snd_pci_quirk vt2002p_fixups[] = { 3682 SND_PCI_QUIRK(0x1043, 0x1487, "Asus G75", VIA_FIXUP_ASUS_G75), 3683 SND_PCI_QUIRK(0x1043, 0x8532, "Asus X202E", VIA_FIXUP_INTMIC_BOOST), 3684 {} 3685 }; 3686 3687 /* NIDs 0x24 and 0x33 on VT1802 have connections to non-existing NID 0x3e 3688 * Replace this with mixer NID 0x1c 3689 */ 3690 static void fix_vt1802_connections(struct hda_codec *codec) 3691 { 3692 static hda_nid_t conn_24[] = { 0x14, 0x1c }; 3693 static hda_nid_t conn_33[] = { 0x1c }; 3694 3695 snd_hda_override_conn_list(codec, 0x24, ARRAY_SIZE(conn_24), conn_24); 3696 snd_hda_override_conn_list(codec, 0x33, ARRAY_SIZE(conn_33), conn_33); 3697 } 3698 3699 /* patch for vt2002P */ 3700 static int patch_vt2002P(struct hda_codec *codec) 3701 { 3702 struct via_spec *spec; 3703 int err; 3704 3705 /* create a codec specific record */ 3706 spec = via_new_spec(codec); 3707 if (spec == NULL) 3708 return -ENOMEM; 3709 3710 spec->aa_mix_nid = 0x21; 3711 override_mic_boost(codec, 0x2b, 0, 3, 40); 3712 override_mic_boost(codec, 0x29, 0, 3, 40); 3713 if (spec->codec_type == VT1802) 3714 fix_vt1802_connections(codec); 3715 add_secret_dac_path(codec); 3716 3717 snd_hda_pick_fixup(codec, NULL, vt2002p_fixups, via_fixups); 3718 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 3719 3720 /* automatic parse from the BIOS config */ 3721 err = via_parse_auto_config(codec); 3722 if (err < 0) { 3723 via_free(codec); 3724 return err; 3725 } 3726 3727 if (spec->codec_type == VT1802) 3728 spec->init_verbs[spec->num_iverbs++] = vt1802_init_verbs; 3729 else 3730 spec->init_verbs[spec->num_iverbs++] = vt2002P_init_verbs; 3731 3732 codec->patch_ops = via_patch_ops; 3733 3734 spec->set_widgets_power_state = set_widgets_power_state_vt2002P; 3735 return 0; 3736 } 3737 3738 /* for vt1812 */ 3739 3740 static const struct hda_verb vt1812_init_verbs[] = { 3741 /* Enable Boost Volume backdoor */ 3742 {0x1, 0xfb9, 0x24}, 3743 /* Enable AOW0 to MW9 */ 3744 {0x1, 0xfb8, 0xa8}, 3745 { } 3746 }; 3747 3748 static void set_widgets_power_state_vt1812(struct hda_codec *codec) 3749 { 3750 struct via_spec *spec = codec->spec; 3751 unsigned int parm; 3752 unsigned int present; 3753 /* inputs */ 3754 /* PW 5/6/7 (29h/2ah/2bh) */ 3755 parm = AC_PWRST_D3; 3756 set_pin_power_state(codec, 0x29, &parm); 3757 set_pin_power_state(codec, 0x2a, &parm); 3758 set_pin_power_state(codec, 0x2b, &parm); 3759 parm = AC_PWRST_D0; 3760 /* MUX10/11 (1eh/1fh), AIW 0/1 (10h/11h) */ 3761 update_power_state(codec, 0x1e, parm); 3762 update_power_state(codec, 0x1f, parm); 3763 update_power_state(codec, 0x10, parm); 3764 update_power_state(codec, 0x11, parm); 3765 3766 /* outputs */ 3767 /* AOW0 (8h)*/ 3768 update_power_state(codec, 0x8, AC_PWRST_D0); 3769 3770 /* PW4 (28h), MW4 (18h), MUX4(38h) */ 3771 parm = AC_PWRST_D3; 3772 set_pin_power_state(codec, 0x28, &parm); 3773 update_power_state(codec, 0x18, parm); 3774 update_power_state(codec, 0x38, parm); 3775 3776 /* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */ 3777 parm = AC_PWRST_D3; 3778 set_pin_power_state(codec, 0x25, &parm); 3779 update_power_state(codec, 0x15, parm); 3780 update_power_state(codec, 0x35, parm); 3781 if (spec->hp_independent_mode) 3782 update_power_state(codec, 0x9, AC_PWRST_D0); 3783 3784 /* Internal Speaker */ 3785 /* PW0 (24h), MW0(14h), MUX0(34h) */ 3786 present = snd_hda_jack_detect(codec, 0x25); 3787 3788 parm = AC_PWRST_D3; 3789 set_pin_power_state(codec, 0x24, &parm); 3790 if (present) { 3791 update_power_state(codec, 0x14, AC_PWRST_D3); 3792 update_power_state(codec, 0x34, AC_PWRST_D3); 3793 } else { 3794 update_power_state(codec, 0x14, AC_PWRST_D0); 3795 update_power_state(codec, 0x34, AC_PWRST_D0); 3796 } 3797 3798 3799 /* Mono Out */ 3800 /* PW13 (31h), MW13(1ch), MUX13(3ch), MW14(3eh) */ 3801 present = snd_hda_jack_detect(codec, 0x28); 3802 3803 parm = AC_PWRST_D3; 3804 set_pin_power_state(codec, 0x31, &parm); 3805 if (present) { 3806 update_power_state(codec, 0x1c, AC_PWRST_D3); 3807 update_power_state(codec, 0x3c, AC_PWRST_D3); 3808 update_power_state(codec, 0x3e, AC_PWRST_D3); 3809 } else { 3810 update_power_state(codec, 0x1c, AC_PWRST_D0); 3811 update_power_state(codec, 0x3c, AC_PWRST_D0); 3812 update_power_state(codec, 0x3e, AC_PWRST_D0); 3813 } 3814 3815 /* PW15 (33h), MW15 (1dh), MUX15(3dh) */ 3816 parm = AC_PWRST_D3; 3817 set_pin_power_state(codec, 0x33, &parm); 3818 update_power_state(codec, 0x1d, parm); 3819 update_power_state(codec, 0x3d, parm); 3820 3821 } 3822 3823 /* patch for vt1812 */ 3824 static int patch_vt1812(struct hda_codec *codec) 3825 { 3826 struct via_spec *spec; 3827 int err; 3828 3829 /* create a codec specific record */ 3830 spec = via_new_spec(codec); 3831 if (spec == NULL) 3832 return -ENOMEM; 3833 3834 spec->aa_mix_nid = 0x21; 3835 override_mic_boost(codec, 0x2b, 0, 3, 40); 3836 override_mic_boost(codec, 0x29, 0, 3, 40); 3837 add_secret_dac_path(codec); 3838 3839 /* automatic parse from the BIOS config */ 3840 err = via_parse_auto_config(codec); 3841 if (err < 0) { 3842 via_free(codec); 3843 return err; 3844 } 3845 3846 spec->init_verbs[spec->num_iverbs++] = vt1812_init_verbs; 3847 3848 codec->patch_ops = via_patch_ops; 3849 3850 spec->set_widgets_power_state = set_widgets_power_state_vt1812; 3851 return 0; 3852 } 3853 3854 /* patch for vt3476 */ 3855 3856 static const struct hda_verb vt3476_init_verbs[] = { 3857 /* Enable DMic 8/16/32K */ 3858 {0x1, 0xF7B, 0x30}, 3859 /* Enable Boost Volume backdoor */ 3860 {0x1, 0xFB9, 0x20}, 3861 /* Enable AOW-MW9 path */ 3862 {0x1, 0xFB8, 0x10}, 3863 { } 3864 }; 3865 3866 static void set_widgets_power_state_vt3476(struct hda_codec *codec) 3867 { 3868 struct via_spec *spec = codec->spec; 3869 int imux_is_smixer; 3870 unsigned int parm, parm2; 3871 /* MUX10 (1eh) = stereo mixer */ 3872 imux_is_smixer = 3873 snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 4; 3874 /* inputs */ 3875 /* PW 5/6/7 (29h/2ah/2bh) */ 3876 parm = AC_PWRST_D3; 3877 set_pin_power_state(codec, 0x29, &parm); 3878 set_pin_power_state(codec, 0x2a, &parm); 3879 set_pin_power_state(codec, 0x2b, &parm); 3880 if (imux_is_smixer) 3881 parm = AC_PWRST_D0; 3882 /* MUX10/11 (1eh/1fh), AIW 0/1 (10h/11h) */ 3883 update_power_state(codec, 0x1e, parm); 3884 update_power_state(codec, 0x1f, parm); 3885 update_power_state(codec, 0x10, parm); 3886 update_power_state(codec, 0x11, parm); 3887 3888 /* outputs */ 3889 /* PW3 (27h), MW3(37h), AOW3 (bh) */ 3890 if (spec->codec_type == VT1705CF) { 3891 parm = AC_PWRST_D3; 3892 update_power_state(codec, 0x27, parm); 3893 update_power_state(codec, 0x37, parm); 3894 } else { 3895 parm = AC_PWRST_D3; 3896 set_pin_power_state(codec, 0x27, &parm); 3897 update_power_state(codec, 0x37, parm); 3898 } 3899 3900 /* PW2 (26h), MW2(36h), AOW2 (ah) */ 3901 parm = AC_PWRST_D3; 3902 set_pin_power_state(codec, 0x26, &parm); 3903 update_power_state(codec, 0x36, parm); 3904 if (spec->smart51_enabled) { 3905 /* PW7(2bh), MW7(3bh), MUX7(1Bh) */ 3906 set_pin_power_state(codec, 0x2b, &parm); 3907 update_power_state(codec, 0x3b, parm); 3908 update_power_state(codec, 0x1b, parm); 3909 } 3910 update_conv_power_state(codec, 0xa, parm, 2); 3911 3912 /* PW1 (25h), MW1(35h), AOW1 (9h) */ 3913 parm = AC_PWRST_D3; 3914 set_pin_power_state(codec, 0x25, &parm); 3915 update_power_state(codec, 0x35, parm); 3916 if (spec->smart51_enabled) { 3917 /* PW6(2ah), MW6(3ah), MUX6(1ah) */ 3918 set_pin_power_state(codec, 0x2a, &parm); 3919 update_power_state(codec, 0x3a, parm); 3920 update_power_state(codec, 0x1a, parm); 3921 } 3922 update_conv_power_state(codec, 0x9, parm, 1); 3923 3924 /* PW4 (28h), MW4 (38h), MUX4(18h), AOW3(bh)/AOW0(8h) */ 3925 parm = AC_PWRST_D3; 3926 set_pin_power_state(codec, 0x28, &parm); 3927 update_power_state(codec, 0x38, parm); 3928 update_power_state(codec, 0x18, parm); 3929 if (spec->hp_independent_mode) 3930 update_conv_power_state(codec, 0xb, parm, 3); 3931 parm2 = parm; /* for pin 0x0b */ 3932 3933 /* PW0 (24h), MW0(34h), MW9(3fh), AOW0 (8h) */ 3934 parm = AC_PWRST_D3; 3935 set_pin_power_state(codec, 0x24, &parm); 3936 update_power_state(codec, 0x34, parm); 3937 if (!spec->hp_independent_mode && parm2 != AC_PWRST_D3) 3938 parm = parm2; 3939 update_conv_power_state(codec, 0x8, parm, 0); 3940 /* MW9 (21h), Mw2 (1ah), AOW0 (8h) */ 3941 update_power_state(codec, 0x3f, imux_is_smixer ? AC_PWRST_D0 : parm); 3942 } 3943 3944 static int patch_vt3476(struct hda_codec *codec) 3945 { 3946 struct via_spec *spec; 3947 int err; 3948 3949 /* create a codec specific record */ 3950 spec = via_new_spec(codec); 3951 if (spec == NULL) 3952 return -ENOMEM; 3953 3954 spec->aa_mix_nid = 0x3f; 3955 add_secret_dac_path(codec); 3956 3957 /* automatic parse from the BIOS config */ 3958 err = via_parse_auto_config(codec); 3959 if (err < 0) { 3960 via_free(codec); 3961 return err; 3962 } 3963 3964 spec->init_verbs[spec->num_iverbs++] = vt3476_init_verbs; 3965 3966 codec->patch_ops = via_patch_ops; 3967 3968 spec->set_widgets_power_state = set_widgets_power_state_vt3476; 3969 3970 return 0; 3971 } 3972 3973 /* 3974 * patch entries 3975 */ 3976 static const struct hda_codec_preset snd_hda_preset_via[] = { 3977 { .id = 0x11061708, .name = "VT1708", .patch = patch_vt1708}, 3978 { .id = 0x11061709, .name = "VT1708", .patch = patch_vt1708}, 3979 { .id = 0x1106170a, .name = "VT1708", .patch = patch_vt1708}, 3980 { .id = 0x1106170b, .name = "VT1708", .patch = patch_vt1708}, 3981 { .id = 0x1106e710, .name = "VT1709 10-Ch", 3982 .patch = patch_vt1709}, 3983 { .id = 0x1106e711, .name = "VT1709 10-Ch", 3984 .patch = patch_vt1709}, 3985 { .id = 0x1106e712, .name = "VT1709 10-Ch", 3986 .patch = patch_vt1709}, 3987 { .id = 0x1106e713, .name = "VT1709 10-Ch", 3988 .patch = patch_vt1709}, 3989 { .id = 0x1106e714, .name = "VT1709 6-Ch", 3990 .patch = patch_vt1709}, 3991 { .id = 0x1106e715, .name = "VT1709 6-Ch", 3992 .patch = patch_vt1709}, 3993 { .id = 0x1106e716, .name = "VT1709 6-Ch", 3994 .patch = patch_vt1709}, 3995 { .id = 0x1106e717, .name = "VT1709 6-Ch", 3996 .patch = patch_vt1709}, 3997 { .id = 0x1106e720, .name = "VT1708B 8-Ch", 3998 .patch = patch_vt1708B}, 3999 { .id = 0x1106e721, .name = "VT1708B 8-Ch", 4000 .patch = patch_vt1708B}, 4001 { .id = 0x1106e722, .name = "VT1708B 8-Ch", 4002 .patch = patch_vt1708B}, 4003 { .id = 0x1106e723, .name = "VT1708B 8-Ch", 4004 .patch = patch_vt1708B}, 4005 { .id = 0x1106e724, .name = "VT1708B 4-Ch", 4006 .patch = patch_vt1708B}, 4007 { .id = 0x1106e725, .name = "VT1708B 4-Ch", 4008 .patch = patch_vt1708B}, 4009 { .id = 0x1106e726, .name = "VT1708B 4-Ch", 4010 .patch = patch_vt1708B}, 4011 { .id = 0x1106e727, .name = "VT1708B 4-Ch", 4012 .patch = patch_vt1708B}, 4013 { .id = 0x11060397, .name = "VT1708S", 4014 .patch = patch_vt1708S}, 4015 { .id = 0x11061397, .name = "VT1708S", 4016 .patch = patch_vt1708S}, 4017 { .id = 0x11062397, .name = "VT1708S", 4018 .patch = patch_vt1708S}, 4019 { .id = 0x11063397, .name = "VT1708S", 4020 .patch = patch_vt1708S}, 4021 { .id = 0x11064397, .name = "VT1705", 4022 .patch = patch_vt1708S}, 4023 { .id = 0x11065397, .name = "VT1708S", 4024 .patch = patch_vt1708S}, 4025 { .id = 0x11066397, .name = "VT1708S", 4026 .patch = patch_vt1708S}, 4027 { .id = 0x11067397, .name = "VT1708S", 4028 .patch = patch_vt1708S}, 4029 { .id = 0x11060398, .name = "VT1702", 4030 .patch = patch_vt1702}, 4031 { .id = 0x11061398, .name = "VT1702", 4032 .patch = patch_vt1702}, 4033 { .id = 0x11062398, .name = "VT1702", 4034 .patch = patch_vt1702}, 4035 { .id = 0x11063398, .name = "VT1702", 4036 .patch = patch_vt1702}, 4037 { .id = 0x11064398, .name = "VT1702", 4038 .patch = patch_vt1702}, 4039 { .id = 0x11065398, .name = "VT1702", 4040 .patch = patch_vt1702}, 4041 { .id = 0x11066398, .name = "VT1702", 4042 .patch = patch_vt1702}, 4043 { .id = 0x11067398, .name = "VT1702", 4044 .patch = patch_vt1702}, 4045 { .id = 0x11060428, .name = "VT1718S", 4046 .patch = patch_vt1718S}, 4047 { .id = 0x11064428, .name = "VT1718S", 4048 .patch = patch_vt1718S}, 4049 { .id = 0x11060441, .name = "VT2020", 4050 .patch = patch_vt1718S}, 4051 { .id = 0x11064441, .name = "VT1828S", 4052 .patch = patch_vt1718S}, 4053 { .id = 0x11060433, .name = "VT1716S", 4054 .patch = patch_vt1716S}, 4055 { .id = 0x1106a721, .name = "VT1716S", 4056 .patch = patch_vt1716S}, 4057 { .id = 0x11060438, .name = "VT2002P", .patch = patch_vt2002P}, 4058 { .id = 0x11064438, .name = "VT2002P", .patch = patch_vt2002P}, 4059 { .id = 0x11060448, .name = "VT1812", .patch = patch_vt1812}, 4060 { .id = 0x11060440, .name = "VT1818S", 4061 .patch = patch_vt1708S}, 4062 { .id = 0x11060446, .name = "VT1802", 4063 .patch = patch_vt2002P}, 4064 { .id = 0x11068446, .name = "VT1802", 4065 .patch = patch_vt2002P}, 4066 { .id = 0x11064760, .name = "VT1705CF", 4067 .patch = patch_vt3476}, 4068 { .id = 0x11064761, .name = "VT1708SCE", 4069 .patch = patch_vt3476}, 4070 { .id = 0x11064762, .name = "VT1808", 4071 .patch = patch_vt3476}, 4072 {} /* terminator */ 4073 }; 4074 4075 MODULE_ALIAS("snd-hda-codec-id:1106*"); 4076 4077 static struct hda_codec_preset_list via_list = { 4078 .preset = snd_hda_preset_via, 4079 .owner = THIS_MODULE, 4080 }; 4081 4082 MODULE_LICENSE("GPL"); 4083 MODULE_DESCRIPTION("VIA HD-audio codec"); 4084 4085 static int __init patch_via_init(void) 4086 { 4087 return snd_hda_add_codec_preset(&via_list); 4088 } 4089 4090 static void __exit patch_via_exit(void) 4091 { 4092 snd_hda_delete_codec_preset(&via_list); 4093 } 4094 4095 module_init(patch_via_init) 4096 module_exit(patch_via_exit) 4097