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